42559 lines
1.5 MiB
42559 lines
1.5 MiB
import { createRequire } from "node:module";
|
|
var __create = Object.create;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => mod[key],
|
|
enumerable: true
|
|
});
|
|
return to;
|
|
};
|
|
var __moduleCache = /* @__PURE__ */ new WeakMap;
|
|
var __toCommonJS = (from) => {
|
|
var entry = __moduleCache.get(from), desc;
|
|
if (entry)
|
|
return entry;
|
|
entry = __defProp({}, "__esModule", { value: true });
|
|
if (from && typeof from === "object" || typeof from === "function")
|
|
__getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
|
|
get: () => from[key],
|
|
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
}));
|
|
__moduleCache.set(from, entry);
|
|
return entry;
|
|
};
|
|
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: (newValue) => all[name] = () => newValue
|
|
});
|
|
};
|
|
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
|
|
var __require = /* @__PURE__ */ createRequire(import.meta.url);
|
|
|
|
// package-shared/utils/grab-host-names.ts
|
|
import https from "https";
|
|
import http from "http";
|
|
function grabHostNames() {
|
|
const scheme = process.env.DSQL_HTTP_SCHEME;
|
|
const localHost = process.env.DSQL_LOCAL_HOST;
|
|
const localHostPort = process.env.DSQL_LOCAL_HOST_PORT;
|
|
const remoteHost = process.env.DSQL_API_REMOTE_HOST?.match(/.*\..*/) ? process.env.DSQL_API_REMOTE_HOST : undefined;
|
|
const remoteHostPort = process.env.DSQL_API_REMOTE_HOST_PORT?.match(/./) ? process.env.DSQL_API_REMOTE_HOST_PORT : undefined;
|
|
return {
|
|
host: remoteHost || localHost || "datasquirel.com",
|
|
port: remoteHostPort || localHostPort || 443,
|
|
scheme: scheme?.match(/^http$/i) ? http : https,
|
|
user_id: String(process.env.DSQL_API_USER_ID || 0)
|
|
};
|
|
}
|
|
var init_grab_host_names = () => {
|
|
};
|
|
|
|
// node_modules/lodash/lodash.js
|
|
var require_lodash = __commonJS((exports, module) => {
|
|
(function() {
|
|
var undefined2;
|
|
var VERSION = "4.17.21";
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
|
|
var HASH_UNDEFINED = "__lodash_hash_undefined__";
|
|
var MAX_MEMOIZE_SIZE = 500;
|
|
var PLACEHOLDER = "__lodash_placeholder__";
|
|
var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
|
|
var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
|
|
var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
|
|
var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "...";
|
|
var HOT_COUNT = 800, HOT_SPAN = 16;
|
|
var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;
|
|
var INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, NAN = 0 / 0;
|
|
var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
|
|
var wrapFlags = [
|
|
["ary", WRAP_ARY_FLAG],
|
|
["bind", WRAP_BIND_FLAG],
|
|
["bindKey", WRAP_BIND_KEY_FLAG],
|
|
["curry", WRAP_CURRY_FLAG],
|
|
["curryRight", WRAP_CURRY_RIGHT_FLAG],
|
|
["flip", WRAP_FLIP_FLAG],
|
|
["partial", WRAP_PARTIAL_FLAG],
|
|
["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
|
|
["rearg", WRAP_REARG_FLAG]
|
|
];
|
|
var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", domExcTag = "[object DOMException]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]", weakSetTag = "[object WeakSet]";
|
|
var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
|
|
var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
|
|
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
|
|
var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g;
|
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);
|
|
var reTrimStart = /^\s+/;
|
|
var reWhitespace = /\s/;
|
|
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
|
|
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
|
|
var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
|
|
var reEscapeChar = /\\(\\)?/g;
|
|
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
|
|
var reFlags = /\w*$/;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
|
|
var reNoMatch = /($^)/;
|
|
var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
|
|
var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
|
|
var rsApos = "['\u2019]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
|
|
var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
|
|
var reApos = RegExp(rsApos, "g");
|
|
var reComboMark = RegExp(rsCombo, "g");
|
|
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
|
|
var reUnicodeWord = RegExp([
|
|
rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
|
|
rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
|
|
rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
|
|
rsUpper + "+" + rsOptContrUpper,
|
|
rsOrdUpper,
|
|
rsOrdLower,
|
|
rsDigits,
|
|
rsEmoji
|
|
].join("|"), "g");
|
|
var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
|
|
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
|
|
var contextProps = [
|
|
"Array",
|
|
"Buffer",
|
|
"DataView",
|
|
"Date",
|
|
"Error",
|
|
"Float32Array",
|
|
"Float64Array",
|
|
"Function",
|
|
"Int8Array",
|
|
"Int16Array",
|
|
"Int32Array",
|
|
"Map",
|
|
"Math",
|
|
"Object",
|
|
"Promise",
|
|
"RegExp",
|
|
"Set",
|
|
"String",
|
|
"Symbol",
|
|
"TypeError",
|
|
"Uint8Array",
|
|
"Uint8ClampedArray",
|
|
"Uint16Array",
|
|
"Uint32Array",
|
|
"WeakMap",
|
|
"_",
|
|
"clearTimeout",
|
|
"isFinite",
|
|
"parseInt",
|
|
"setTimeout"
|
|
];
|
|
var templateCounter = -1;
|
|
var typedArrayTags = {};
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
|
|
typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
|
var cloneableTags = {};
|
|
cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
|
|
cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
|
|
var deburredLetters = {
|
|
"\xC0": "A",
|
|
"\xC1": "A",
|
|
"\xC2": "A",
|
|
"\xC3": "A",
|
|
"\xC4": "A",
|
|
"\xC5": "A",
|
|
"\xE0": "a",
|
|
"\xE1": "a",
|
|
"\xE2": "a",
|
|
"\xE3": "a",
|
|
"\xE4": "a",
|
|
"\xE5": "a",
|
|
"\xC7": "C",
|
|
"\xE7": "c",
|
|
"\xD0": "D",
|
|
"\xF0": "d",
|
|
"\xC8": "E",
|
|
"\xC9": "E",
|
|
"\xCA": "E",
|
|
"\xCB": "E",
|
|
"\xE8": "e",
|
|
"\xE9": "e",
|
|
"\xEA": "e",
|
|
"\xEB": "e",
|
|
"\xCC": "I",
|
|
"\xCD": "I",
|
|
"\xCE": "I",
|
|
"\xCF": "I",
|
|
"\xEC": "i",
|
|
"\xED": "i",
|
|
"\xEE": "i",
|
|
"\xEF": "i",
|
|
"\xD1": "N",
|
|
"\xF1": "n",
|
|
"\xD2": "O",
|
|
"\xD3": "O",
|
|
"\xD4": "O",
|
|
"\xD5": "O",
|
|
"\xD6": "O",
|
|
"\xD8": "O",
|
|
"\xF2": "o",
|
|
"\xF3": "o",
|
|
"\xF4": "o",
|
|
"\xF5": "o",
|
|
"\xF6": "o",
|
|
"\xF8": "o",
|
|
"\xD9": "U",
|
|
"\xDA": "U",
|
|
"\xDB": "U",
|
|
"\xDC": "U",
|
|
"\xF9": "u",
|
|
"\xFA": "u",
|
|
"\xFB": "u",
|
|
"\xFC": "u",
|
|
"\xDD": "Y",
|
|
"\xFD": "y",
|
|
"\xFF": "y",
|
|
"\xC6": "Ae",
|
|
"\xE6": "ae",
|
|
"\xDE": "Th",
|
|
"\xFE": "th",
|
|
"\xDF": "ss",
|
|
"\u0100": "A",
|
|
"\u0102": "A",
|
|
"\u0104": "A",
|
|
"\u0101": "a",
|
|
"\u0103": "a",
|
|
"\u0105": "a",
|
|
"\u0106": "C",
|
|
"\u0108": "C",
|
|
"\u010A": "C",
|
|
"\u010C": "C",
|
|
"\u0107": "c",
|
|
"\u0109": "c",
|
|
"\u010B": "c",
|
|
"\u010D": "c",
|
|
"\u010E": "D",
|
|
"\u0110": "D",
|
|
"\u010F": "d",
|
|
"\u0111": "d",
|
|
"\u0112": "E",
|
|
"\u0114": "E",
|
|
"\u0116": "E",
|
|
"\u0118": "E",
|
|
"\u011A": "E",
|
|
"\u0113": "e",
|
|
"\u0115": "e",
|
|
"\u0117": "e",
|
|
"\u0119": "e",
|
|
"\u011B": "e",
|
|
"\u011C": "G",
|
|
"\u011E": "G",
|
|
"\u0120": "G",
|
|
"\u0122": "G",
|
|
"\u011D": "g",
|
|
"\u011F": "g",
|
|
"\u0121": "g",
|
|
"\u0123": "g",
|
|
"\u0124": "H",
|
|
"\u0126": "H",
|
|
"\u0125": "h",
|
|
"\u0127": "h",
|
|
"\u0128": "I",
|
|
"\u012A": "I",
|
|
"\u012C": "I",
|
|
"\u012E": "I",
|
|
"\u0130": "I",
|
|
"\u0129": "i",
|
|
"\u012B": "i",
|
|
"\u012D": "i",
|
|
"\u012F": "i",
|
|
"\u0131": "i",
|
|
"\u0134": "J",
|
|
"\u0135": "j",
|
|
"\u0136": "K",
|
|
"\u0137": "k",
|
|
"\u0138": "k",
|
|
"\u0139": "L",
|
|
"\u013B": "L",
|
|
"\u013D": "L",
|
|
"\u013F": "L",
|
|
"\u0141": "L",
|
|
"\u013A": "l",
|
|
"\u013C": "l",
|
|
"\u013E": "l",
|
|
"\u0140": "l",
|
|
"\u0142": "l",
|
|
"\u0143": "N",
|
|
"\u0145": "N",
|
|
"\u0147": "N",
|
|
"\u014A": "N",
|
|
"\u0144": "n",
|
|
"\u0146": "n",
|
|
"\u0148": "n",
|
|
"\u014B": "n",
|
|
"\u014C": "O",
|
|
"\u014E": "O",
|
|
"\u0150": "O",
|
|
"\u014D": "o",
|
|
"\u014F": "o",
|
|
"\u0151": "o",
|
|
"\u0154": "R",
|
|
"\u0156": "R",
|
|
"\u0158": "R",
|
|
"\u0155": "r",
|
|
"\u0157": "r",
|
|
"\u0159": "r",
|
|
"\u015A": "S",
|
|
"\u015C": "S",
|
|
"\u015E": "S",
|
|
"\u0160": "S",
|
|
"\u015B": "s",
|
|
"\u015D": "s",
|
|
"\u015F": "s",
|
|
"\u0161": "s",
|
|
"\u0162": "T",
|
|
"\u0164": "T",
|
|
"\u0166": "T",
|
|
"\u0163": "t",
|
|
"\u0165": "t",
|
|
"\u0167": "t",
|
|
"\u0168": "U",
|
|
"\u016A": "U",
|
|
"\u016C": "U",
|
|
"\u016E": "U",
|
|
"\u0170": "U",
|
|
"\u0172": "U",
|
|
"\u0169": "u",
|
|
"\u016B": "u",
|
|
"\u016D": "u",
|
|
"\u016F": "u",
|
|
"\u0171": "u",
|
|
"\u0173": "u",
|
|
"\u0174": "W",
|
|
"\u0175": "w",
|
|
"\u0176": "Y",
|
|
"\u0177": "y",
|
|
"\u0178": "Y",
|
|
"\u0179": "Z",
|
|
"\u017B": "Z",
|
|
"\u017D": "Z",
|
|
"\u017A": "z",
|
|
"\u017C": "z",
|
|
"\u017E": "z",
|
|
"\u0132": "IJ",
|
|
"\u0133": "ij",
|
|
"\u0152": "Oe",
|
|
"\u0153": "oe",
|
|
"\u0149": "'n",
|
|
"\u017F": "s"
|
|
};
|
|
var htmlEscapes = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'"
|
|
};
|
|
var htmlUnescapes = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
""": '"',
|
|
"'": "'"
|
|
};
|
|
var stringEscapes = {
|
|
"\\": "\\",
|
|
"'": "'",
|
|
"\n": "n",
|
|
"\r": "r",
|
|
"\u2028": "u2028",
|
|
"\u2029": "u2029"
|
|
};
|
|
var freeParseFloat = parseFloat, freeParseInt = parseInt;
|
|
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
|
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
|
var root = freeGlobal || freeSelf || Function("return this")();
|
|
var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
var freeProcess = moduleExports && freeGlobal.process;
|
|
var nodeUtil = function() {
|
|
try {
|
|
var types = freeModule && freeModule.require && freeModule.require("util").types;
|
|
if (types) {
|
|
return types;
|
|
}
|
|
return freeProcess && freeProcess.binding && freeProcess.binding("util");
|
|
} catch (e) {
|
|
}
|
|
}();
|
|
var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
|
|
function apply(func, thisArg, args) {
|
|
switch (args.length) {
|
|
case 0:
|
|
return func.call(thisArg);
|
|
case 1:
|
|
return func.call(thisArg, args[0]);
|
|
case 2:
|
|
return func.call(thisArg, args[0], args[1]);
|
|
case 3:
|
|
return func.call(thisArg, args[0], args[1], args[2]);
|
|
}
|
|
return func.apply(thisArg, args);
|
|
}
|
|
function arrayAggregator(array, setter, iteratee, accumulator) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
setter(accumulator, value, iteratee(value), array);
|
|
}
|
|
return accumulator;
|
|
}
|
|
function arrayEach(array, iteratee) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (iteratee(array[index], index, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function arrayEachRight(array, iteratee) {
|
|
var length = array == null ? 0 : array.length;
|
|
while (length--) {
|
|
if (iteratee(array[length], length, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function arrayEvery(array, predicate) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (!predicate(array[index], index, array)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function arrayFilter(array, predicate) {
|
|
var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (predicate(value, index, array)) {
|
|
result[resIndex++] = value;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function arrayIncludes(array, value) {
|
|
var length = array == null ? 0 : array.length;
|
|
return !!length && baseIndexOf(array, value, 0) > -1;
|
|
}
|
|
function arrayIncludesWith(array, value, comparator) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (comparator(value, array[index])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function arrayMap(array, iteratee) {
|
|
var index = -1, length = array == null ? 0 : array.length, result = Array(length);
|
|
while (++index < length) {
|
|
result[index] = iteratee(array[index], index, array);
|
|
}
|
|
return result;
|
|
}
|
|
function arrayPush(array, values) {
|
|
var index = -1, length = values.length, offset = array.length;
|
|
while (++index < length) {
|
|
array[offset + index] = values[index];
|
|
}
|
|
return array;
|
|
}
|
|
function arrayReduce(array, iteratee, accumulator, initAccum) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
if (initAccum && length) {
|
|
accumulator = array[++index];
|
|
}
|
|
while (++index < length) {
|
|
accumulator = iteratee(accumulator, array[index], index, array);
|
|
}
|
|
return accumulator;
|
|
}
|
|
function arrayReduceRight(array, iteratee, accumulator, initAccum) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (initAccum && length) {
|
|
accumulator = array[--length];
|
|
}
|
|
while (length--) {
|
|
accumulator = iteratee(accumulator, array[length], length, array);
|
|
}
|
|
return accumulator;
|
|
}
|
|
function arraySome(array, predicate) {
|
|
var index = -1, length = array == null ? 0 : array.length;
|
|
while (++index < length) {
|
|
if (predicate(array[index], index, array)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var asciiSize = baseProperty("length");
|
|
function asciiToArray(string) {
|
|
return string.split("");
|
|
}
|
|
function asciiWords(string) {
|
|
return string.match(reAsciiWord) || [];
|
|
}
|
|
function baseFindKey(collection, predicate, eachFunc) {
|
|
var result;
|
|
eachFunc(collection, function(value, key, collection2) {
|
|
if (predicate(value, key, collection2)) {
|
|
result = key;
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function baseFindIndex(array, predicate, fromIndex, fromRight) {
|
|
var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
|
|
while (fromRight ? index-- : ++index < length) {
|
|
if (predicate(array[index], index, array)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseIndexOf(array, value, fromIndex) {
|
|
return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
|
|
}
|
|
function baseIndexOfWith(array, value, fromIndex, comparator) {
|
|
var index = fromIndex - 1, length = array.length;
|
|
while (++index < length) {
|
|
if (comparator(array[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseIsNaN(value) {
|
|
return value !== value;
|
|
}
|
|
function baseMean(array, iteratee) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? baseSum(array, iteratee) / length : NAN;
|
|
}
|
|
function baseProperty(key) {
|
|
return function(object) {
|
|
return object == null ? undefined2 : object[key];
|
|
};
|
|
}
|
|
function basePropertyOf(object) {
|
|
return function(key) {
|
|
return object == null ? undefined2 : object[key];
|
|
};
|
|
}
|
|
function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
|
|
eachFunc(collection, function(value, index, collection2) {
|
|
accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
function baseSortBy(array, comparer) {
|
|
var length = array.length;
|
|
array.sort(comparer);
|
|
while (length--) {
|
|
array[length] = array[length].value;
|
|
}
|
|
return array;
|
|
}
|
|
function baseSum(array, iteratee) {
|
|
var result, index = -1, length = array.length;
|
|
while (++index < length) {
|
|
var current = iteratee(array[index]);
|
|
if (current !== undefined2) {
|
|
result = result === undefined2 ? current : result + current;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function baseTimes(n, iteratee) {
|
|
var index = -1, result = Array(n);
|
|
while (++index < n) {
|
|
result[index] = iteratee(index);
|
|
}
|
|
return result;
|
|
}
|
|
function baseToPairs(object, props) {
|
|
return arrayMap(props, function(key) {
|
|
return [key, object[key]];
|
|
});
|
|
}
|
|
function baseTrim(string) {
|
|
return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
|
|
}
|
|
function baseUnary(func) {
|
|
return function(value) {
|
|
return func(value);
|
|
};
|
|
}
|
|
function baseValues(object, props) {
|
|
return arrayMap(props, function(key) {
|
|
return object[key];
|
|
});
|
|
}
|
|
function cacheHas(cache, key) {
|
|
return cache.has(key);
|
|
}
|
|
function charsStartIndex(strSymbols, chrSymbols) {
|
|
var index = -1, length = strSymbols.length;
|
|
while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
|
|
}
|
|
return index;
|
|
}
|
|
function charsEndIndex(strSymbols, chrSymbols) {
|
|
var index = strSymbols.length;
|
|
while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
|
|
}
|
|
return index;
|
|
}
|
|
function countHolders(array, placeholder) {
|
|
var length = array.length, result = 0;
|
|
while (length--) {
|
|
if (array[length] === placeholder) {
|
|
++result;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var deburrLetter = basePropertyOf(deburredLetters);
|
|
var escapeHtmlChar = basePropertyOf(htmlEscapes);
|
|
function escapeStringChar(chr) {
|
|
return "\\" + stringEscapes[chr];
|
|
}
|
|
function getValue(object, key) {
|
|
return object == null ? undefined2 : object[key];
|
|
}
|
|
function hasUnicode(string) {
|
|
return reHasUnicode.test(string);
|
|
}
|
|
function hasUnicodeWord(string) {
|
|
return reHasUnicodeWord.test(string);
|
|
}
|
|
function iteratorToArray(iterator) {
|
|
var data, result = [];
|
|
while (!(data = iterator.next()).done) {
|
|
result.push(data.value);
|
|
}
|
|
return result;
|
|
}
|
|
function mapToArray(map) {
|
|
var index = -1, result = Array(map.size);
|
|
map.forEach(function(value, key) {
|
|
result[++index] = [key, value];
|
|
});
|
|
return result;
|
|
}
|
|
function overArg(func, transform) {
|
|
return function(arg) {
|
|
return func(transform(arg));
|
|
};
|
|
}
|
|
function replaceHolders(array, placeholder) {
|
|
var index = -1, length = array.length, resIndex = 0, result = [];
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (value === placeholder || value === PLACEHOLDER) {
|
|
array[index] = PLACEHOLDER;
|
|
result[resIndex++] = index;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function setToArray(set) {
|
|
var index = -1, result = Array(set.size);
|
|
set.forEach(function(value) {
|
|
result[++index] = value;
|
|
});
|
|
return result;
|
|
}
|
|
function setToPairs(set) {
|
|
var index = -1, result = Array(set.size);
|
|
set.forEach(function(value) {
|
|
result[++index] = [value, value];
|
|
});
|
|
return result;
|
|
}
|
|
function strictIndexOf(array, value, fromIndex) {
|
|
var index = fromIndex - 1, length = array.length;
|
|
while (++index < length) {
|
|
if (array[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function strictLastIndexOf(array, value, fromIndex) {
|
|
var index = fromIndex + 1;
|
|
while (index--) {
|
|
if (array[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
function stringSize(string) {
|
|
return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
|
|
}
|
|
function stringToArray(string) {
|
|
return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
|
|
}
|
|
function trimmedEndIndex(string) {
|
|
var index = string.length;
|
|
while (index-- && reWhitespace.test(string.charAt(index))) {
|
|
}
|
|
return index;
|
|
}
|
|
var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
|
|
function unicodeSize(string) {
|
|
var result = reUnicode.lastIndex = 0;
|
|
while (reUnicode.test(string)) {
|
|
++result;
|
|
}
|
|
return result;
|
|
}
|
|
function unicodeToArray(string) {
|
|
return string.match(reUnicode) || [];
|
|
}
|
|
function unicodeWords(string) {
|
|
return string.match(reUnicodeWord) || [];
|
|
}
|
|
var runInContext = function runInContext(context) {
|
|
context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
|
|
var { Array: Array2, Date: Date2, Error: Error2, Function: Function2, Math: Math2, Object: Object2, RegExp: RegExp2, String: String2, TypeError: TypeError2 } = context;
|
|
var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
|
|
var coreJsData = context["__core-js_shared__"];
|
|
var funcToString = funcProto.toString;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var idCounter = 0;
|
|
var maskSrcKey = function() {
|
|
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
|
|
return uid ? "Symbol(src)_1." + uid : "";
|
|
}();
|
|
var nativeObjectToString = objectProto.toString;
|
|
var objectCtorString = funcToString.call(Object2);
|
|
var oldDash = root._;
|
|
var reIsNative = RegExp2("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
|
|
var Buffer2 = moduleExports ? context.Buffer : undefined2, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined2, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined2, symIterator = Symbol2 ? Symbol2.iterator : undefined2, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined2;
|
|
var defineProperty = function() {
|
|
try {
|
|
var func = getNative(Object2, "defineProperty");
|
|
func({}, "", {});
|
|
return func;
|
|
} catch (e) {
|
|
}
|
|
}();
|
|
var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
|
|
var { ceil: nativeCeil, floor: nativeFloor } = Math2, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
|
|
var DataView = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap2 = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
|
|
var metaMap = WeakMap2 && new WeakMap2;
|
|
var realNames = {};
|
|
var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
|
|
var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2;
|
|
function lodash(value) {
|
|
if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
|
|
if (value instanceof LodashWrapper) {
|
|
return value;
|
|
}
|
|
if (hasOwnProperty.call(value, "__wrapped__")) {
|
|
return wrapperClone(value);
|
|
}
|
|
}
|
|
return new LodashWrapper(value);
|
|
}
|
|
var baseCreate = function() {
|
|
function object() {
|
|
}
|
|
return function(proto) {
|
|
if (!isObject(proto)) {
|
|
return {};
|
|
}
|
|
if (objectCreate) {
|
|
return objectCreate(proto);
|
|
}
|
|
object.prototype = proto;
|
|
var result2 = new object;
|
|
object.prototype = undefined2;
|
|
return result2;
|
|
};
|
|
}();
|
|
function baseLodash() {
|
|
}
|
|
function LodashWrapper(value, chainAll) {
|
|
this.__wrapped__ = value;
|
|
this.__actions__ = [];
|
|
this.__chain__ = !!chainAll;
|
|
this.__index__ = 0;
|
|
this.__values__ = undefined2;
|
|
}
|
|
lodash.templateSettings = {
|
|
escape: reEscape,
|
|
evaluate: reEvaluate,
|
|
interpolate: reInterpolate,
|
|
variable: "",
|
|
imports: {
|
|
_: lodash
|
|
}
|
|
};
|
|
lodash.prototype = baseLodash.prototype;
|
|
lodash.prototype.constructor = lodash;
|
|
LodashWrapper.prototype = baseCreate(baseLodash.prototype);
|
|
LodashWrapper.prototype.constructor = LodashWrapper;
|
|
function LazyWrapper(value) {
|
|
this.__wrapped__ = value;
|
|
this.__actions__ = [];
|
|
this.__dir__ = 1;
|
|
this.__filtered__ = false;
|
|
this.__iteratees__ = [];
|
|
this.__takeCount__ = MAX_ARRAY_LENGTH;
|
|
this.__views__ = [];
|
|
}
|
|
function lazyClone() {
|
|
var result2 = new LazyWrapper(this.__wrapped__);
|
|
result2.__actions__ = copyArray(this.__actions__);
|
|
result2.__dir__ = this.__dir__;
|
|
result2.__filtered__ = this.__filtered__;
|
|
result2.__iteratees__ = copyArray(this.__iteratees__);
|
|
result2.__takeCount__ = this.__takeCount__;
|
|
result2.__views__ = copyArray(this.__views__);
|
|
return result2;
|
|
}
|
|
function lazyReverse() {
|
|
if (this.__filtered__) {
|
|
var result2 = new LazyWrapper(this);
|
|
result2.__dir__ = -1;
|
|
result2.__filtered__ = true;
|
|
} else {
|
|
result2 = this.clone();
|
|
result2.__dir__ *= -1;
|
|
}
|
|
return result2;
|
|
}
|
|
function lazyValue() {
|
|
var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);
|
|
if (!isArr || !isRight && arrLength == length && takeCount == length) {
|
|
return baseWrapperValue(array, this.__actions__);
|
|
}
|
|
var result2 = [];
|
|
outer:
|
|
while (length-- && resIndex < takeCount) {
|
|
index += dir;
|
|
var iterIndex = -1, value = array[index];
|
|
while (++iterIndex < iterLength) {
|
|
var data = iteratees[iterIndex], iteratee2 = data.iteratee, type = data.type, computed = iteratee2(value);
|
|
if (type == LAZY_MAP_FLAG) {
|
|
value = computed;
|
|
} else if (!computed) {
|
|
if (type == LAZY_FILTER_FLAG) {
|
|
continue outer;
|
|
} else {
|
|
break outer;
|
|
}
|
|
}
|
|
}
|
|
result2[resIndex++] = value;
|
|
}
|
|
return result2;
|
|
}
|
|
LazyWrapper.prototype = baseCreate(baseLodash.prototype);
|
|
LazyWrapper.prototype.constructor = LazyWrapper;
|
|
function Hash(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function hashClear() {
|
|
this.__data__ = nativeCreate ? nativeCreate(null) : {};
|
|
this.size = 0;
|
|
}
|
|
function hashDelete(key) {
|
|
var result2 = this.has(key) && delete this.__data__[key];
|
|
this.size -= result2 ? 1 : 0;
|
|
return result2;
|
|
}
|
|
function hashGet(key) {
|
|
var data = this.__data__;
|
|
if (nativeCreate) {
|
|
var result2 = data[key];
|
|
return result2 === HASH_UNDEFINED ? undefined2 : result2;
|
|
}
|
|
return hasOwnProperty.call(data, key) ? data[key] : undefined2;
|
|
}
|
|
function hashHas(key) {
|
|
var data = this.__data__;
|
|
return nativeCreate ? data[key] !== undefined2 : hasOwnProperty.call(data, key);
|
|
}
|
|
function hashSet(key, value) {
|
|
var data = this.__data__;
|
|
this.size += this.has(key) ? 0 : 1;
|
|
data[key] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value;
|
|
return this;
|
|
}
|
|
Hash.prototype.clear = hashClear;
|
|
Hash.prototype["delete"] = hashDelete;
|
|
Hash.prototype.get = hashGet;
|
|
Hash.prototype.has = hashHas;
|
|
Hash.prototype.set = hashSet;
|
|
function ListCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function listCacheClear() {
|
|
this.__data__ = [];
|
|
this.size = 0;
|
|
}
|
|
function listCacheDelete(key) {
|
|
var data = this.__data__, index = assocIndexOf(data, key);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
var lastIndex = data.length - 1;
|
|
if (index == lastIndex) {
|
|
data.pop();
|
|
} else {
|
|
splice.call(data, index, 1);
|
|
}
|
|
--this.size;
|
|
return true;
|
|
}
|
|
function listCacheGet(key) {
|
|
var data = this.__data__, index = assocIndexOf(data, key);
|
|
return index < 0 ? undefined2 : data[index][1];
|
|
}
|
|
function listCacheHas(key) {
|
|
return assocIndexOf(this.__data__, key) > -1;
|
|
}
|
|
function listCacheSet(key, value) {
|
|
var data = this.__data__, index = assocIndexOf(data, key);
|
|
if (index < 0) {
|
|
++this.size;
|
|
data.push([key, value]);
|
|
} else {
|
|
data[index][1] = value;
|
|
}
|
|
return this;
|
|
}
|
|
ListCache.prototype.clear = listCacheClear;
|
|
ListCache.prototype["delete"] = listCacheDelete;
|
|
ListCache.prototype.get = listCacheGet;
|
|
ListCache.prototype.has = listCacheHas;
|
|
ListCache.prototype.set = listCacheSet;
|
|
function MapCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function mapCacheClear() {
|
|
this.size = 0;
|
|
this.__data__ = {
|
|
hash: new Hash,
|
|
map: new (Map2 || ListCache),
|
|
string: new Hash
|
|
};
|
|
}
|
|
function mapCacheDelete(key) {
|
|
var result2 = getMapData(this, key)["delete"](key);
|
|
this.size -= result2 ? 1 : 0;
|
|
return result2;
|
|
}
|
|
function mapCacheGet(key) {
|
|
return getMapData(this, key).get(key);
|
|
}
|
|
function mapCacheHas(key) {
|
|
return getMapData(this, key).has(key);
|
|
}
|
|
function mapCacheSet(key, value) {
|
|
var data = getMapData(this, key), size2 = data.size;
|
|
data.set(key, value);
|
|
this.size += data.size == size2 ? 0 : 1;
|
|
return this;
|
|
}
|
|
MapCache.prototype.clear = mapCacheClear;
|
|
MapCache.prototype["delete"] = mapCacheDelete;
|
|
MapCache.prototype.get = mapCacheGet;
|
|
MapCache.prototype.has = mapCacheHas;
|
|
MapCache.prototype.set = mapCacheSet;
|
|
function SetCache(values2) {
|
|
var index = -1, length = values2 == null ? 0 : values2.length;
|
|
this.__data__ = new MapCache;
|
|
while (++index < length) {
|
|
this.add(values2[index]);
|
|
}
|
|
}
|
|
function setCacheAdd(value) {
|
|
this.__data__.set(value, HASH_UNDEFINED);
|
|
return this;
|
|
}
|
|
function setCacheHas(value) {
|
|
return this.__data__.has(value);
|
|
}
|
|
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
|
|
SetCache.prototype.has = setCacheHas;
|
|
function Stack(entries) {
|
|
var data = this.__data__ = new ListCache(entries);
|
|
this.size = data.size;
|
|
}
|
|
function stackClear() {
|
|
this.__data__ = new ListCache;
|
|
this.size = 0;
|
|
}
|
|
function stackDelete(key) {
|
|
var data = this.__data__, result2 = data["delete"](key);
|
|
this.size = data.size;
|
|
return result2;
|
|
}
|
|
function stackGet(key) {
|
|
return this.__data__.get(key);
|
|
}
|
|
function stackHas(key) {
|
|
return this.__data__.has(key);
|
|
}
|
|
function stackSet(key, value) {
|
|
var data = this.__data__;
|
|
if (data instanceof ListCache) {
|
|
var pairs = data.__data__;
|
|
if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
|
|
pairs.push([key, value]);
|
|
this.size = ++data.size;
|
|
return this;
|
|
}
|
|
data = this.__data__ = new MapCache(pairs);
|
|
}
|
|
data.set(key, value);
|
|
this.size = data.size;
|
|
return this;
|
|
}
|
|
Stack.prototype.clear = stackClear;
|
|
Stack.prototype["delete"] = stackDelete;
|
|
Stack.prototype.get = stackGet;
|
|
Stack.prototype.has = stackHas;
|
|
Stack.prototype.set = stackSet;
|
|
function arrayLikeKeys(value, inherited) {
|
|
var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length;
|
|
for (var key in value) {
|
|
if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function arraySample(array) {
|
|
var length = array.length;
|
|
return length ? array[baseRandom(0, length - 1)] : undefined2;
|
|
}
|
|
function arraySampleSize(array, n) {
|
|
return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
|
|
}
|
|
function arrayShuffle(array) {
|
|
return shuffleSelf(copyArray(array));
|
|
}
|
|
function assignMergeValue(object, key, value) {
|
|
if (value !== undefined2 && !eq(object[key], value) || value === undefined2 && !(key in object)) {
|
|
baseAssignValue(object, key, value);
|
|
}
|
|
}
|
|
function assignValue(object, key, value) {
|
|
var objValue = object[key];
|
|
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined2 && !(key in object)) {
|
|
baseAssignValue(object, key, value);
|
|
}
|
|
}
|
|
function assocIndexOf(array, key) {
|
|
var length = array.length;
|
|
while (length--) {
|
|
if (eq(array[length][0], key)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseAggregator(collection, setter, iteratee2, accumulator) {
|
|
baseEach(collection, function(value, key, collection2) {
|
|
setter(accumulator, value, iteratee2(value), collection2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
function baseAssign(object, source) {
|
|
return object && copyObject(source, keys(source), object);
|
|
}
|
|
function baseAssignIn(object, source) {
|
|
return object && copyObject(source, keysIn(source), object);
|
|
}
|
|
function baseAssignValue(object, key, value) {
|
|
if (key == "__proto__" && defineProperty) {
|
|
defineProperty(object, key, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
value,
|
|
writable: true
|
|
});
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
function baseAt(object, paths) {
|
|
var index = -1, length = paths.length, result2 = Array2(length), skip = object == null;
|
|
while (++index < length) {
|
|
result2[index] = skip ? undefined2 : get(object, paths[index]);
|
|
}
|
|
return result2;
|
|
}
|
|
function baseClamp(number, lower, upper) {
|
|
if (number === number) {
|
|
if (upper !== undefined2) {
|
|
number = number <= upper ? number : upper;
|
|
}
|
|
if (lower !== undefined2) {
|
|
number = number >= lower ? number : lower;
|
|
}
|
|
}
|
|
return number;
|
|
}
|
|
function baseClone(value, bitmask, customizer, key, object, stack) {
|
|
var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
|
|
if (customizer) {
|
|
result2 = object ? customizer(value, key, object, stack) : customizer(value);
|
|
}
|
|
if (result2 !== undefined2) {
|
|
return result2;
|
|
}
|
|
if (!isObject(value)) {
|
|
return value;
|
|
}
|
|
var isArr = isArray(value);
|
|
if (isArr) {
|
|
result2 = initCloneArray(value);
|
|
if (!isDeep) {
|
|
return copyArray(value, result2);
|
|
}
|
|
} else {
|
|
var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
|
|
if (isBuffer(value)) {
|
|
return cloneBuffer(value, isDeep);
|
|
}
|
|
if (tag == objectTag || tag == argsTag || isFunc && !object) {
|
|
result2 = isFlat || isFunc ? {} : initCloneObject(value);
|
|
if (!isDeep) {
|
|
return isFlat ? copySymbolsIn(value, baseAssignIn(result2, value)) : copySymbols(value, baseAssign(result2, value));
|
|
}
|
|
} else {
|
|
if (!cloneableTags[tag]) {
|
|
return object ? value : {};
|
|
}
|
|
result2 = initCloneByTag(value, tag, isDeep);
|
|
}
|
|
}
|
|
stack || (stack = new Stack);
|
|
var stacked = stack.get(value);
|
|
if (stacked) {
|
|
return stacked;
|
|
}
|
|
stack.set(value, result2);
|
|
if (isSet(value)) {
|
|
value.forEach(function(subValue) {
|
|
result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
|
|
});
|
|
} else if (isMap(value)) {
|
|
value.forEach(function(subValue, key2) {
|
|
result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
}
|
|
var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
|
|
var props = isArr ? undefined2 : keysFunc(value);
|
|
arrayEach(props || value, function(subValue, key2) {
|
|
if (props) {
|
|
key2 = subValue;
|
|
subValue = value[key2];
|
|
}
|
|
assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
return result2;
|
|
}
|
|
function baseConforms(source) {
|
|
var props = keys(source);
|
|
return function(object) {
|
|
return baseConformsTo(object, source, props);
|
|
};
|
|
}
|
|
function baseConformsTo(object, source, props) {
|
|
var length = props.length;
|
|
if (object == null) {
|
|
return !length;
|
|
}
|
|
object = Object2(object);
|
|
while (length--) {
|
|
var key = props[length], predicate = source[key], value = object[key];
|
|
if (value === undefined2 && !(key in object) || !predicate(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function baseDelay(func, wait, args) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
return setTimeout2(function() {
|
|
func.apply(undefined2, args);
|
|
}, wait);
|
|
}
|
|
function baseDifference(array, values2, iteratee2, comparator) {
|
|
var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
|
|
if (!length) {
|
|
return result2;
|
|
}
|
|
if (iteratee2) {
|
|
values2 = arrayMap(values2, baseUnary(iteratee2));
|
|
}
|
|
if (comparator) {
|
|
includes2 = arrayIncludesWith;
|
|
isCommon = false;
|
|
} else if (values2.length >= LARGE_ARRAY_SIZE) {
|
|
includes2 = cacheHas;
|
|
isCommon = false;
|
|
values2 = new SetCache(values2);
|
|
}
|
|
outer:
|
|
while (++index < length) {
|
|
var value = array[index], computed = iteratee2 == null ? value : iteratee2(value);
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (isCommon && computed === computed) {
|
|
var valuesIndex = valuesLength;
|
|
while (valuesIndex--) {
|
|
if (values2[valuesIndex] === computed) {
|
|
continue outer;
|
|
}
|
|
}
|
|
result2.push(value);
|
|
} else if (!includes2(values2, computed, comparator)) {
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseEach = createBaseEach(baseForOwn);
|
|
var baseEachRight = createBaseEach(baseForOwnRight, true);
|
|
function baseEvery(collection, predicate) {
|
|
var result2 = true;
|
|
baseEach(collection, function(value, index, collection2) {
|
|
result2 = !!predicate(value, index, collection2);
|
|
return result2;
|
|
});
|
|
return result2;
|
|
}
|
|
function baseExtremum(array, iteratee2, comparator) {
|
|
var index = -1, length = array.length;
|
|
while (++index < length) {
|
|
var value = array[index], current = iteratee2(value);
|
|
if (current != null && (computed === undefined2 ? current === current && !isSymbol(current) : comparator(current, computed))) {
|
|
var computed = current, result2 = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseFill(array, value, start, end) {
|
|
var length = array.length;
|
|
start = toInteger(start);
|
|
if (start < 0) {
|
|
start = -start > length ? 0 : length + start;
|
|
}
|
|
end = end === undefined2 || end > length ? length : toInteger(end);
|
|
if (end < 0) {
|
|
end += length;
|
|
}
|
|
end = start > end ? 0 : toLength(end);
|
|
while (start < end) {
|
|
array[start++] = value;
|
|
}
|
|
return array;
|
|
}
|
|
function baseFilter(collection, predicate) {
|
|
var result2 = [];
|
|
baseEach(collection, function(value, index, collection2) {
|
|
if (predicate(value, index, collection2)) {
|
|
result2.push(value);
|
|
}
|
|
});
|
|
return result2;
|
|
}
|
|
function baseFlatten(array, depth, predicate, isStrict, result2) {
|
|
var index = -1, length = array.length;
|
|
predicate || (predicate = isFlattenable);
|
|
result2 || (result2 = []);
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (depth > 0 && predicate(value)) {
|
|
if (depth > 1) {
|
|
baseFlatten(value, depth - 1, predicate, isStrict, result2);
|
|
} else {
|
|
arrayPush(result2, value);
|
|
}
|
|
} else if (!isStrict) {
|
|
result2[result2.length] = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseFor = createBaseFor();
|
|
var baseForRight = createBaseFor(true);
|
|
function baseForOwn(object, iteratee2) {
|
|
return object && baseFor(object, iteratee2, keys);
|
|
}
|
|
function baseForOwnRight(object, iteratee2) {
|
|
return object && baseForRight(object, iteratee2, keys);
|
|
}
|
|
function baseFunctions(object, props) {
|
|
return arrayFilter(props, function(key) {
|
|
return isFunction(object[key]);
|
|
});
|
|
}
|
|
function baseGet(object, path) {
|
|
path = castPath(path, object);
|
|
var index = 0, length = path.length;
|
|
while (object != null && index < length) {
|
|
object = object[toKey(path[index++])];
|
|
}
|
|
return index && index == length ? object : undefined2;
|
|
}
|
|
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
|
|
var result2 = keysFunc(object);
|
|
return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object));
|
|
}
|
|
function baseGetTag(value) {
|
|
if (value == null) {
|
|
return value === undefined2 ? undefinedTag : nullTag;
|
|
}
|
|
return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString(value);
|
|
}
|
|
function baseGt(value, other) {
|
|
return value > other;
|
|
}
|
|
function baseHas(object, key) {
|
|
return object != null && hasOwnProperty.call(object, key);
|
|
}
|
|
function baseHasIn(object, key) {
|
|
return object != null && key in Object2(object);
|
|
}
|
|
function baseInRange(number, start, end) {
|
|
return number >= nativeMin(start, end) && number < nativeMax(start, end);
|
|
}
|
|
function baseIntersection(arrays, iteratee2, comparator) {
|
|
var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];
|
|
while (othIndex--) {
|
|
var array = arrays[othIndex];
|
|
if (othIndex && iteratee2) {
|
|
array = arrayMap(array, baseUnary(iteratee2));
|
|
}
|
|
maxLength = nativeMin(array.length, maxLength);
|
|
caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined2;
|
|
}
|
|
array = arrays[0];
|
|
var index = -1, seen = caches[0];
|
|
outer:
|
|
while (++index < length && result2.length < maxLength) {
|
|
var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) {
|
|
othIndex = othLength;
|
|
while (--othIndex) {
|
|
var cache = caches[othIndex];
|
|
if (!(cache ? cacheHas(cache, computed) : includes2(arrays[othIndex], computed, comparator))) {
|
|
continue outer;
|
|
}
|
|
}
|
|
if (seen) {
|
|
seen.push(computed);
|
|
}
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseInverter(object, setter, iteratee2, accumulator) {
|
|
baseForOwn(object, function(value, key, object2) {
|
|
setter(accumulator, iteratee2(value), key, object2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
function baseInvoke(object, path, args) {
|
|
path = castPath(path, object);
|
|
object = parent(object, path);
|
|
var func = object == null ? object : object[toKey(last(path))];
|
|
return func == null ? undefined2 : apply(func, object, args);
|
|
}
|
|
function baseIsArguments(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == argsTag;
|
|
}
|
|
function baseIsArrayBuffer(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
|
|
}
|
|
function baseIsDate(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == dateTag;
|
|
}
|
|
function baseIsEqual(value, other, bitmask, customizer, stack) {
|
|
if (value === other) {
|
|
return true;
|
|
}
|
|
if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
|
|
return value !== value && other !== other;
|
|
}
|
|
return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
|
|
}
|
|
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
|
|
var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
|
|
objTag = objTag == argsTag ? objectTag : objTag;
|
|
othTag = othTag == argsTag ? objectTag : othTag;
|
|
var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
|
|
if (isSameTag && isBuffer(object)) {
|
|
if (!isBuffer(other)) {
|
|
return false;
|
|
}
|
|
objIsArr = true;
|
|
objIsObj = false;
|
|
}
|
|
if (isSameTag && !objIsObj) {
|
|
stack || (stack = new Stack);
|
|
return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
|
|
var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
|
|
if (objIsWrapped || othIsWrapped) {
|
|
var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
|
|
stack || (stack = new Stack);
|
|
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
|
|
}
|
|
}
|
|
if (!isSameTag) {
|
|
return false;
|
|
}
|
|
stack || (stack = new Stack);
|
|
return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
function baseIsMap(value) {
|
|
return isObjectLike(value) && getTag(value) == mapTag;
|
|
}
|
|
function baseIsMatch(object, source, matchData, customizer) {
|
|
var index = matchData.length, length = index, noCustomizer = !customizer;
|
|
if (object == null) {
|
|
return !length;
|
|
}
|
|
object = Object2(object);
|
|
while (index--) {
|
|
var data = matchData[index];
|
|
if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
|
|
return false;
|
|
}
|
|
}
|
|
while (++index < length) {
|
|
data = matchData[index];
|
|
var key = data[0], objValue = object[key], srcValue = data[1];
|
|
if (noCustomizer && data[2]) {
|
|
if (objValue === undefined2 && !(key in object)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
var stack = new Stack;
|
|
if (customizer) {
|
|
var result2 = customizer(objValue, srcValue, key, object, source, stack);
|
|
}
|
|
if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function baseIsNative(value) {
|
|
if (!isObject(value) || isMasked(value)) {
|
|
return false;
|
|
}
|
|
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
|
|
return pattern.test(toSource(value));
|
|
}
|
|
function baseIsRegExp(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == regexpTag;
|
|
}
|
|
function baseIsSet(value) {
|
|
return isObjectLike(value) && getTag(value) == setTag;
|
|
}
|
|
function baseIsTypedArray(value) {
|
|
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
|
}
|
|
function baseIteratee(value) {
|
|
if (typeof value == "function") {
|
|
return value;
|
|
}
|
|
if (value == null) {
|
|
return identity;
|
|
}
|
|
if (typeof value == "object") {
|
|
return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
|
|
}
|
|
return property(value);
|
|
}
|
|
function baseKeys(object) {
|
|
if (!isPrototype(object)) {
|
|
return nativeKeys(object);
|
|
}
|
|
var result2 = [];
|
|
for (var key in Object2(object)) {
|
|
if (hasOwnProperty.call(object, key) && key != "constructor") {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseKeysIn(object) {
|
|
if (!isObject(object)) {
|
|
return nativeKeysIn(object);
|
|
}
|
|
var isProto = isPrototype(object), result2 = [];
|
|
for (var key in object) {
|
|
if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseLt(value, other) {
|
|
return value < other;
|
|
}
|
|
function baseMap(collection, iteratee2) {
|
|
var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];
|
|
baseEach(collection, function(value, key, collection2) {
|
|
result2[++index] = iteratee2(value, key, collection2);
|
|
});
|
|
return result2;
|
|
}
|
|
function baseMatches(source) {
|
|
var matchData = getMatchData(source);
|
|
if (matchData.length == 1 && matchData[0][2]) {
|
|
return matchesStrictComparable(matchData[0][0], matchData[0][1]);
|
|
}
|
|
return function(object) {
|
|
return object === source || baseIsMatch(object, source, matchData);
|
|
};
|
|
}
|
|
function baseMatchesProperty(path, srcValue) {
|
|
if (isKey(path) && isStrictComparable(srcValue)) {
|
|
return matchesStrictComparable(toKey(path), srcValue);
|
|
}
|
|
return function(object) {
|
|
var objValue = get(object, path);
|
|
return objValue === undefined2 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
|
|
};
|
|
}
|
|
function baseMerge(object, source, srcIndex, customizer, stack) {
|
|
if (object === source) {
|
|
return;
|
|
}
|
|
baseFor(source, function(srcValue, key) {
|
|
stack || (stack = new Stack);
|
|
if (isObject(srcValue)) {
|
|
baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
|
|
} else {
|
|
var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : undefined2;
|
|
if (newValue === undefined2) {
|
|
newValue = srcValue;
|
|
}
|
|
assignMergeValue(object, key, newValue);
|
|
}
|
|
}, keysIn);
|
|
}
|
|
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
|
|
var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
|
|
if (stacked) {
|
|
assignMergeValue(object, key, stacked);
|
|
return;
|
|
}
|
|
var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined2;
|
|
var isCommon = newValue === undefined2;
|
|
if (isCommon) {
|
|
var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
|
|
newValue = srcValue;
|
|
if (isArr || isBuff || isTyped) {
|
|
if (isArray(objValue)) {
|
|
newValue = objValue;
|
|
} else if (isArrayLikeObject(objValue)) {
|
|
newValue = copyArray(objValue);
|
|
} else if (isBuff) {
|
|
isCommon = false;
|
|
newValue = cloneBuffer(srcValue, true);
|
|
} else if (isTyped) {
|
|
isCommon = false;
|
|
newValue = cloneTypedArray(srcValue, true);
|
|
} else {
|
|
newValue = [];
|
|
}
|
|
} else if (isPlainObject(srcValue) || isArguments(srcValue)) {
|
|
newValue = objValue;
|
|
if (isArguments(objValue)) {
|
|
newValue = toPlainObject(objValue);
|
|
} else if (!isObject(objValue) || isFunction(objValue)) {
|
|
newValue = initCloneObject(srcValue);
|
|
}
|
|
} else {
|
|
isCommon = false;
|
|
}
|
|
}
|
|
if (isCommon) {
|
|
stack.set(srcValue, newValue);
|
|
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
|
|
stack["delete"](srcValue);
|
|
}
|
|
assignMergeValue(object, key, newValue);
|
|
}
|
|
function baseNth(array, n) {
|
|
var length = array.length;
|
|
if (!length) {
|
|
return;
|
|
}
|
|
n += n < 0 ? length : 0;
|
|
return isIndex(n, length) ? array[n] : undefined2;
|
|
}
|
|
function baseOrderBy(collection, iteratees, orders) {
|
|
if (iteratees.length) {
|
|
iteratees = arrayMap(iteratees, function(iteratee2) {
|
|
if (isArray(iteratee2)) {
|
|
return function(value) {
|
|
return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
|
|
};
|
|
}
|
|
return iteratee2;
|
|
});
|
|
} else {
|
|
iteratees = [identity];
|
|
}
|
|
var index = -1;
|
|
iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
|
|
var result2 = baseMap(collection, function(value, key, collection2) {
|
|
var criteria = arrayMap(iteratees, function(iteratee2) {
|
|
return iteratee2(value);
|
|
});
|
|
return { criteria, index: ++index, value };
|
|
});
|
|
return baseSortBy(result2, function(object, other) {
|
|
return compareMultiple(object, other, orders);
|
|
});
|
|
}
|
|
function basePick(object, paths) {
|
|
return basePickBy(object, paths, function(value, path) {
|
|
return hasIn(object, path);
|
|
});
|
|
}
|
|
function basePickBy(object, paths, predicate) {
|
|
var index = -1, length = paths.length, result2 = {};
|
|
while (++index < length) {
|
|
var path = paths[index], value = baseGet(object, path);
|
|
if (predicate(value, path)) {
|
|
baseSet(result2, castPath(path, object), value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function basePropertyDeep(path) {
|
|
return function(object) {
|
|
return baseGet(object, path);
|
|
};
|
|
}
|
|
function basePullAll(array, values2, iteratee2, comparator) {
|
|
var indexOf2 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array;
|
|
if (array === values2) {
|
|
values2 = copyArray(values2);
|
|
}
|
|
if (iteratee2) {
|
|
seen = arrayMap(array, baseUnary(iteratee2));
|
|
}
|
|
while (++index < length) {
|
|
var fromIndex = 0, value = values2[index], computed = iteratee2 ? iteratee2(value) : value;
|
|
while ((fromIndex = indexOf2(seen, computed, fromIndex, comparator)) > -1) {
|
|
if (seen !== array) {
|
|
splice.call(seen, fromIndex, 1);
|
|
}
|
|
splice.call(array, fromIndex, 1);
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function basePullAt(array, indexes) {
|
|
var length = array ? indexes.length : 0, lastIndex = length - 1;
|
|
while (length--) {
|
|
var index = indexes[length];
|
|
if (length == lastIndex || index !== previous) {
|
|
var previous = index;
|
|
if (isIndex(index)) {
|
|
splice.call(array, index, 1);
|
|
} else {
|
|
baseUnset(array, index);
|
|
}
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function baseRandom(lower, upper) {
|
|
return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
|
|
}
|
|
function baseRange(start, end, step, fromRight) {
|
|
var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);
|
|
while (length--) {
|
|
result2[fromRight ? length : ++index] = start;
|
|
start += step;
|
|
}
|
|
return result2;
|
|
}
|
|
function baseRepeat(string, n) {
|
|
var result2 = "";
|
|
if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
|
|
return result2;
|
|
}
|
|
do {
|
|
if (n % 2) {
|
|
result2 += string;
|
|
}
|
|
n = nativeFloor(n / 2);
|
|
if (n) {
|
|
string += string;
|
|
}
|
|
} while (n);
|
|
return result2;
|
|
}
|
|
function baseRest(func, start) {
|
|
return setToString(overRest(func, start, identity), func + "");
|
|
}
|
|
function baseSample(collection) {
|
|
return arraySample(values(collection));
|
|
}
|
|
function baseSampleSize(collection, n) {
|
|
var array = values(collection);
|
|
return shuffleSelf(array, baseClamp(n, 0, array.length));
|
|
}
|
|
function baseSet(object, path, value, customizer) {
|
|
if (!isObject(object)) {
|
|
return object;
|
|
}
|
|
path = castPath(path, object);
|
|
var index = -1, length = path.length, lastIndex = length - 1, nested = object;
|
|
while (nested != null && ++index < length) {
|
|
var key = toKey(path[index]), newValue = value;
|
|
if (key === "__proto__" || key === "constructor" || key === "prototype") {
|
|
return object;
|
|
}
|
|
if (index != lastIndex) {
|
|
var objValue = nested[key];
|
|
newValue = customizer ? customizer(objValue, key, nested) : undefined2;
|
|
if (newValue === undefined2) {
|
|
newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
|
|
}
|
|
}
|
|
assignValue(nested, key, newValue);
|
|
nested = nested[key];
|
|
}
|
|
return object;
|
|
}
|
|
var baseSetData = !metaMap ? identity : function(func, data) {
|
|
metaMap.set(func, data);
|
|
return func;
|
|
};
|
|
var baseSetToString = !defineProperty ? identity : function(func, string) {
|
|
return defineProperty(func, "toString", {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: constant(string),
|
|
writable: true
|
|
});
|
|
};
|
|
function baseShuffle(collection) {
|
|
return shuffleSelf(values(collection));
|
|
}
|
|
function baseSlice(array, start, end) {
|
|
var index = -1, length = array.length;
|
|
if (start < 0) {
|
|
start = -start > length ? 0 : length + start;
|
|
}
|
|
end = end > length ? length : end;
|
|
if (end < 0) {
|
|
end += length;
|
|
}
|
|
length = start > end ? 0 : end - start >>> 0;
|
|
start >>>= 0;
|
|
var result2 = Array2(length);
|
|
while (++index < length) {
|
|
result2[index] = array[index + start];
|
|
}
|
|
return result2;
|
|
}
|
|
function baseSome(collection, predicate) {
|
|
var result2;
|
|
baseEach(collection, function(value, index, collection2) {
|
|
result2 = predicate(value, index, collection2);
|
|
return !result2;
|
|
});
|
|
return !!result2;
|
|
}
|
|
function baseSortedIndex(array, value, retHighest) {
|
|
var low = 0, high = array == null ? low : array.length;
|
|
if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
|
|
while (low < high) {
|
|
var mid = low + high >>> 1, computed = array[mid];
|
|
if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return high;
|
|
}
|
|
return baseSortedIndexBy(array, value, identity, retHighest);
|
|
}
|
|
function baseSortedIndexBy(array, value, iteratee2, retHighest) {
|
|
var low = 0, high = array == null ? 0 : array.length;
|
|
if (high === 0) {
|
|
return 0;
|
|
}
|
|
value = iteratee2(value);
|
|
var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined2;
|
|
while (low < high) {
|
|
var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined2, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
|
|
if (valIsNaN) {
|
|
var setLow = retHighest || othIsReflexive;
|
|
} else if (valIsUndefined) {
|
|
setLow = othIsReflexive && (retHighest || othIsDefined);
|
|
} else if (valIsNull) {
|
|
setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
|
|
} else if (valIsSymbol) {
|
|
setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
|
|
} else if (othIsNull || othIsSymbol) {
|
|
setLow = false;
|
|
} else {
|
|
setLow = retHighest ? computed <= value : computed < value;
|
|
}
|
|
if (setLow) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return nativeMin(high, MAX_ARRAY_INDEX);
|
|
}
|
|
function baseSortedUniq(array, iteratee2) {
|
|
var index = -1, length = array.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
|
|
if (!index || !eq(computed, seen)) {
|
|
var seen = computed;
|
|
result2[resIndex++] = value === 0 ? 0 : value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseToNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
return +value;
|
|
}
|
|
function baseToString(value) {
|
|
if (typeof value == "string") {
|
|
return value;
|
|
}
|
|
if (isArray(value)) {
|
|
return arrayMap(value, baseToString) + "";
|
|
}
|
|
if (isSymbol(value)) {
|
|
return symbolToString ? symbolToString.call(value) : "";
|
|
}
|
|
var result2 = value + "";
|
|
return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
|
|
}
|
|
function baseUniq(array, iteratee2, comparator) {
|
|
var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
|
|
if (comparator) {
|
|
isCommon = false;
|
|
includes2 = arrayIncludesWith;
|
|
} else if (length >= LARGE_ARRAY_SIZE) {
|
|
var set2 = iteratee2 ? null : createSet(array);
|
|
if (set2) {
|
|
return setToArray(set2);
|
|
}
|
|
isCommon = false;
|
|
includes2 = cacheHas;
|
|
seen = new SetCache;
|
|
} else {
|
|
seen = iteratee2 ? [] : result2;
|
|
}
|
|
outer:
|
|
while (++index < length) {
|
|
var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (isCommon && computed === computed) {
|
|
var seenIndex = seen.length;
|
|
while (seenIndex--) {
|
|
if (seen[seenIndex] === computed) {
|
|
continue outer;
|
|
}
|
|
}
|
|
if (iteratee2) {
|
|
seen.push(computed);
|
|
}
|
|
result2.push(value);
|
|
} else if (!includes2(seen, computed, comparator)) {
|
|
if (seen !== result2) {
|
|
seen.push(computed);
|
|
}
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function baseUnset(object, path) {
|
|
path = castPath(path, object);
|
|
object = parent(object, path);
|
|
return object == null || delete object[toKey(last(path))];
|
|
}
|
|
function baseUpdate(object, path, updater, customizer) {
|
|
return baseSet(object, path, updater(baseGet(object, path)), customizer);
|
|
}
|
|
function baseWhile(array, predicate, isDrop, fromRight) {
|
|
var length = array.length, index = fromRight ? length : -1;
|
|
while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {
|
|
}
|
|
return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
|
|
}
|
|
function baseWrapperValue(value, actions) {
|
|
var result2 = value;
|
|
if (result2 instanceof LazyWrapper) {
|
|
result2 = result2.value();
|
|
}
|
|
return arrayReduce(actions, function(result3, action) {
|
|
return action.func.apply(action.thisArg, arrayPush([result3], action.args));
|
|
}, result2);
|
|
}
|
|
function baseXor(arrays, iteratee2, comparator) {
|
|
var length = arrays.length;
|
|
if (length < 2) {
|
|
return length ? baseUniq(arrays[0]) : [];
|
|
}
|
|
var index = -1, result2 = Array2(length);
|
|
while (++index < length) {
|
|
var array = arrays[index], othIndex = -1;
|
|
while (++othIndex < length) {
|
|
if (othIndex != index) {
|
|
result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator);
|
|
}
|
|
}
|
|
}
|
|
return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);
|
|
}
|
|
function baseZipObject(props, values2, assignFunc) {
|
|
var index = -1, length = props.length, valsLength = values2.length, result2 = {};
|
|
while (++index < length) {
|
|
var value = index < valsLength ? values2[index] : undefined2;
|
|
assignFunc(result2, props[index], value);
|
|
}
|
|
return result2;
|
|
}
|
|
function castArrayLikeObject(value) {
|
|
return isArrayLikeObject(value) ? value : [];
|
|
}
|
|
function castFunction(value) {
|
|
return typeof value == "function" ? value : identity;
|
|
}
|
|
function castPath(value, object) {
|
|
if (isArray(value)) {
|
|
return value;
|
|
}
|
|
return isKey(value, object) ? [value] : stringToPath(toString(value));
|
|
}
|
|
var castRest = baseRest;
|
|
function castSlice(array, start, end) {
|
|
var length = array.length;
|
|
end = end === undefined2 ? length : end;
|
|
return !start && end >= length ? array : baseSlice(array, start, end);
|
|
}
|
|
var clearTimeout2 = ctxClearTimeout || function(id) {
|
|
return root.clearTimeout(id);
|
|
};
|
|
function cloneBuffer(buffer, isDeep) {
|
|
if (isDeep) {
|
|
return buffer.slice();
|
|
}
|
|
var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
|
|
buffer.copy(result2);
|
|
return result2;
|
|
}
|
|
function cloneArrayBuffer(arrayBuffer) {
|
|
var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);
|
|
new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer));
|
|
return result2;
|
|
}
|
|
function cloneDataView(dataView, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
|
|
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
|
|
}
|
|
function cloneRegExp(regexp) {
|
|
var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));
|
|
result2.lastIndex = regexp.lastIndex;
|
|
return result2;
|
|
}
|
|
function cloneSymbol(symbol) {
|
|
return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};
|
|
}
|
|
function cloneTypedArray(typedArray, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
|
|
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
|
|
}
|
|
function compareAscending(value, other) {
|
|
if (value !== other) {
|
|
var valIsDefined = value !== undefined2, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
|
|
var othIsDefined = other !== undefined2, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
|
|
if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
|
|
return 1;
|
|
}
|
|
if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function compareMultiple(object, other, orders) {
|
|
var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
|
|
while (++index < length) {
|
|
var result2 = compareAscending(objCriteria[index], othCriteria[index]);
|
|
if (result2) {
|
|
if (index >= ordersLength) {
|
|
return result2;
|
|
}
|
|
var order = orders[index];
|
|
return result2 * (order == "desc" ? -1 : 1);
|
|
}
|
|
}
|
|
return object.index - other.index;
|
|
}
|
|
function composeArgs(args, partials, holders, isCurried) {
|
|
var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;
|
|
while (++leftIndex < leftLength) {
|
|
result2[leftIndex] = partials[leftIndex];
|
|
}
|
|
while (++argsIndex < holdersLength) {
|
|
if (isUncurried || argsIndex < argsLength) {
|
|
result2[holders[argsIndex]] = args[argsIndex];
|
|
}
|
|
}
|
|
while (rangeLength--) {
|
|
result2[leftIndex++] = args[argsIndex++];
|
|
}
|
|
return result2;
|
|
}
|
|
function composeArgsRight(args, partials, holders, isCurried) {
|
|
var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;
|
|
while (++argsIndex < rangeLength) {
|
|
result2[argsIndex] = args[argsIndex];
|
|
}
|
|
var offset = argsIndex;
|
|
while (++rightIndex < rightLength) {
|
|
result2[offset + rightIndex] = partials[rightIndex];
|
|
}
|
|
while (++holdersIndex < holdersLength) {
|
|
if (isUncurried || argsIndex < argsLength) {
|
|
result2[offset + holders[holdersIndex]] = args[argsIndex++];
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function copyArray(source, array) {
|
|
var index = -1, length = source.length;
|
|
array || (array = Array2(length));
|
|
while (++index < length) {
|
|
array[index] = source[index];
|
|
}
|
|
return array;
|
|
}
|
|
function copyObject(source, props, object, customizer) {
|
|
var isNew = !object;
|
|
object || (object = {});
|
|
var index = -1, length = props.length;
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined2;
|
|
if (newValue === undefined2) {
|
|
newValue = source[key];
|
|
}
|
|
if (isNew) {
|
|
baseAssignValue(object, key, newValue);
|
|
} else {
|
|
assignValue(object, key, newValue);
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function copySymbols(source, object) {
|
|
return copyObject(source, getSymbols(source), object);
|
|
}
|
|
function copySymbolsIn(source, object) {
|
|
return copyObject(source, getSymbolsIn(source), object);
|
|
}
|
|
function createAggregator(setter, initializer) {
|
|
return function(collection, iteratee2) {
|
|
var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
|
|
return func(collection, setter, getIteratee(iteratee2, 2), accumulator);
|
|
};
|
|
}
|
|
function createAssigner(assigner) {
|
|
return baseRest(function(object, sources) {
|
|
var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined2, guard = length > 2 ? sources[2] : undefined2;
|
|
customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined2;
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
|
customizer = length < 3 ? undefined2 : customizer;
|
|
length = 1;
|
|
}
|
|
object = Object2(object);
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
if (source) {
|
|
assigner(object, source, index, customizer);
|
|
}
|
|
}
|
|
return object;
|
|
});
|
|
}
|
|
function createBaseEach(eachFunc, fromRight) {
|
|
return function(collection, iteratee2) {
|
|
if (collection == null) {
|
|
return collection;
|
|
}
|
|
if (!isArrayLike(collection)) {
|
|
return eachFunc(collection, iteratee2);
|
|
}
|
|
var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection);
|
|
while (fromRight ? index-- : ++index < length) {
|
|
if (iteratee2(iterable[index], index, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return collection;
|
|
};
|
|
}
|
|
function createBaseFor(fromRight) {
|
|
return function(object, iteratee2, keysFunc) {
|
|
var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;
|
|
while (length--) {
|
|
var key = props[fromRight ? length : ++index];
|
|
if (iteratee2(iterable[key], key, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
}
|
|
function createBind(func, bitmask, thisArg) {
|
|
var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
|
|
function wrapper() {
|
|
var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
|
|
return fn.apply(isBind ? thisArg : this, arguments);
|
|
}
|
|
return wrapper;
|
|
}
|
|
function createCaseFirst(methodName) {
|
|
return function(string) {
|
|
string = toString(string);
|
|
var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined2;
|
|
var chr = strSymbols ? strSymbols[0] : string.charAt(0);
|
|
var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
|
|
return chr[methodName]() + trailing;
|
|
};
|
|
}
|
|
function createCompounder(callback) {
|
|
return function(string) {
|
|
return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
|
|
};
|
|
}
|
|
function createCtor(Ctor) {
|
|
return function() {
|
|
var args = arguments;
|
|
switch (args.length) {
|
|
case 0:
|
|
return new Ctor;
|
|
case 1:
|
|
return new Ctor(args[0]);
|
|
case 2:
|
|
return new Ctor(args[0], args[1]);
|
|
case 3:
|
|
return new Ctor(args[0], args[1], args[2]);
|
|
case 4:
|
|
return new Ctor(args[0], args[1], args[2], args[3]);
|
|
case 5:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4]);
|
|
case 6:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
|
|
case 7:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
|
|
}
|
|
var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
|
|
return isObject(result2) ? result2 : thisBinding;
|
|
};
|
|
}
|
|
function createCurry(func, bitmask, arity) {
|
|
var Ctor = createCtor(func);
|
|
function wrapper() {
|
|
var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper);
|
|
while (index--) {
|
|
args[index] = arguments[index];
|
|
}
|
|
var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
|
|
length -= holders.length;
|
|
if (length < arity) {
|
|
return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, undefined2, args, holders, undefined2, undefined2, arity - length);
|
|
}
|
|
var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
|
|
return apply(fn, this, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
function createFind(findIndexFunc) {
|
|
return function(collection, predicate, fromIndex) {
|
|
var iterable = Object2(collection);
|
|
if (!isArrayLike(collection)) {
|
|
var iteratee2 = getIteratee(predicate, 3);
|
|
collection = keys(collection);
|
|
predicate = function(key) {
|
|
return iteratee2(iterable[key], key, iterable);
|
|
};
|
|
}
|
|
var index = findIndexFunc(collection, predicate, fromIndex);
|
|
return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2;
|
|
};
|
|
}
|
|
function createFlow(fromRight) {
|
|
return flatRest(function(funcs) {
|
|
var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
|
|
if (fromRight) {
|
|
funcs.reverse();
|
|
}
|
|
while (index--) {
|
|
var func = funcs[index];
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
if (prereq && !wrapper && getFuncName(func) == "wrapper") {
|
|
var wrapper = new LodashWrapper([], true);
|
|
}
|
|
}
|
|
index = wrapper ? index : length;
|
|
while (++index < length) {
|
|
func = funcs[index];
|
|
var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : undefined2;
|
|
if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) {
|
|
wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
|
|
} else {
|
|
wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
|
|
}
|
|
}
|
|
return function() {
|
|
var args = arguments, value = args[0];
|
|
if (wrapper && args.length == 1 && isArray(value)) {
|
|
return wrapper.plant(value).value();
|
|
}
|
|
var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value;
|
|
while (++index2 < length) {
|
|
result2 = funcs[index2].call(this, result2);
|
|
}
|
|
return result2;
|
|
};
|
|
});
|
|
}
|
|
function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
|
|
var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined2 : createCtor(func);
|
|
function wrapper() {
|
|
var length = arguments.length, args = Array2(length), index = length;
|
|
while (index--) {
|
|
args[index] = arguments[index];
|
|
}
|
|
if (isCurried) {
|
|
var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
|
|
}
|
|
if (partials) {
|
|
args = composeArgs(args, partials, holders, isCurried);
|
|
}
|
|
if (partialsRight) {
|
|
args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
|
|
}
|
|
length -= holdersCount;
|
|
if (isCurried && length < arity) {
|
|
var newHolders = replaceHolders(args, placeholder);
|
|
return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary2, arity - length);
|
|
}
|
|
var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
|
|
length = args.length;
|
|
if (argPos) {
|
|
args = reorder(args, argPos);
|
|
} else if (isFlip && length > 1) {
|
|
args.reverse();
|
|
}
|
|
if (isAry && ary2 < length) {
|
|
args.length = ary2;
|
|
}
|
|
if (this && this !== root && this instanceof wrapper) {
|
|
fn = Ctor || createCtor(fn);
|
|
}
|
|
return fn.apply(thisBinding, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
function createInverter(setter, toIteratee) {
|
|
return function(object, iteratee2) {
|
|
return baseInverter(object, setter, toIteratee(iteratee2), {});
|
|
};
|
|
}
|
|
function createMathOperation(operator, defaultValue) {
|
|
return function(value, other) {
|
|
var result2;
|
|
if (value === undefined2 && other === undefined2) {
|
|
return defaultValue;
|
|
}
|
|
if (value !== undefined2) {
|
|
result2 = value;
|
|
}
|
|
if (other !== undefined2) {
|
|
if (result2 === undefined2) {
|
|
return other;
|
|
}
|
|
if (typeof value == "string" || typeof other == "string") {
|
|
value = baseToString(value);
|
|
other = baseToString(other);
|
|
} else {
|
|
value = baseToNumber(value);
|
|
other = baseToNumber(other);
|
|
}
|
|
result2 = operator(value, other);
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
function createOver(arrayFunc) {
|
|
return flatRest(function(iteratees) {
|
|
iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
|
|
return baseRest(function(args) {
|
|
var thisArg = this;
|
|
return arrayFunc(iteratees, function(iteratee2) {
|
|
return apply(iteratee2, thisArg, args);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
function createPadding(length, chars) {
|
|
chars = chars === undefined2 ? " " : baseToString(chars);
|
|
var charsLength = chars.length;
|
|
if (charsLength < 2) {
|
|
return charsLength ? baseRepeat(chars, length) : chars;
|
|
}
|
|
var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
|
|
return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length);
|
|
}
|
|
function createPartial(func, bitmask, thisArg, partials) {
|
|
var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
|
|
function wrapper() {
|
|
var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;
|
|
while (++leftIndex < leftLength) {
|
|
args[leftIndex] = partials[leftIndex];
|
|
}
|
|
while (argsLength--) {
|
|
args[leftIndex++] = arguments[++argsIndex];
|
|
}
|
|
return apply(fn, isBind ? thisArg : this, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
function createRange(fromRight) {
|
|
return function(start, end, step) {
|
|
if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
|
|
end = step = undefined2;
|
|
}
|
|
start = toFinite(start);
|
|
if (end === undefined2) {
|
|
end = start;
|
|
start = 0;
|
|
} else {
|
|
end = toFinite(end);
|
|
}
|
|
step = step === undefined2 ? start < end ? 1 : -1 : toFinite(step);
|
|
return baseRange(start, end, step, fromRight);
|
|
};
|
|
}
|
|
function createRelationalOperation(operator) {
|
|
return function(value, other) {
|
|
if (!(typeof value == "string" && typeof other == "string")) {
|
|
value = toNumber(value);
|
|
other = toNumber(other);
|
|
}
|
|
return operator(value, other);
|
|
};
|
|
}
|
|
function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
|
|
var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined2, newHoldersRight = isCurry ? undefined2 : holders, newPartials = isCurry ? partials : undefined2, newPartialsRight = isCurry ? undefined2 : partials;
|
|
bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;
|
|
bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
|
|
if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
|
|
bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
|
|
}
|
|
var newData = [
|
|
func,
|
|
bitmask,
|
|
thisArg,
|
|
newPartials,
|
|
newHolders,
|
|
newPartialsRight,
|
|
newHoldersRight,
|
|
argPos,
|
|
ary2,
|
|
arity
|
|
];
|
|
var result2 = wrapFunc.apply(undefined2, newData);
|
|
if (isLaziable(func)) {
|
|
setData(result2, newData);
|
|
}
|
|
result2.placeholder = placeholder;
|
|
return setWrapToString(result2, func, bitmask);
|
|
}
|
|
function createRound(methodName) {
|
|
var func = Math2[methodName];
|
|
return function(number, precision) {
|
|
number = toNumber(number);
|
|
precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
|
|
if (precision && nativeIsFinite(number)) {
|
|
var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
|
|
pair = (toString(value) + "e").split("e");
|
|
return +(pair[0] + "e" + (+pair[1] - precision));
|
|
}
|
|
return func(number);
|
|
};
|
|
}
|
|
var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values2) {
|
|
return new Set2(values2);
|
|
};
|
|
function createToPairs(keysFunc) {
|
|
return function(object) {
|
|
var tag = getTag(object);
|
|
if (tag == mapTag) {
|
|
return mapToArray(object);
|
|
}
|
|
if (tag == setTag) {
|
|
return setToPairs(object);
|
|
}
|
|
return baseToPairs(object, keysFunc(object));
|
|
};
|
|
}
|
|
function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
|
|
var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
|
|
if (!isBindKey && typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
var length = partials ? partials.length : 0;
|
|
if (!length) {
|
|
bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
|
|
partials = holders = undefined2;
|
|
}
|
|
ary2 = ary2 === undefined2 ? ary2 : nativeMax(toInteger(ary2), 0);
|
|
arity = arity === undefined2 ? arity : toInteger(arity);
|
|
length -= holders ? holders.length : 0;
|
|
if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
|
|
var partialsRight = partials, holdersRight = holders;
|
|
partials = holders = undefined2;
|
|
}
|
|
var data = isBindKey ? undefined2 : getData(func);
|
|
var newData = [
|
|
func,
|
|
bitmask,
|
|
thisArg,
|
|
partials,
|
|
holders,
|
|
partialsRight,
|
|
holdersRight,
|
|
argPos,
|
|
ary2,
|
|
arity
|
|
];
|
|
if (data) {
|
|
mergeData(newData, data);
|
|
}
|
|
func = newData[0];
|
|
bitmask = newData[1];
|
|
thisArg = newData[2];
|
|
partials = newData[3];
|
|
holders = newData[4];
|
|
arity = newData[9] = newData[9] === undefined2 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);
|
|
if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
|
|
bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
|
|
}
|
|
if (!bitmask || bitmask == WRAP_BIND_FLAG) {
|
|
var result2 = createBind(func, bitmask, thisArg);
|
|
} else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
|
|
result2 = createCurry(func, bitmask, arity);
|
|
} else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
|
|
result2 = createPartial(func, bitmask, thisArg, partials);
|
|
} else {
|
|
result2 = createHybrid.apply(undefined2, newData);
|
|
}
|
|
var setter = data ? baseSetData : setData;
|
|
return setWrapToString(setter(result2, newData), func, bitmask);
|
|
}
|
|
function customDefaultsAssignIn(objValue, srcValue, key, object) {
|
|
if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key)) {
|
|
return srcValue;
|
|
}
|
|
return objValue;
|
|
}
|
|
function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
|
|
if (isObject(objValue) && isObject(srcValue)) {
|
|
stack.set(srcValue, objValue);
|
|
baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);
|
|
stack["delete"](srcValue);
|
|
}
|
|
return objValue;
|
|
}
|
|
function customOmitClone(value) {
|
|
return isPlainObject(value) ? undefined2 : value;
|
|
}
|
|
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
|
|
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
|
|
return false;
|
|
}
|
|
var arrStacked = stack.get(array);
|
|
var othStacked = stack.get(other);
|
|
if (arrStacked && othStacked) {
|
|
return arrStacked == other && othStacked == array;
|
|
}
|
|
var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache : undefined2;
|
|
stack.set(array, other);
|
|
stack.set(other, array);
|
|
while (++index < arrLength) {
|
|
var arrValue = array[index], othValue = other[index];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
|
|
}
|
|
if (compared !== undefined2) {
|
|
if (compared) {
|
|
continue;
|
|
}
|
|
result2 = false;
|
|
break;
|
|
}
|
|
if (seen) {
|
|
if (!arraySome(other, function(othValue2, othIndex) {
|
|
if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
|
|
return seen.push(othIndex);
|
|
}
|
|
})) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
}
|
|
stack["delete"](array);
|
|
stack["delete"](other);
|
|
return result2;
|
|
}
|
|
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
|
|
switch (tag) {
|
|
case dataViewTag:
|
|
if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
|
|
return false;
|
|
}
|
|
object = object.buffer;
|
|
other = other.buffer;
|
|
case arrayBufferTag:
|
|
if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case boolTag:
|
|
case dateTag:
|
|
case numberTag:
|
|
return eq(+object, +other);
|
|
case errorTag:
|
|
return object.name == other.name && object.message == other.message;
|
|
case regexpTag:
|
|
case stringTag:
|
|
return object == other + "";
|
|
case mapTag:
|
|
var convert = mapToArray;
|
|
case setTag:
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
|
|
convert || (convert = setToArray);
|
|
if (object.size != other.size && !isPartial) {
|
|
return false;
|
|
}
|
|
var stacked = stack.get(object);
|
|
if (stacked) {
|
|
return stacked == other;
|
|
}
|
|
bitmask |= COMPARE_UNORDERED_FLAG;
|
|
stack.set(object, other);
|
|
var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
|
|
stack["delete"](object);
|
|
return result2;
|
|
case symbolTag:
|
|
if (symbolValueOf) {
|
|
return symbolValueOf.call(object) == symbolValueOf.call(other);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
|
|
if (objLength != othLength && !isPartial) {
|
|
return false;
|
|
}
|
|
var index = objLength;
|
|
while (index--) {
|
|
var key = objProps[index];
|
|
if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
|
|
return false;
|
|
}
|
|
}
|
|
var objStacked = stack.get(object);
|
|
var othStacked = stack.get(other);
|
|
if (objStacked && othStacked) {
|
|
return objStacked == other && othStacked == object;
|
|
}
|
|
var result2 = true;
|
|
stack.set(object, other);
|
|
stack.set(other, object);
|
|
var skipCtor = isPartial;
|
|
while (++index < objLength) {
|
|
key = objProps[index];
|
|
var objValue = object[key], othValue = other[key];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
|
|
}
|
|
if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
skipCtor || (skipCtor = key == "constructor");
|
|
}
|
|
if (result2 && !skipCtor) {
|
|
var objCtor = object.constructor, othCtor = other.constructor;
|
|
if (objCtor != othCtor && (("constructor" in object) && ("constructor" in other)) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
|
|
result2 = false;
|
|
}
|
|
}
|
|
stack["delete"](object);
|
|
stack["delete"](other);
|
|
return result2;
|
|
}
|
|
function flatRest(func) {
|
|
return setToString(overRest(func, undefined2, flatten), func + "");
|
|
}
|
|
function getAllKeys(object) {
|
|
return baseGetAllKeys(object, keys, getSymbols);
|
|
}
|
|
function getAllKeysIn(object) {
|
|
return baseGetAllKeys(object, keysIn, getSymbolsIn);
|
|
}
|
|
var getData = !metaMap ? noop : function(func) {
|
|
return metaMap.get(func);
|
|
};
|
|
function getFuncName(func) {
|
|
var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty.call(realNames, result2) ? array.length : 0;
|
|
while (length--) {
|
|
var data = array[length], otherFunc = data.func;
|
|
if (otherFunc == null || otherFunc == func) {
|
|
return data.name;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function getHolder(func) {
|
|
var object = hasOwnProperty.call(lodash, "placeholder") ? lodash : func;
|
|
return object.placeholder;
|
|
}
|
|
function getIteratee() {
|
|
var result2 = lodash.iteratee || iteratee;
|
|
result2 = result2 === iteratee ? baseIteratee : result2;
|
|
return arguments.length ? result2(arguments[0], arguments[1]) : result2;
|
|
}
|
|
function getMapData(map2, key) {
|
|
var data = map2.__data__;
|
|
return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
|
|
}
|
|
function getMatchData(object) {
|
|
var result2 = keys(object), length = result2.length;
|
|
while (length--) {
|
|
var key = result2[length], value = object[key];
|
|
result2[length] = [key, value, isStrictComparable(value)];
|
|
}
|
|
return result2;
|
|
}
|
|
function getNative(object, key) {
|
|
var value = getValue(object, key);
|
|
return baseIsNative(value) ? value : undefined2;
|
|
}
|
|
function getRawTag(value) {
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
|
|
try {
|
|
value[symToStringTag] = undefined2;
|
|
var unmasked = true;
|
|
} catch (e) {
|
|
}
|
|
var result2 = nativeObjectToString.call(value);
|
|
if (unmasked) {
|
|
if (isOwn) {
|
|
value[symToStringTag] = tag;
|
|
} else {
|
|
delete value[symToStringTag];
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
|
|
if (object == null) {
|
|
return [];
|
|
}
|
|
object = Object2(object);
|
|
return arrayFilter(nativeGetSymbols(object), function(symbol) {
|
|
return propertyIsEnumerable.call(object, symbol);
|
|
});
|
|
};
|
|
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
|
|
var result2 = [];
|
|
while (object) {
|
|
arrayPush(result2, getSymbols(object));
|
|
object = getPrototype(object);
|
|
}
|
|
return result2;
|
|
};
|
|
var getTag = baseGetTag;
|
|
if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2) != setTag || WeakMap2 && getTag(new WeakMap2) != weakMapTag) {
|
|
getTag = function(value) {
|
|
var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : "";
|
|
if (ctorString) {
|
|
switch (ctorString) {
|
|
case dataViewCtorString:
|
|
return dataViewTag;
|
|
case mapCtorString:
|
|
return mapTag;
|
|
case promiseCtorString:
|
|
return promiseTag;
|
|
case setCtorString:
|
|
return setTag;
|
|
case weakMapCtorString:
|
|
return weakMapTag;
|
|
}
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
function getView(start, end, transforms) {
|
|
var index = -1, length = transforms.length;
|
|
while (++index < length) {
|
|
var data = transforms[index], size2 = data.size;
|
|
switch (data.type) {
|
|
case "drop":
|
|
start += size2;
|
|
break;
|
|
case "dropRight":
|
|
end -= size2;
|
|
break;
|
|
case "take":
|
|
end = nativeMin(end, start + size2);
|
|
break;
|
|
case "takeRight":
|
|
start = nativeMax(start, end - size2);
|
|
break;
|
|
}
|
|
}
|
|
return { start, end };
|
|
}
|
|
function getWrapDetails(source) {
|
|
var match = source.match(reWrapDetails);
|
|
return match ? match[1].split(reSplitDetails) : [];
|
|
}
|
|
function hasPath(object, path, hasFunc) {
|
|
path = castPath(path, object);
|
|
var index = -1, length = path.length, result2 = false;
|
|
while (++index < length) {
|
|
var key = toKey(path[index]);
|
|
if (!(result2 = object != null && hasFunc(object, key))) {
|
|
break;
|
|
}
|
|
object = object[key];
|
|
}
|
|
if (result2 || ++index != length) {
|
|
return result2;
|
|
}
|
|
length = object == null ? 0 : object.length;
|
|
return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
|
|
}
|
|
function initCloneArray(array) {
|
|
var length = array.length, result2 = new array.constructor(length);
|
|
if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
|
|
result2.index = array.index;
|
|
result2.input = array.input;
|
|
}
|
|
return result2;
|
|
}
|
|
function initCloneObject(object) {
|
|
return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
|
|
}
|
|
function initCloneByTag(object, tag, isDeep) {
|
|
var Ctor = object.constructor;
|
|
switch (tag) {
|
|
case arrayBufferTag:
|
|
return cloneArrayBuffer(object);
|
|
case boolTag:
|
|
case dateTag:
|
|
return new Ctor(+object);
|
|
case dataViewTag:
|
|
return cloneDataView(object, isDeep);
|
|
case float32Tag:
|
|
case float64Tag:
|
|
case int8Tag:
|
|
case int16Tag:
|
|
case int32Tag:
|
|
case uint8Tag:
|
|
case uint8ClampedTag:
|
|
case uint16Tag:
|
|
case uint32Tag:
|
|
return cloneTypedArray(object, isDeep);
|
|
case mapTag:
|
|
return new Ctor;
|
|
case numberTag:
|
|
case stringTag:
|
|
return new Ctor(object);
|
|
case regexpTag:
|
|
return cloneRegExp(object);
|
|
case setTag:
|
|
return new Ctor;
|
|
case symbolTag:
|
|
return cloneSymbol(object);
|
|
}
|
|
}
|
|
function insertWrapDetails(source, details) {
|
|
var length = details.length;
|
|
if (!length) {
|
|
return source;
|
|
}
|
|
var lastIndex = length - 1;
|
|
details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
|
|
details = details.join(length > 2 ? ", " : " ");
|
|
return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
|
|
}
|
|
function isFlattenable(value) {
|
|
return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
|
|
}
|
|
function isIndex(value, length) {
|
|
var type = typeof value;
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
function isIterateeCall(value, index, object) {
|
|
if (!isObject(object)) {
|
|
return false;
|
|
}
|
|
var type = typeof index;
|
|
if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && (index in object)) {
|
|
return eq(object[index], value);
|
|
}
|
|
return false;
|
|
}
|
|
function isKey(value, object) {
|
|
if (isArray(value)) {
|
|
return false;
|
|
}
|
|
var type = typeof value;
|
|
if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
|
|
return true;
|
|
}
|
|
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object);
|
|
}
|
|
function isKeyable(value) {
|
|
var type = typeof value;
|
|
return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
|
|
}
|
|
function isLaziable(func) {
|
|
var funcName = getFuncName(func), other = lodash[funcName];
|
|
if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
|
|
return false;
|
|
}
|
|
if (func === other) {
|
|
return true;
|
|
}
|
|
var data = getData(other);
|
|
return !!data && func === data[0];
|
|
}
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && maskSrcKey in func;
|
|
}
|
|
var isMaskable = coreJsData ? isFunction : stubFalse;
|
|
function isPrototype(value) {
|
|
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
|
|
return value === proto;
|
|
}
|
|
function isStrictComparable(value) {
|
|
return value === value && !isObject(value);
|
|
}
|
|
function matchesStrictComparable(key, srcValue) {
|
|
return function(object) {
|
|
if (object == null) {
|
|
return false;
|
|
}
|
|
return object[key] === srcValue && (srcValue !== undefined2 || (key in Object2(object)));
|
|
};
|
|
}
|
|
function memoizeCapped(func) {
|
|
var result2 = memoize(func, function(key) {
|
|
if (cache.size === MAX_MEMOIZE_SIZE) {
|
|
cache.clear();
|
|
}
|
|
return key;
|
|
});
|
|
var cache = result2.cache;
|
|
return result2;
|
|
}
|
|
function mergeData(data, source) {
|
|
var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
|
|
var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
|
|
if (!(isCommon || isCombo)) {
|
|
return data;
|
|
}
|
|
if (srcBitmask & WRAP_BIND_FLAG) {
|
|
data[2] = source[2];
|
|
newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
|
|
}
|
|
var value = source[3];
|
|
if (value) {
|
|
var partials = data[3];
|
|
data[3] = partials ? composeArgs(partials, value, source[4]) : value;
|
|
data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
|
|
}
|
|
value = source[5];
|
|
if (value) {
|
|
partials = data[5];
|
|
data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
|
|
data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
|
|
}
|
|
value = source[7];
|
|
if (value) {
|
|
data[7] = value;
|
|
}
|
|
if (srcBitmask & WRAP_ARY_FLAG) {
|
|
data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
|
|
}
|
|
if (data[9] == null) {
|
|
data[9] = source[9];
|
|
}
|
|
data[0] = source[0];
|
|
data[1] = newBitmask;
|
|
return data;
|
|
}
|
|
function nativeKeysIn(object) {
|
|
var result2 = [];
|
|
if (object != null) {
|
|
for (var key in Object2(object)) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function objectToString(value) {
|
|
return nativeObjectToString.call(value);
|
|
}
|
|
function overRest(func, start, transform2) {
|
|
start = nativeMax(start === undefined2 ? func.length - 1 : start, 0);
|
|
return function() {
|
|
var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length);
|
|
while (++index < length) {
|
|
array[index] = args[start + index];
|
|
}
|
|
index = -1;
|
|
var otherArgs = Array2(start + 1);
|
|
while (++index < start) {
|
|
otherArgs[index] = args[index];
|
|
}
|
|
otherArgs[start] = transform2(array);
|
|
return apply(func, this, otherArgs);
|
|
};
|
|
}
|
|
function parent(object, path) {
|
|
return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
|
|
}
|
|
function reorder(array, indexes) {
|
|
var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
|
|
while (length--) {
|
|
var index = indexes[length];
|
|
array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined2;
|
|
}
|
|
return array;
|
|
}
|
|
function safeGet(object, key) {
|
|
if (key === "constructor" && typeof object[key] === "function") {
|
|
return;
|
|
}
|
|
if (key == "__proto__") {
|
|
return;
|
|
}
|
|
return object[key];
|
|
}
|
|
var setData = shortOut(baseSetData);
|
|
var setTimeout2 = ctxSetTimeout || function(func, wait) {
|
|
return root.setTimeout(func, wait);
|
|
};
|
|
var setToString = shortOut(baseSetToString);
|
|
function setWrapToString(wrapper, reference, bitmask) {
|
|
var source = reference + "";
|
|
return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
|
|
}
|
|
function shortOut(func) {
|
|
var count = 0, lastCalled = 0;
|
|
return function() {
|
|
var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
|
|
lastCalled = stamp;
|
|
if (remaining > 0) {
|
|
if (++count >= HOT_COUNT) {
|
|
return arguments[0];
|
|
}
|
|
} else {
|
|
count = 0;
|
|
}
|
|
return func.apply(undefined2, arguments);
|
|
};
|
|
}
|
|
function shuffleSelf(array, size2) {
|
|
var index = -1, length = array.length, lastIndex = length - 1;
|
|
size2 = size2 === undefined2 ? length : size2;
|
|
while (++index < size2) {
|
|
var rand = baseRandom(index, lastIndex), value = array[rand];
|
|
array[rand] = array[index];
|
|
array[index] = value;
|
|
}
|
|
array.length = size2;
|
|
return array;
|
|
}
|
|
var stringToPath = memoizeCapped(function(string) {
|
|
var result2 = [];
|
|
if (string.charCodeAt(0) === 46) {
|
|
result2.push("");
|
|
}
|
|
string.replace(rePropName, function(match, number, quote, subString) {
|
|
result2.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
|
|
});
|
|
return result2;
|
|
});
|
|
function toKey(value) {
|
|
if (typeof value == "string" || isSymbol(value)) {
|
|
return value;
|
|
}
|
|
var result2 = value + "";
|
|
return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
|
|
}
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
return func + "";
|
|
} catch (e) {
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
function updateWrapDetails(details, bitmask) {
|
|
arrayEach(wrapFlags, function(pair) {
|
|
var value = "_." + pair[0];
|
|
if (bitmask & pair[1] && !arrayIncludes(details, value)) {
|
|
details.push(value);
|
|
}
|
|
});
|
|
return details.sort();
|
|
}
|
|
function wrapperClone(wrapper) {
|
|
if (wrapper instanceof LazyWrapper) {
|
|
return wrapper.clone();
|
|
}
|
|
var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
|
|
result2.__actions__ = copyArray(wrapper.__actions__);
|
|
result2.__index__ = wrapper.__index__;
|
|
result2.__values__ = wrapper.__values__;
|
|
return result2;
|
|
}
|
|
function chunk(array, size2, guard) {
|
|
if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined2) {
|
|
size2 = 1;
|
|
} else {
|
|
size2 = nativeMax(toInteger(size2), 0);
|
|
}
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length || size2 < 1) {
|
|
return [];
|
|
}
|
|
var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2));
|
|
while (index < length) {
|
|
result2[resIndex++] = baseSlice(array, index, index += size2);
|
|
}
|
|
return result2;
|
|
}
|
|
function compact(array) {
|
|
var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (value) {
|
|
result2[resIndex++] = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function concat() {
|
|
var length = arguments.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
var args = Array2(length - 1), array = arguments[0], index = length;
|
|
while (index--) {
|
|
args[index - 1] = arguments[index];
|
|
}
|
|
return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
|
|
}
|
|
var difference = baseRest(function(array, values2) {
|
|
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
|
|
});
|
|
var differenceBy = baseRest(function(array, values2) {
|
|
var iteratee2 = last(values2);
|
|
if (isArrayLikeObject(iteratee2)) {
|
|
iteratee2 = undefined2;
|
|
}
|
|
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];
|
|
});
|
|
var differenceWith = baseRest(function(array, values2) {
|
|
var comparator = last(values2);
|
|
if (isArrayLikeObject(comparator)) {
|
|
comparator = undefined2;
|
|
}
|
|
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined2, comparator) : [];
|
|
});
|
|
function drop(array, n, guard) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === undefined2 ? 1 : toInteger(n);
|
|
return baseSlice(array, n < 0 ? 0 : n, length);
|
|
}
|
|
function dropRight(array, n, guard) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === undefined2 ? 1 : toInteger(n);
|
|
n = length - n;
|
|
return baseSlice(array, 0, n < 0 ? 0 : n);
|
|
}
|
|
function dropRightWhile(array, predicate) {
|
|
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
|
|
}
|
|
function dropWhile(array, predicate) {
|
|
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
|
|
}
|
|
function fill(array, value, start, end) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
|
|
start = 0;
|
|
end = length;
|
|
}
|
|
return baseFill(array, value, start, end);
|
|
}
|
|
function findIndex(array, predicate, fromIndex) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = fromIndex == null ? 0 : toInteger(fromIndex);
|
|
if (index < 0) {
|
|
index = nativeMax(length + index, 0);
|
|
}
|
|
return baseFindIndex(array, getIteratee(predicate, 3), index);
|
|
}
|
|
function findLastIndex(array, predicate, fromIndex) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = length - 1;
|
|
if (fromIndex !== undefined2) {
|
|
index = toInteger(fromIndex);
|
|
index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
|
|
}
|
|
return baseFindIndex(array, getIteratee(predicate, 3), index, true);
|
|
}
|
|
function flatten(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? baseFlatten(array, 1) : [];
|
|
}
|
|
function flattenDeep(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? baseFlatten(array, INFINITY) : [];
|
|
}
|
|
function flattenDepth(array, depth) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
depth = depth === undefined2 ? 1 : toInteger(depth);
|
|
return baseFlatten(array, depth);
|
|
}
|
|
function fromPairs(pairs) {
|
|
var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
|
|
while (++index < length) {
|
|
var pair = pairs[index];
|
|
result2[pair[0]] = pair[1];
|
|
}
|
|
return result2;
|
|
}
|
|
function head(array) {
|
|
return array && array.length ? array[0] : undefined2;
|
|
}
|
|
function indexOf(array, value, fromIndex) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = fromIndex == null ? 0 : toInteger(fromIndex);
|
|
if (index < 0) {
|
|
index = nativeMax(length + index, 0);
|
|
}
|
|
return baseIndexOf(array, value, index);
|
|
}
|
|
function initial(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? baseSlice(array, 0, -1) : [];
|
|
}
|
|
var intersection = baseRest(function(arrays) {
|
|
var mapped = arrayMap(arrays, castArrayLikeObject);
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
|
|
});
|
|
var intersectionBy = baseRest(function(arrays) {
|
|
var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
|
|
if (iteratee2 === last(mapped)) {
|
|
iteratee2 = undefined2;
|
|
} else {
|
|
mapped.pop();
|
|
}
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];
|
|
});
|
|
var intersectionWith = baseRest(function(arrays) {
|
|
var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
|
|
comparator = typeof comparator == "function" ? comparator : undefined2;
|
|
if (comparator) {
|
|
mapped.pop();
|
|
}
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
|
|
});
|
|
function join(array, separator) {
|
|
return array == null ? "" : nativeJoin.call(array, separator);
|
|
}
|
|
function last(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? array[length - 1] : undefined2;
|
|
}
|
|
function lastIndexOf(array, value, fromIndex) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = length;
|
|
if (fromIndex !== undefined2) {
|
|
index = toInteger(fromIndex);
|
|
index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
|
|
}
|
|
return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);
|
|
}
|
|
function nth(array, n) {
|
|
return array && array.length ? baseNth(array, toInteger(n)) : undefined2;
|
|
}
|
|
var pull = baseRest(pullAll);
|
|
function pullAll(array, values2) {
|
|
return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
|
|
}
|
|
function pullAllBy(array, values2, iteratee2) {
|
|
return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
|
|
}
|
|
function pullAllWith(array, values2, comparator) {
|
|
return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array;
|
|
}
|
|
var pullAt = flatRest(function(array, indexes) {
|
|
var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);
|
|
basePullAt(array, arrayMap(indexes, function(index) {
|
|
return isIndex(index, length) ? +index : index;
|
|
}).sort(compareAscending));
|
|
return result2;
|
|
});
|
|
function remove(array, predicate) {
|
|
var result2 = [];
|
|
if (!(array && array.length)) {
|
|
return result2;
|
|
}
|
|
var index = -1, indexes = [], length = array.length;
|
|
predicate = getIteratee(predicate, 3);
|
|
while (++index < length) {
|
|
var value = array[index];
|
|
if (predicate(value, index, array)) {
|
|
result2.push(value);
|
|
indexes.push(index);
|
|
}
|
|
}
|
|
basePullAt(array, indexes);
|
|
return result2;
|
|
}
|
|
function reverse(array) {
|
|
return array == null ? array : nativeReverse.call(array);
|
|
}
|
|
function slice(array, start, end) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
|
|
start = 0;
|
|
end = length;
|
|
} else {
|
|
start = start == null ? 0 : toInteger(start);
|
|
end = end === undefined2 ? length : toInteger(end);
|
|
}
|
|
return baseSlice(array, start, end);
|
|
}
|
|
function sortedIndex(array, value) {
|
|
return baseSortedIndex(array, value);
|
|
}
|
|
function sortedIndexBy(array, value, iteratee2) {
|
|
return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));
|
|
}
|
|
function sortedIndexOf(array, value) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (length) {
|
|
var index = baseSortedIndex(array, value);
|
|
if (index < length && eq(array[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function sortedLastIndex(array, value) {
|
|
return baseSortedIndex(array, value, true);
|
|
}
|
|
function sortedLastIndexBy(array, value, iteratee2) {
|
|
return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);
|
|
}
|
|
function sortedLastIndexOf(array, value) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (length) {
|
|
var index = baseSortedIndex(array, value, true) - 1;
|
|
if (eq(array[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function sortedUniq(array) {
|
|
return array && array.length ? baseSortedUniq(array) : [];
|
|
}
|
|
function sortedUniqBy(array, iteratee2) {
|
|
return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
|
|
}
|
|
function tail(array) {
|
|
var length = array == null ? 0 : array.length;
|
|
return length ? baseSlice(array, 1, length) : [];
|
|
}
|
|
function take(array, n, guard) {
|
|
if (!(array && array.length)) {
|
|
return [];
|
|
}
|
|
n = guard || n === undefined2 ? 1 : toInteger(n);
|
|
return baseSlice(array, 0, n < 0 ? 0 : n);
|
|
}
|
|
function takeRight(array, n, guard) {
|
|
var length = array == null ? 0 : array.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === undefined2 ? 1 : toInteger(n);
|
|
n = length - n;
|
|
return baseSlice(array, n < 0 ? 0 : n, length);
|
|
}
|
|
function takeRightWhile(array, predicate) {
|
|
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
|
|
}
|
|
function takeWhile(array, predicate) {
|
|
return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
|
|
}
|
|
var union = baseRest(function(arrays) {
|
|
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
|
|
});
|
|
var unionBy = baseRest(function(arrays) {
|
|
var iteratee2 = last(arrays);
|
|
if (isArrayLikeObject(iteratee2)) {
|
|
iteratee2 = undefined2;
|
|
}
|
|
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));
|
|
});
|
|
var unionWith = baseRest(function(arrays) {
|
|
var comparator = last(arrays);
|
|
comparator = typeof comparator == "function" ? comparator : undefined2;
|
|
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined2, comparator);
|
|
});
|
|
function uniq(array) {
|
|
return array && array.length ? baseUniq(array) : [];
|
|
}
|
|
function uniqBy(array, iteratee2) {
|
|
return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
|
|
}
|
|
function uniqWith(array, comparator) {
|
|
comparator = typeof comparator == "function" ? comparator : undefined2;
|
|
return array && array.length ? baseUniq(array, undefined2, comparator) : [];
|
|
}
|
|
function unzip(array) {
|
|
if (!(array && array.length)) {
|
|
return [];
|
|
}
|
|
var length = 0;
|
|
array = arrayFilter(array, function(group) {
|
|
if (isArrayLikeObject(group)) {
|
|
length = nativeMax(group.length, length);
|
|
return true;
|
|
}
|
|
});
|
|
return baseTimes(length, function(index) {
|
|
return arrayMap(array, baseProperty(index));
|
|
});
|
|
}
|
|
function unzipWith(array, iteratee2) {
|
|
if (!(array && array.length)) {
|
|
return [];
|
|
}
|
|
var result2 = unzip(array);
|
|
if (iteratee2 == null) {
|
|
return result2;
|
|
}
|
|
return arrayMap(result2, function(group) {
|
|
return apply(iteratee2, undefined2, group);
|
|
});
|
|
}
|
|
var without = baseRest(function(array, values2) {
|
|
return isArrayLikeObject(array) ? baseDifference(array, values2) : [];
|
|
});
|
|
var xor = baseRest(function(arrays) {
|
|
return baseXor(arrayFilter(arrays, isArrayLikeObject));
|
|
});
|
|
var xorBy = baseRest(function(arrays) {
|
|
var iteratee2 = last(arrays);
|
|
if (isArrayLikeObject(iteratee2)) {
|
|
iteratee2 = undefined2;
|
|
}
|
|
return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));
|
|
});
|
|
var xorWith = baseRest(function(arrays) {
|
|
var comparator = last(arrays);
|
|
comparator = typeof comparator == "function" ? comparator : undefined2;
|
|
return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined2, comparator);
|
|
});
|
|
var zip = baseRest(unzip);
|
|
function zipObject(props, values2) {
|
|
return baseZipObject(props || [], values2 || [], assignValue);
|
|
}
|
|
function zipObjectDeep(props, values2) {
|
|
return baseZipObject(props || [], values2 || [], baseSet);
|
|
}
|
|
var zipWith = baseRest(function(arrays) {
|
|
var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined2;
|
|
iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined2;
|
|
return unzipWith(arrays, iteratee2);
|
|
});
|
|
function chain(value) {
|
|
var result2 = lodash(value);
|
|
result2.__chain__ = true;
|
|
return result2;
|
|
}
|
|
function tap(value, interceptor) {
|
|
interceptor(value);
|
|
return value;
|
|
}
|
|
function thru(value, interceptor) {
|
|
return interceptor(value);
|
|
}
|
|
var wrapperAt = flatRest(function(paths) {
|
|
var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {
|
|
return baseAt(object, paths);
|
|
};
|
|
if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {
|
|
return this.thru(interceptor);
|
|
}
|
|
value = value.slice(start, +start + (length ? 1 : 0));
|
|
value.__actions__.push({
|
|
func: thru,
|
|
args: [interceptor],
|
|
thisArg: undefined2
|
|
});
|
|
return new LodashWrapper(value, this.__chain__).thru(function(array) {
|
|
if (length && !array.length) {
|
|
array.push(undefined2);
|
|
}
|
|
return array;
|
|
});
|
|
});
|
|
function wrapperChain() {
|
|
return chain(this);
|
|
}
|
|
function wrapperCommit() {
|
|
return new LodashWrapper(this.value(), this.__chain__);
|
|
}
|
|
function wrapperNext() {
|
|
if (this.__values__ === undefined2) {
|
|
this.__values__ = toArray(this.value());
|
|
}
|
|
var done = this.__index__ >= this.__values__.length, value = done ? undefined2 : this.__values__[this.__index__++];
|
|
return { done, value };
|
|
}
|
|
function wrapperToIterator() {
|
|
return this;
|
|
}
|
|
function wrapperPlant(value) {
|
|
var result2, parent2 = this;
|
|
while (parent2 instanceof baseLodash) {
|
|
var clone2 = wrapperClone(parent2);
|
|
clone2.__index__ = 0;
|
|
clone2.__values__ = undefined2;
|
|
if (result2) {
|
|
previous.__wrapped__ = clone2;
|
|
} else {
|
|
result2 = clone2;
|
|
}
|
|
var previous = clone2;
|
|
parent2 = parent2.__wrapped__;
|
|
}
|
|
previous.__wrapped__ = value;
|
|
return result2;
|
|
}
|
|
function wrapperReverse() {
|
|
var value = this.__wrapped__;
|
|
if (value instanceof LazyWrapper) {
|
|
var wrapped = value;
|
|
if (this.__actions__.length) {
|
|
wrapped = new LazyWrapper(this);
|
|
}
|
|
wrapped = wrapped.reverse();
|
|
wrapped.__actions__.push({
|
|
func: thru,
|
|
args: [reverse],
|
|
thisArg: undefined2
|
|
});
|
|
return new LodashWrapper(wrapped, this.__chain__);
|
|
}
|
|
return this.thru(reverse);
|
|
}
|
|
function wrapperValue() {
|
|
return baseWrapperValue(this.__wrapped__, this.__actions__);
|
|
}
|
|
var countBy = createAggregator(function(result2, value, key) {
|
|
if (hasOwnProperty.call(result2, key)) {
|
|
++result2[key];
|
|
} else {
|
|
baseAssignValue(result2, key, 1);
|
|
}
|
|
});
|
|
function every(collection, predicate, guard) {
|
|
var func = isArray(collection) ? arrayEvery : baseEvery;
|
|
if (guard && isIterateeCall(collection, predicate, guard)) {
|
|
predicate = undefined2;
|
|
}
|
|
return func(collection, getIteratee(predicate, 3));
|
|
}
|
|
function filter(collection, predicate) {
|
|
var func = isArray(collection) ? arrayFilter : baseFilter;
|
|
return func(collection, getIteratee(predicate, 3));
|
|
}
|
|
var find = createFind(findIndex);
|
|
var findLast = createFind(findLastIndex);
|
|
function flatMap(collection, iteratee2) {
|
|
return baseFlatten(map(collection, iteratee2), 1);
|
|
}
|
|
function flatMapDeep(collection, iteratee2) {
|
|
return baseFlatten(map(collection, iteratee2), INFINITY);
|
|
}
|
|
function flatMapDepth(collection, iteratee2, depth) {
|
|
depth = depth === undefined2 ? 1 : toInteger(depth);
|
|
return baseFlatten(map(collection, iteratee2), depth);
|
|
}
|
|
function forEach(collection, iteratee2) {
|
|
var func = isArray(collection) ? arrayEach : baseEach;
|
|
return func(collection, getIteratee(iteratee2, 3));
|
|
}
|
|
function forEachRight(collection, iteratee2) {
|
|
var func = isArray(collection) ? arrayEachRight : baseEachRight;
|
|
return func(collection, getIteratee(iteratee2, 3));
|
|
}
|
|
var groupBy = createAggregator(function(result2, value, key) {
|
|
if (hasOwnProperty.call(result2, key)) {
|
|
result2[key].push(value);
|
|
} else {
|
|
baseAssignValue(result2, key, [value]);
|
|
}
|
|
});
|
|
function includes(collection, value, fromIndex, guard) {
|
|
collection = isArrayLike(collection) ? collection : values(collection);
|
|
fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
|
|
var length = collection.length;
|
|
if (fromIndex < 0) {
|
|
fromIndex = nativeMax(length + fromIndex, 0);
|
|
}
|
|
return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
|
|
}
|
|
var invokeMap = baseRest(function(collection, path, args) {
|
|
var index = -1, isFunc = typeof path == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
|
|
baseEach(collection, function(value) {
|
|
result2[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
|
|
});
|
|
return result2;
|
|
});
|
|
var keyBy = createAggregator(function(result2, value, key) {
|
|
baseAssignValue(result2, key, value);
|
|
});
|
|
function map(collection, iteratee2) {
|
|
var func = isArray(collection) ? arrayMap : baseMap;
|
|
return func(collection, getIteratee(iteratee2, 3));
|
|
}
|
|
function orderBy(collection, iteratees, orders, guard) {
|
|
if (collection == null) {
|
|
return [];
|
|
}
|
|
if (!isArray(iteratees)) {
|
|
iteratees = iteratees == null ? [] : [iteratees];
|
|
}
|
|
orders = guard ? undefined2 : orders;
|
|
if (!isArray(orders)) {
|
|
orders = orders == null ? [] : [orders];
|
|
}
|
|
return baseOrderBy(collection, iteratees, orders);
|
|
}
|
|
var partition = createAggregator(function(result2, value, key) {
|
|
result2[key ? 0 : 1].push(value);
|
|
}, function() {
|
|
return [[], []];
|
|
});
|
|
function reduce(collection, iteratee2, accumulator) {
|
|
var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
|
|
return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);
|
|
}
|
|
function reduceRight(collection, iteratee2, accumulator) {
|
|
var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
|
|
return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
|
|
}
|
|
function reject(collection, predicate) {
|
|
var func = isArray(collection) ? arrayFilter : baseFilter;
|
|
return func(collection, negate(getIteratee(predicate, 3)));
|
|
}
|
|
function sample(collection) {
|
|
var func = isArray(collection) ? arraySample : baseSample;
|
|
return func(collection);
|
|
}
|
|
function sampleSize(collection, n, guard) {
|
|
if (guard ? isIterateeCall(collection, n, guard) : n === undefined2) {
|
|
n = 1;
|
|
} else {
|
|
n = toInteger(n);
|
|
}
|
|
var func = isArray(collection) ? arraySampleSize : baseSampleSize;
|
|
return func(collection, n);
|
|
}
|
|
function shuffle(collection) {
|
|
var func = isArray(collection) ? arrayShuffle : baseShuffle;
|
|
return func(collection);
|
|
}
|
|
function size(collection) {
|
|
if (collection == null) {
|
|
return 0;
|
|
}
|
|
if (isArrayLike(collection)) {
|
|
return isString(collection) ? stringSize(collection) : collection.length;
|
|
}
|
|
var tag = getTag(collection);
|
|
if (tag == mapTag || tag == setTag) {
|
|
return collection.size;
|
|
}
|
|
return baseKeys(collection).length;
|
|
}
|
|
function some(collection, predicate, guard) {
|
|
var func = isArray(collection) ? arraySome : baseSome;
|
|
if (guard && isIterateeCall(collection, predicate, guard)) {
|
|
predicate = undefined2;
|
|
}
|
|
return func(collection, getIteratee(predicate, 3));
|
|
}
|
|
var sortBy = baseRest(function(collection, iteratees) {
|
|
if (collection == null) {
|
|
return [];
|
|
}
|
|
var length = iteratees.length;
|
|
if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
|
|
iteratees = [];
|
|
} else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
|
|
iteratees = [iteratees[0]];
|
|
}
|
|
return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
|
|
});
|
|
var now = ctxNow || function() {
|
|
return root.Date.now();
|
|
};
|
|
function after(n, func) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
n = toInteger(n);
|
|
return function() {
|
|
if (--n < 1) {
|
|
return func.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
function ary(func, n, guard) {
|
|
n = guard ? undefined2 : n;
|
|
n = func && n == null ? func.length : n;
|
|
return createWrap(func, WRAP_ARY_FLAG, undefined2, undefined2, undefined2, undefined2, n);
|
|
}
|
|
function before(n, func) {
|
|
var result2;
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
n = toInteger(n);
|
|
return function() {
|
|
if (--n > 0) {
|
|
result2 = func.apply(this, arguments);
|
|
}
|
|
if (n <= 1) {
|
|
func = undefined2;
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
var bind = baseRest(function(func, thisArg, partials) {
|
|
var bitmask = WRAP_BIND_FLAG;
|
|
if (partials.length) {
|
|
var holders = replaceHolders(partials, getHolder(bind));
|
|
bitmask |= WRAP_PARTIAL_FLAG;
|
|
}
|
|
return createWrap(func, bitmask, thisArg, partials, holders);
|
|
});
|
|
var bindKey = baseRest(function(object, key, partials) {
|
|
var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
|
|
if (partials.length) {
|
|
var holders = replaceHolders(partials, getHolder(bindKey));
|
|
bitmask |= WRAP_PARTIAL_FLAG;
|
|
}
|
|
return createWrap(key, bitmask, object, partials, holders);
|
|
});
|
|
function curry(func, arity, guard) {
|
|
arity = guard ? undefined2 : arity;
|
|
var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
|
|
result2.placeholder = curry.placeholder;
|
|
return result2;
|
|
}
|
|
function curryRight(func, arity, guard) {
|
|
arity = guard ? undefined2 : arity;
|
|
var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
|
|
result2.placeholder = curryRight.placeholder;
|
|
return result2;
|
|
}
|
|
function debounce(func, wait, options) {
|
|
var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
wait = toNumber(wait) || 0;
|
|
if (isObject(options)) {
|
|
leading = !!options.leading;
|
|
maxing = "maxWait" in options;
|
|
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
function invokeFunc(time) {
|
|
var args = lastArgs, thisArg = lastThis;
|
|
lastArgs = lastThis = undefined2;
|
|
lastInvokeTime = time;
|
|
result2 = func.apply(thisArg, args);
|
|
return result2;
|
|
}
|
|
function leadingEdge(time) {
|
|
lastInvokeTime = time;
|
|
timerId = setTimeout2(timerExpired, wait);
|
|
return leading ? invokeFunc(time) : result2;
|
|
}
|
|
function remainingWait(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
|
|
return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
|
|
}
|
|
function shouldInvoke(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
|
|
return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
|
|
}
|
|
function timerExpired() {
|
|
var time = now();
|
|
if (shouldInvoke(time)) {
|
|
return trailingEdge(time);
|
|
}
|
|
timerId = setTimeout2(timerExpired, remainingWait(time));
|
|
}
|
|
function trailingEdge(time) {
|
|
timerId = undefined2;
|
|
if (trailing && lastArgs) {
|
|
return invokeFunc(time);
|
|
}
|
|
lastArgs = lastThis = undefined2;
|
|
return result2;
|
|
}
|
|
function cancel() {
|
|
if (timerId !== undefined2) {
|
|
clearTimeout2(timerId);
|
|
}
|
|
lastInvokeTime = 0;
|
|
lastArgs = lastCallTime = lastThis = timerId = undefined2;
|
|
}
|
|
function flush() {
|
|
return timerId === undefined2 ? result2 : trailingEdge(now());
|
|
}
|
|
function debounced() {
|
|
var time = now(), isInvoking = shouldInvoke(time);
|
|
lastArgs = arguments;
|
|
lastThis = this;
|
|
lastCallTime = time;
|
|
if (isInvoking) {
|
|
if (timerId === undefined2) {
|
|
return leadingEdge(lastCallTime);
|
|
}
|
|
if (maxing) {
|
|
clearTimeout2(timerId);
|
|
timerId = setTimeout2(timerExpired, wait);
|
|
return invokeFunc(lastCallTime);
|
|
}
|
|
}
|
|
if (timerId === undefined2) {
|
|
timerId = setTimeout2(timerExpired, wait);
|
|
}
|
|
return result2;
|
|
}
|
|
debounced.cancel = cancel;
|
|
debounced.flush = flush;
|
|
return debounced;
|
|
}
|
|
var defer = baseRest(function(func, args) {
|
|
return baseDelay(func, 1, args);
|
|
});
|
|
var delay = baseRest(function(func, wait, args) {
|
|
return baseDelay(func, toNumber(wait) || 0, args);
|
|
});
|
|
function flip(func) {
|
|
return createWrap(func, WRAP_FLIP_FLAG);
|
|
}
|
|
function memoize(func, resolver) {
|
|
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
var memoized = function() {
|
|
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
|
|
if (cache.has(key)) {
|
|
return cache.get(key);
|
|
}
|
|
var result2 = func.apply(this, args);
|
|
memoized.cache = cache.set(key, result2) || cache;
|
|
return result2;
|
|
};
|
|
memoized.cache = new (memoize.Cache || MapCache);
|
|
return memoized;
|
|
}
|
|
memoize.Cache = MapCache;
|
|
function negate(predicate) {
|
|
if (typeof predicate != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
return function() {
|
|
var args = arguments;
|
|
switch (args.length) {
|
|
case 0:
|
|
return !predicate.call(this);
|
|
case 1:
|
|
return !predicate.call(this, args[0]);
|
|
case 2:
|
|
return !predicate.call(this, args[0], args[1]);
|
|
case 3:
|
|
return !predicate.call(this, args[0], args[1], args[2]);
|
|
}
|
|
return !predicate.apply(this, args);
|
|
};
|
|
}
|
|
function once(func) {
|
|
return before(2, func);
|
|
}
|
|
var overArgs = castRest(function(func, transforms) {
|
|
transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
|
|
var funcsLength = transforms.length;
|
|
return baseRest(function(args) {
|
|
var index = -1, length = nativeMin(args.length, funcsLength);
|
|
while (++index < length) {
|
|
args[index] = transforms[index].call(this, args[index]);
|
|
}
|
|
return apply(func, this, args);
|
|
});
|
|
});
|
|
var partial = baseRest(function(func, partials) {
|
|
var holders = replaceHolders(partials, getHolder(partial));
|
|
return createWrap(func, WRAP_PARTIAL_FLAG, undefined2, partials, holders);
|
|
});
|
|
var partialRight = baseRest(function(func, partials) {
|
|
var holders = replaceHolders(partials, getHolder(partialRight));
|
|
return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined2, partials, holders);
|
|
});
|
|
var rearg = flatRest(function(func, indexes) {
|
|
return createWrap(func, WRAP_REARG_FLAG, undefined2, undefined2, undefined2, indexes);
|
|
});
|
|
function rest(func, start) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
start = start === undefined2 ? start : toInteger(start);
|
|
return baseRest(func, start);
|
|
}
|
|
function spread(func, start) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
start = start == null ? 0 : nativeMax(toInteger(start), 0);
|
|
return baseRest(function(args) {
|
|
var array = args[start], otherArgs = castSlice(args, 0, start);
|
|
if (array) {
|
|
arrayPush(otherArgs, array);
|
|
}
|
|
return apply(func, this, otherArgs);
|
|
});
|
|
}
|
|
function throttle(func, wait, options) {
|
|
var leading = true, trailing = true;
|
|
if (typeof func != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
if (isObject(options)) {
|
|
leading = "leading" in options ? !!options.leading : leading;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
return debounce(func, wait, {
|
|
leading,
|
|
maxWait: wait,
|
|
trailing
|
|
});
|
|
}
|
|
function unary(func) {
|
|
return ary(func, 1);
|
|
}
|
|
function wrap(value, wrapper) {
|
|
return partial(castFunction(wrapper), value);
|
|
}
|
|
function castArray() {
|
|
if (!arguments.length) {
|
|
return [];
|
|
}
|
|
var value = arguments[0];
|
|
return isArray(value) ? value : [value];
|
|
}
|
|
function clone(value) {
|
|
return baseClone(value, CLONE_SYMBOLS_FLAG);
|
|
}
|
|
function cloneWith(value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
|
|
}
|
|
function cloneDeep(value) {
|
|
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
|
|
}
|
|
function cloneDeepWith(value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
|
|
}
|
|
function conformsTo(object, source) {
|
|
return source == null || baseConformsTo(object, source, keys(source));
|
|
}
|
|
function eq(value, other) {
|
|
return value === other || value !== value && other !== other;
|
|
}
|
|
var gt = createRelationalOperation(baseGt);
|
|
var gte = createRelationalOperation(function(value, other) {
|
|
return value >= other;
|
|
});
|
|
var isArguments = baseIsArguments(function() {
|
|
return arguments;
|
|
}()) ? baseIsArguments : function(value) {
|
|
return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
|
|
};
|
|
var isArray = Array2.isArray;
|
|
var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
|
|
function isArrayLike(value) {
|
|
return value != null && isLength(value.length) && !isFunction(value);
|
|
}
|
|
function isArrayLikeObject(value) {
|
|
return isObjectLike(value) && isArrayLike(value);
|
|
}
|
|
function isBoolean(value) {
|
|
return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
|
|
}
|
|
var isBuffer = nativeIsBuffer || stubFalse;
|
|
var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
|
|
function isElement(value) {
|
|
return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
|
|
}
|
|
function isEmpty(value) {
|
|
if (value == null) {
|
|
return true;
|
|
}
|
|
if (isArrayLike(value) && (isArray(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
|
|
return !value.length;
|
|
}
|
|
var tag = getTag(value);
|
|
if (tag == mapTag || tag == setTag) {
|
|
return !value.size;
|
|
}
|
|
if (isPrototype(value)) {
|
|
return !baseKeys(value).length;
|
|
}
|
|
for (var key in value) {
|
|
if (hasOwnProperty.call(value, key)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isEqual(value, other) {
|
|
return baseIsEqual(value, other);
|
|
}
|
|
function isEqualWith(value, other, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
var result2 = customizer ? customizer(value, other) : undefined2;
|
|
return result2 === undefined2 ? baseIsEqual(value, other, undefined2, customizer) : !!result2;
|
|
}
|
|
function isError(value) {
|
|
if (!isObjectLike(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag(value);
|
|
return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
|
|
}
|
|
function isFinite2(value) {
|
|
return typeof value == "number" && nativeIsFinite(value);
|
|
}
|
|
function isFunction(value) {
|
|
if (!isObject(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag(value);
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
}
|
|
function isInteger(value) {
|
|
return typeof value == "number" && value == toInteger(value);
|
|
}
|
|
function isLength(value) {
|
|
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
}
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return value != null && (type == "object" || type == "function");
|
|
}
|
|
function isObjectLike(value) {
|
|
return value != null && typeof value == "object";
|
|
}
|
|
var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
|
|
function isMatch(object, source) {
|
|
return object === source || baseIsMatch(object, source, getMatchData(source));
|
|
}
|
|
function isMatchWith(object, source, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
return baseIsMatch(object, source, getMatchData(source), customizer);
|
|
}
|
|
function isNaN2(value) {
|
|
return isNumber(value) && value != +value;
|
|
}
|
|
function isNative(value) {
|
|
if (isMaskable(value)) {
|
|
throw new Error2(CORE_ERROR_TEXT);
|
|
}
|
|
return baseIsNative(value);
|
|
}
|
|
function isNull(value) {
|
|
return value === null;
|
|
}
|
|
function isNil(value) {
|
|
return value == null;
|
|
}
|
|
function isNumber(value) {
|
|
return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
|
|
}
|
|
function isPlainObject(value) {
|
|
if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
|
|
return false;
|
|
}
|
|
var proto = getPrototype(value);
|
|
if (proto === null) {
|
|
return true;
|
|
}
|
|
var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
|
|
}
|
|
var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
|
|
function isSafeInteger(value) {
|
|
return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
|
|
}
|
|
var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
|
|
function isString(value) {
|
|
return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
|
|
}
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
|
|
}
|
|
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
|
function isUndefined(value) {
|
|
return value === undefined2;
|
|
}
|
|
function isWeakMap(value) {
|
|
return isObjectLike(value) && getTag(value) == weakMapTag;
|
|
}
|
|
function isWeakSet(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == weakSetTag;
|
|
}
|
|
var lt = createRelationalOperation(baseLt);
|
|
var lte = createRelationalOperation(function(value, other) {
|
|
return value <= other;
|
|
});
|
|
function toArray(value) {
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
if (isArrayLike(value)) {
|
|
return isString(value) ? stringToArray(value) : copyArray(value);
|
|
}
|
|
if (symIterator && value[symIterator]) {
|
|
return iteratorToArray(value[symIterator]());
|
|
}
|
|
var tag = getTag(value), func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values;
|
|
return func(value);
|
|
}
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber(value);
|
|
if (value === INFINITY || value === -INFINITY) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
function toInteger(value) {
|
|
var result2 = toFinite(value), remainder = result2 % 1;
|
|
return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
|
|
}
|
|
function toLength(value) {
|
|
return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
|
|
}
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = baseTrim(value);
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
|
}
|
|
function toPlainObject(value) {
|
|
return copyObject(value, keysIn(value));
|
|
}
|
|
function toSafeInteger(value) {
|
|
return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
|
|
}
|
|
function toString(value) {
|
|
return value == null ? "" : baseToString(value);
|
|
}
|
|
var assign = createAssigner(function(object, source) {
|
|
if (isPrototype(source) || isArrayLike(source)) {
|
|
copyObject(source, keys(source), object);
|
|
return;
|
|
}
|
|
for (var key in source) {
|
|
if (hasOwnProperty.call(source, key)) {
|
|
assignValue(object, key, source[key]);
|
|
}
|
|
}
|
|
});
|
|
var assignIn = createAssigner(function(object, source) {
|
|
copyObject(source, keysIn(source), object);
|
|
});
|
|
var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
|
|
copyObject(source, keysIn(source), object, customizer);
|
|
});
|
|
var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
|
|
copyObject(source, keys(source), object, customizer);
|
|
});
|
|
var at = flatRest(baseAt);
|
|
function create(prototype, properties) {
|
|
var result2 = baseCreate(prototype);
|
|
return properties == null ? result2 : baseAssign(result2, properties);
|
|
}
|
|
var defaults = baseRest(function(object, sources) {
|
|
object = Object2(object);
|
|
var index = -1;
|
|
var length = sources.length;
|
|
var guard = length > 2 ? sources[2] : undefined2;
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
|
length = 1;
|
|
}
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
var props = keysIn(source);
|
|
var propsIndex = -1;
|
|
var propsLength = props.length;
|
|
while (++propsIndex < propsLength) {
|
|
var key = props[propsIndex];
|
|
var value = object[key];
|
|
if (value === undefined2 || eq(value, objectProto[key]) && !hasOwnProperty.call(object, key)) {
|
|
object[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return object;
|
|
});
|
|
var defaultsDeep = baseRest(function(args) {
|
|
args.push(undefined2, customDefaultsMerge);
|
|
return apply(mergeWith, undefined2, args);
|
|
});
|
|
function findKey(object, predicate) {
|
|
return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
|
|
}
|
|
function findLastKey(object, predicate) {
|
|
return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
|
|
}
|
|
function forIn(object, iteratee2) {
|
|
return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);
|
|
}
|
|
function forInRight(object, iteratee2) {
|
|
return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);
|
|
}
|
|
function forOwn(object, iteratee2) {
|
|
return object && baseForOwn(object, getIteratee(iteratee2, 3));
|
|
}
|
|
function forOwnRight(object, iteratee2) {
|
|
return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
|
|
}
|
|
function functions(object) {
|
|
return object == null ? [] : baseFunctions(object, keys(object));
|
|
}
|
|
function functionsIn(object) {
|
|
return object == null ? [] : baseFunctions(object, keysIn(object));
|
|
}
|
|
function get(object, path, defaultValue) {
|
|
var result2 = object == null ? undefined2 : baseGet(object, path);
|
|
return result2 === undefined2 ? defaultValue : result2;
|
|
}
|
|
function has(object, path) {
|
|
return object != null && hasPath(object, path, baseHas);
|
|
}
|
|
function hasIn(object, path) {
|
|
return object != null && hasPath(object, path, baseHasIn);
|
|
}
|
|
var invert = createInverter(function(result2, value, key) {
|
|
if (value != null && typeof value.toString != "function") {
|
|
value = nativeObjectToString.call(value);
|
|
}
|
|
result2[value] = key;
|
|
}, constant(identity));
|
|
var invertBy = createInverter(function(result2, value, key) {
|
|
if (value != null && typeof value.toString != "function") {
|
|
value = nativeObjectToString.call(value);
|
|
}
|
|
if (hasOwnProperty.call(result2, value)) {
|
|
result2[value].push(key);
|
|
} else {
|
|
result2[value] = [key];
|
|
}
|
|
}, getIteratee);
|
|
var invoke = baseRest(baseInvoke);
|
|
function keys(object) {
|
|
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
|
}
|
|
function keysIn(object) {
|
|
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
|
|
}
|
|
function mapKeys(object, iteratee2) {
|
|
var result2 = {};
|
|
iteratee2 = getIteratee(iteratee2, 3);
|
|
baseForOwn(object, function(value, key, object2) {
|
|
baseAssignValue(result2, iteratee2(value, key, object2), value);
|
|
});
|
|
return result2;
|
|
}
|
|
function mapValues(object, iteratee2) {
|
|
var result2 = {};
|
|
iteratee2 = getIteratee(iteratee2, 3);
|
|
baseForOwn(object, function(value, key, object2) {
|
|
baseAssignValue(result2, key, iteratee2(value, key, object2));
|
|
});
|
|
return result2;
|
|
}
|
|
var merge = createAssigner(function(object, source, srcIndex) {
|
|
baseMerge(object, source, srcIndex);
|
|
});
|
|
var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
|
|
baseMerge(object, source, srcIndex, customizer);
|
|
});
|
|
var omit = flatRest(function(object, paths) {
|
|
var result2 = {};
|
|
if (object == null) {
|
|
return result2;
|
|
}
|
|
var isDeep = false;
|
|
paths = arrayMap(paths, function(path) {
|
|
path = castPath(path, object);
|
|
isDeep || (isDeep = path.length > 1);
|
|
return path;
|
|
});
|
|
copyObject(object, getAllKeysIn(object), result2);
|
|
if (isDeep) {
|
|
result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
|
|
}
|
|
var length = paths.length;
|
|
while (length--) {
|
|
baseUnset(result2, paths[length]);
|
|
}
|
|
return result2;
|
|
});
|
|
function omitBy(object, predicate) {
|
|
return pickBy(object, negate(getIteratee(predicate)));
|
|
}
|
|
var pick = flatRest(function(object, paths) {
|
|
return object == null ? {} : basePick(object, paths);
|
|
});
|
|
function pickBy(object, predicate) {
|
|
if (object == null) {
|
|
return {};
|
|
}
|
|
var props = arrayMap(getAllKeysIn(object), function(prop) {
|
|
return [prop];
|
|
});
|
|
predicate = getIteratee(predicate);
|
|
return basePickBy(object, props, function(value, path) {
|
|
return predicate(value, path[0]);
|
|
});
|
|
}
|
|
function result(object, path, defaultValue) {
|
|
path = castPath(path, object);
|
|
var index = -1, length = path.length;
|
|
if (!length) {
|
|
length = 1;
|
|
object = undefined2;
|
|
}
|
|
while (++index < length) {
|
|
var value = object == null ? undefined2 : object[toKey(path[index])];
|
|
if (value === undefined2) {
|
|
index = length;
|
|
value = defaultValue;
|
|
}
|
|
object = isFunction(value) ? value.call(object) : value;
|
|
}
|
|
return object;
|
|
}
|
|
function set(object, path, value) {
|
|
return object == null ? object : baseSet(object, path, value);
|
|
}
|
|
function setWith(object, path, value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
return object == null ? object : baseSet(object, path, value, customizer);
|
|
}
|
|
var toPairs = createToPairs(keys);
|
|
var toPairsIn = createToPairs(keysIn);
|
|
function transform(object, iteratee2, accumulator) {
|
|
var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);
|
|
iteratee2 = getIteratee(iteratee2, 4);
|
|
if (accumulator == null) {
|
|
var Ctor = object && object.constructor;
|
|
if (isArrLike) {
|
|
accumulator = isArr ? new Ctor : [];
|
|
} else if (isObject(object)) {
|
|
accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
|
|
} else {
|
|
accumulator = {};
|
|
}
|
|
}
|
|
(isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
|
|
return iteratee2(accumulator, value, index, object2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
function unset(object, path) {
|
|
return object == null ? true : baseUnset(object, path);
|
|
}
|
|
function update(object, path, updater) {
|
|
return object == null ? object : baseUpdate(object, path, castFunction(updater));
|
|
}
|
|
function updateWith(object, path, updater, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : undefined2;
|
|
return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
|
|
}
|
|
function values(object) {
|
|
return object == null ? [] : baseValues(object, keys(object));
|
|
}
|
|
function valuesIn(object) {
|
|
return object == null ? [] : baseValues(object, keysIn(object));
|
|
}
|
|
function clamp(number, lower, upper) {
|
|
if (upper === undefined2) {
|
|
upper = lower;
|
|
lower = undefined2;
|
|
}
|
|
if (upper !== undefined2) {
|
|
upper = toNumber(upper);
|
|
upper = upper === upper ? upper : 0;
|
|
}
|
|
if (lower !== undefined2) {
|
|
lower = toNumber(lower);
|
|
lower = lower === lower ? lower : 0;
|
|
}
|
|
return baseClamp(toNumber(number), lower, upper);
|
|
}
|
|
function inRange(number, start, end) {
|
|
start = toFinite(start);
|
|
if (end === undefined2) {
|
|
end = start;
|
|
start = 0;
|
|
} else {
|
|
end = toFinite(end);
|
|
}
|
|
number = toNumber(number);
|
|
return baseInRange(number, start, end);
|
|
}
|
|
function random(lower, upper, floating) {
|
|
if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
|
|
upper = floating = undefined2;
|
|
}
|
|
if (floating === undefined2) {
|
|
if (typeof upper == "boolean") {
|
|
floating = upper;
|
|
upper = undefined2;
|
|
} else if (typeof lower == "boolean") {
|
|
floating = lower;
|
|
lower = undefined2;
|
|
}
|
|
}
|
|
if (lower === undefined2 && upper === undefined2) {
|
|
lower = 0;
|
|
upper = 1;
|
|
} else {
|
|
lower = toFinite(lower);
|
|
if (upper === undefined2) {
|
|
upper = lower;
|
|
lower = 0;
|
|
} else {
|
|
upper = toFinite(upper);
|
|
}
|
|
}
|
|
if (lower > upper) {
|
|
var temp = lower;
|
|
lower = upper;
|
|
upper = temp;
|
|
}
|
|
if (floating || lower % 1 || upper % 1) {
|
|
var rand = nativeRandom();
|
|
return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
|
|
}
|
|
return baseRandom(lower, upper);
|
|
}
|
|
var camelCase = createCompounder(function(result2, word, index) {
|
|
word = word.toLowerCase();
|
|
return result2 + (index ? capitalize(word) : word);
|
|
});
|
|
function capitalize(string) {
|
|
return upperFirst(toString(string).toLowerCase());
|
|
}
|
|
function deburr(string) {
|
|
string = toString(string);
|
|
return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
|
|
}
|
|
function endsWith(string, target, position) {
|
|
string = toString(string);
|
|
target = baseToString(target);
|
|
var length = string.length;
|
|
position = position === undefined2 ? length : baseClamp(toInteger(position), 0, length);
|
|
var end = position;
|
|
position -= target.length;
|
|
return position >= 0 && string.slice(position, end) == target;
|
|
}
|
|
function escape(string) {
|
|
string = toString(string);
|
|
return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
|
|
}
|
|
function escapeRegExp(string) {
|
|
string = toString(string);
|
|
return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
|
|
}
|
|
var kebabCase = createCompounder(function(result2, word, index) {
|
|
return result2 + (index ? "-" : "") + word.toLowerCase();
|
|
});
|
|
var lowerCase = createCompounder(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + word.toLowerCase();
|
|
});
|
|
var lowerFirst = createCaseFirst("toLowerCase");
|
|
function pad(string, length, chars) {
|
|
string = toString(string);
|
|
length = toInteger(length);
|
|
var strLength = length ? stringSize(string) : 0;
|
|
if (!length || strLength >= length) {
|
|
return string;
|
|
}
|
|
var mid = (length - strLength) / 2;
|
|
return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars);
|
|
}
|
|
function padEnd(string, length, chars) {
|
|
string = toString(string);
|
|
length = toInteger(length);
|
|
var strLength = length ? stringSize(string) : 0;
|
|
return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
|
|
}
|
|
function padStart(string, length, chars) {
|
|
string = toString(string);
|
|
length = toInteger(length);
|
|
var strLength = length ? stringSize(string) : 0;
|
|
return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
|
|
}
|
|
function parseInt2(string, radix, guard) {
|
|
if (guard || radix == null) {
|
|
radix = 0;
|
|
} else if (radix) {
|
|
radix = +radix;
|
|
}
|
|
return nativeParseInt(toString(string).replace(reTrimStart, ""), radix || 0);
|
|
}
|
|
function repeat(string, n, guard) {
|
|
if (guard ? isIterateeCall(string, n, guard) : n === undefined2) {
|
|
n = 1;
|
|
} else {
|
|
n = toInteger(n);
|
|
}
|
|
return baseRepeat(toString(string), n);
|
|
}
|
|
function replace() {
|
|
var args = arguments, string = toString(args[0]);
|
|
return args.length < 3 ? string : string.replace(args[1], args[2]);
|
|
}
|
|
var snakeCase = createCompounder(function(result2, word, index) {
|
|
return result2 + (index ? "_" : "") + word.toLowerCase();
|
|
});
|
|
function split(string, separator, limit) {
|
|
if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
|
|
separator = limit = undefined2;
|
|
}
|
|
limit = limit === undefined2 ? MAX_ARRAY_LENGTH : limit >>> 0;
|
|
if (!limit) {
|
|
return [];
|
|
}
|
|
string = toString(string);
|
|
if (string && (typeof separator == "string" || separator != null && !isRegExp(separator))) {
|
|
separator = baseToString(separator);
|
|
if (!separator && hasUnicode(string)) {
|
|
return castSlice(stringToArray(string), 0, limit);
|
|
}
|
|
}
|
|
return string.split(separator, limit);
|
|
}
|
|
var startCase = createCompounder(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + upperFirst(word);
|
|
});
|
|
function startsWith(string, target, position) {
|
|
string = toString(string);
|
|
position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
|
|
target = baseToString(target);
|
|
return string.slice(position, position + target.length) == target;
|
|
}
|
|
function template(string, options, guard) {
|
|
var settings = lodash.templateSettings;
|
|
if (guard && isIterateeCall(string, options, guard)) {
|
|
options = undefined2;
|
|
}
|
|
string = toString(string);
|
|
options = assignInWith({}, options, settings, customDefaultsAssignIn);
|
|
var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
|
|
var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
|
|
var reDelimiters = RegExp2((options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", "g");
|
|
var sourceURL = "//# sourceURL=" + (hasOwnProperty.call(options, "sourceURL") ? (options.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n";
|
|
string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
|
|
interpolateValue || (interpolateValue = esTemplateValue);
|
|
source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
|
|
if (escapeValue) {
|
|
isEscaping = true;
|
|
source += "' +\n__e(" + escapeValue + ") +\n'";
|
|
}
|
|
if (evaluateValue) {
|
|
isEvaluating = true;
|
|
source += "';\n" + evaluateValue + ";\n__p += '";
|
|
}
|
|
if (interpolateValue) {
|
|
source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
|
|
}
|
|
index = offset + match.length;
|
|
return match;
|
|
});
|
|
source += "';\n";
|
|
var variable = hasOwnProperty.call(options, "variable") && options.variable;
|
|
if (!variable) {
|
|
source = "with (obj) {\n" + source + "\n}\n";
|
|
} else if (reForbiddenIdentifierChars.test(variable)) {
|
|
throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);
|
|
}
|
|
source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
|
|
source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\n" + "function print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
|
|
var result2 = attempt(function() {
|
|
return Function2(importsKeys, sourceURL + "return " + source).apply(undefined2, importsValues);
|
|
});
|
|
result2.source = source;
|
|
if (isError(result2)) {
|
|
throw result2;
|
|
}
|
|
return result2;
|
|
}
|
|
function toLower(value) {
|
|
return toString(value).toLowerCase();
|
|
}
|
|
function toUpper(value) {
|
|
return toString(value).toUpperCase();
|
|
}
|
|
function trim(string, chars, guard) {
|
|
string = toString(string);
|
|
if (string && (guard || chars === undefined2)) {
|
|
return baseTrim(string);
|
|
}
|
|
if (!string || !(chars = baseToString(chars))) {
|
|
return string;
|
|
}
|
|
var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
|
|
return castSlice(strSymbols, start, end).join("");
|
|
}
|
|
function trimEnd(string, chars, guard) {
|
|
string = toString(string);
|
|
if (string && (guard || chars === undefined2)) {
|
|
return string.slice(0, trimmedEndIndex(string) + 1);
|
|
}
|
|
if (!string || !(chars = baseToString(chars))) {
|
|
return string;
|
|
}
|
|
var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
|
|
return castSlice(strSymbols, 0, end).join("");
|
|
}
|
|
function trimStart(string, chars, guard) {
|
|
string = toString(string);
|
|
if (string && (guard || chars === undefined2)) {
|
|
return string.replace(reTrimStart, "");
|
|
}
|
|
if (!string || !(chars = baseToString(chars))) {
|
|
return string;
|
|
}
|
|
var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
|
|
return castSlice(strSymbols, start).join("");
|
|
}
|
|
function truncate(string, options) {
|
|
var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
|
|
if (isObject(options)) {
|
|
var separator = "separator" in options ? options.separator : separator;
|
|
length = "length" in options ? toInteger(options.length) : length;
|
|
omission = "omission" in options ? baseToString(options.omission) : omission;
|
|
}
|
|
string = toString(string);
|
|
var strLength = string.length;
|
|
if (hasUnicode(string)) {
|
|
var strSymbols = stringToArray(string);
|
|
strLength = strSymbols.length;
|
|
}
|
|
if (length >= strLength) {
|
|
return string;
|
|
}
|
|
var end = length - stringSize(omission);
|
|
if (end < 1) {
|
|
return omission;
|
|
}
|
|
var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
|
|
if (separator === undefined2) {
|
|
return result2 + omission;
|
|
}
|
|
if (strSymbols) {
|
|
end += result2.length - end;
|
|
}
|
|
if (isRegExp(separator)) {
|
|
if (string.slice(end).search(separator)) {
|
|
var match, substring = result2;
|
|
if (!separator.global) {
|
|
separator = RegExp2(separator.source, toString(reFlags.exec(separator)) + "g");
|
|
}
|
|
separator.lastIndex = 0;
|
|
while (match = separator.exec(substring)) {
|
|
var newEnd = match.index;
|
|
}
|
|
result2 = result2.slice(0, newEnd === undefined2 ? end : newEnd);
|
|
}
|
|
} else if (string.indexOf(baseToString(separator), end) != end) {
|
|
var index = result2.lastIndexOf(separator);
|
|
if (index > -1) {
|
|
result2 = result2.slice(0, index);
|
|
}
|
|
}
|
|
return result2 + omission;
|
|
}
|
|
function unescape2(string) {
|
|
string = toString(string);
|
|
return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
|
|
}
|
|
var upperCase = createCompounder(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + word.toUpperCase();
|
|
});
|
|
var upperFirst = createCaseFirst("toUpperCase");
|
|
function words(string, pattern, guard) {
|
|
string = toString(string);
|
|
pattern = guard ? undefined2 : pattern;
|
|
if (pattern === undefined2) {
|
|
return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
|
|
}
|
|
return string.match(pattern) || [];
|
|
}
|
|
var attempt = baseRest(function(func, args) {
|
|
try {
|
|
return apply(func, undefined2, args);
|
|
} catch (e) {
|
|
return isError(e) ? e : new Error2(e);
|
|
}
|
|
});
|
|
var bindAll = flatRest(function(object, methodNames) {
|
|
arrayEach(methodNames, function(key) {
|
|
key = toKey(key);
|
|
baseAssignValue(object, key, bind(object[key], object));
|
|
});
|
|
return object;
|
|
});
|
|
function cond(pairs) {
|
|
var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee();
|
|
pairs = !length ? [] : arrayMap(pairs, function(pair) {
|
|
if (typeof pair[1] != "function") {
|
|
throw new TypeError2(FUNC_ERROR_TEXT);
|
|
}
|
|
return [toIteratee(pair[0]), pair[1]];
|
|
});
|
|
return baseRest(function(args) {
|
|
var index = -1;
|
|
while (++index < length) {
|
|
var pair = pairs[index];
|
|
if (apply(pair[0], this, args)) {
|
|
return apply(pair[1], this, args);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function conforms(source) {
|
|
return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
|
|
}
|
|
function constant(value) {
|
|
return function() {
|
|
return value;
|
|
};
|
|
}
|
|
function defaultTo(value, defaultValue) {
|
|
return value == null || value !== value ? defaultValue : value;
|
|
}
|
|
var flow = createFlow();
|
|
var flowRight = createFlow(true);
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
function iteratee(func) {
|
|
return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG));
|
|
}
|
|
function matches(source) {
|
|
return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
|
|
}
|
|
function matchesProperty(path, srcValue) {
|
|
return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
|
|
}
|
|
var method = baseRest(function(path, args) {
|
|
return function(object) {
|
|
return baseInvoke(object, path, args);
|
|
};
|
|
});
|
|
var methodOf = baseRest(function(object, args) {
|
|
return function(path) {
|
|
return baseInvoke(object, path, args);
|
|
};
|
|
});
|
|
function mixin(object, source, options) {
|
|
var props = keys(source), methodNames = baseFunctions(source, props);
|
|
if (options == null && !(isObject(source) && (methodNames.length || !props.length))) {
|
|
options = source;
|
|
source = object;
|
|
object = this;
|
|
methodNames = baseFunctions(source, keys(source));
|
|
}
|
|
var chain2 = !(isObject(options) && ("chain" in options)) || !!options.chain, isFunc = isFunction(object);
|
|
arrayEach(methodNames, function(methodName) {
|
|
var func = source[methodName];
|
|
object[methodName] = func;
|
|
if (isFunc) {
|
|
object.prototype[methodName] = function() {
|
|
var chainAll = this.__chain__;
|
|
if (chain2 || chainAll) {
|
|
var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__);
|
|
actions.push({ func, args: arguments, thisArg: object });
|
|
result2.__chain__ = chainAll;
|
|
return result2;
|
|
}
|
|
return func.apply(object, arrayPush([this.value()], arguments));
|
|
};
|
|
}
|
|
});
|
|
return object;
|
|
}
|
|
function noConflict() {
|
|
if (root._ === this) {
|
|
root._ = oldDash;
|
|
}
|
|
return this;
|
|
}
|
|
function noop() {
|
|
}
|
|
function nthArg(n) {
|
|
n = toInteger(n);
|
|
return baseRest(function(args) {
|
|
return baseNth(args, n);
|
|
});
|
|
}
|
|
var over = createOver(arrayMap);
|
|
var overEvery = createOver(arrayEvery);
|
|
var overSome = createOver(arraySome);
|
|
function property(path) {
|
|
return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
|
|
}
|
|
function propertyOf(object) {
|
|
return function(path) {
|
|
return object == null ? undefined2 : baseGet(object, path);
|
|
};
|
|
}
|
|
var range = createRange();
|
|
var rangeRight = createRange(true);
|
|
function stubArray() {
|
|
return [];
|
|
}
|
|
function stubFalse() {
|
|
return false;
|
|
}
|
|
function stubObject() {
|
|
return {};
|
|
}
|
|
function stubString() {
|
|
return "";
|
|
}
|
|
function stubTrue() {
|
|
return true;
|
|
}
|
|
function times(n, iteratee2) {
|
|
n = toInteger(n);
|
|
if (n < 1 || n > MAX_SAFE_INTEGER) {
|
|
return [];
|
|
}
|
|
var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);
|
|
iteratee2 = getIteratee(iteratee2);
|
|
n -= MAX_ARRAY_LENGTH;
|
|
var result2 = baseTimes(length, iteratee2);
|
|
while (++index < n) {
|
|
iteratee2(index);
|
|
}
|
|
return result2;
|
|
}
|
|
function toPath(value) {
|
|
if (isArray(value)) {
|
|
return arrayMap(value, toKey);
|
|
}
|
|
return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
|
|
}
|
|
function uniqueId(prefix) {
|
|
var id = ++idCounter;
|
|
return toString(prefix) + id;
|
|
}
|
|
var add = createMathOperation(function(augend, addend) {
|
|
return augend + addend;
|
|
}, 0);
|
|
var ceil = createRound("ceil");
|
|
var divide = createMathOperation(function(dividend, divisor) {
|
|
return dividend / divisor;
|
|
}, 1);
|
|
var floor = createRound("floor");
|
|
function max(array) {
|
|
return array && array.length ? baseExtremum(array, identity, baseGt) : undefined2;
|
|
}
|
|
function maxBy(array, iteratee2) {
|
|
return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;
|
|
}
|
|
function mean(array) {
|
|
return baseMean(array, identity);
|
|
}
|
|
function meanBy(array, iteratee2) {
|
|
return baseMean(array, getIteratee(iteratee2, 2));
|
|
}
|
|
function min(array) {
|
|
return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2;
|
|
}
|
|
function minBy(array, iteratee2) {
|
|
return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2;
|
|
}
|
|
var multiply = createMathOperation(function(multiplier, multiplicand) {
|
|
return multiplier * multiplicand;
|
|
}, 1);
|
|
var round = createRound("round");
|
|
var subtract = createMathOperation(function(minuend, subtrahend) {
|
|
return minuend - subtrahend;
|
|
}, 0);
|
|
function sum(array) {
|
|
return array && array.length ? baseSum(array, identity) : 0;
|
|
}
|
|
function sumBy(array, iteratee2) {
|
|
return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
|
|
}
|
|
lodash.after = after;
|
|
lodash.ary = ary;
|
|
lodash.assign = assign;
|
|
lodash.assignIn = assignIn;
|
|
lodash.assignInWith = assignInWith;
|
|
lodash.assignWith = assignWith;
|
|
lodash.at = at;
|
|
lodash.before = before;
|
|
lodash.bind = bind;
|
|
lodash.bindAll = bindAll;
|
|
lodash.bindKey = bindKey;
|
|
lodash.castArray = castArray;
|
|
lodash.chain = chain;
|
|
lodash.chunk = chunk;
|
|
lodash.compact = compact;
|
|
lodash.concat = concat;
|
|
lodash.cond = cond;
|
|
lodash.conforms = conforms;
|
|
lodash.constant = constant;
|
|
lodash.countBy = countBy;
|
|
lodash.create = create;
|
|
lodash.curry = curry;
|
|
lodash.curryRight = curryRight;
|
|
lodash.debounce = debounce;
|
|
lodash.defaults = defaults;
|
|
lodash.defaultsDeep = defaultsDeep;
|
|
lodash.defer = defer;
|
|
lodash.delay = delay;
|
|
lodash.difference = difference;
|
|
lodash.differenceBy = differenceBy;
|
|
lodash.differenceWith = differenceWith;
|
|
lodash.drop = drop;
|
|
lodash.dropRight = dropRight;
|
|
lodash.dropRightWhile = dropRightWhile;
|
|
lodash.dropWhile = dropWhile;
|
|
lodash.fill = fill;
|
|
lodash.filter = filter;
|
|
lodash.flatMap = flatMap;
|
|
lodash.flatMapDeep = flatMapDeep;
|
|
lodash.flatMapDepth = flatMapDepth;
|
|
lodash.flatten = flatten;
|
|
lodash.flattenDeep = flattenDeep;
|
|
lodash.flattenDepth = flattenDepth;
|
|
lodash.flip = flip;
|
|
lodash.flow = flow;
|
|
lodash.flowRight = flowRight;
|
|
lodash.fromPairs = fromPairs;
|
|
lodash.functions = functions;
|
|
lodash.functionsIn = functionsIn;
|
|
lodash.groupBy = groupBy;
|
|
lodash.initial = initial;
|
|
lodash.intersection = intersection;
|
|
lodash.intersectionBy = intersectionBy;
|
|
lodash.intersectionWith = intersectionWith;
|
|
lodash.invert = invert;
|
|
lodash.invertBy = invertBy;
|
|
lodash.invokeMap = invokeMap;
|
|
lodash.iteratee = iteratee;
|
|
lodash.keyBy = keyBy;
|
|
lodash.keys = keys;
|
|
lodash.keysIn = keysIn;
|
|
lodash.map = map;
|
|
lodash.mapKeys = mapKeys;
|
|
lodash.mapValues = mapValues;
|
|
lodash.matches = matches;
|
|
lodash.matchesProperty = matchesProperty;
|
|
lodash.memoize = memoize;
|
|
lodash.merge = merge;
|
|
lodash.mergeWith = mergeWith;
|
|
lodash.method = method;
|
|
lodash.methodOf = methodOf;
|
|
lodash.mixin = mixin;
|
|
lodash.negate = negate;
|
|
lodash.nthArg = nthArg;
|
|
lodash.omit = omit;
|
|
lodash.omitBy = omitBy;
|
|
lodash.once = once;
|
|
lodash.orderBy = orderBy;
|
|
lodash.over = over;
|
|
lodash.overArgs = overArgs;
|
|
lodash.overEvery = overEvery;
|
|
lodash.overSome = overSome;
|
|
lodash.partial = partial;
|
|
lodash.partialRight = partialRight;
|
|
lodash.partition = partition;
|
|
lodash.pick = pick;
|
|
lodash.pickBy = pickBy;
|
|
lodash.property = property;
|
|
lodash.propertyOf = propertyOf;
|
|
lodash.pull = pull;
|
|
lodash.pullAll = pullAll;
|
|
lodash.pullAllBy = pullAllBy;
|
|
lodash.pullAllWith = pullAllWith;
|
|
lodash.pullAt = pullAt;
|
|
lodash.range = range;
|
|
lodash.rangeRight = rangeRight;
|
|
lodash.rearg = rearg;
|
|
lodash.reject = reject;
|
|
lodash.remove = remove;
|
|
lodash.rest = rest;
|
|
lodash.reverse = reverse;
|
|
lodash.sampleSize = sampleSize;
|
|
lodash.set = set;
|
|
lodash.setWith = setWith;
|
|
lodash.shuffle = shuffle;
|
|
lodash.slice = slice;
|
|
lodash.sortBy = sortBy;
|
|
lodash.sortedUniq = sortedUniq;
|
|
lodash.sortedUniqBy = sortedUniqBy;
|
|
lodash.split = split;
|
|
lodash.spread = spread;
|
|
lodash.tail = tail;
|
|
lodash.take = take;
|
|
lodash.takeRight = takeRight;
|
|
lodash.takeRightWhile = takeRightWhile;
|
|
lodash.takeWhile = takeWhile;
|
|
lodash.tap = tap;
|
|
lodash.throttle = throttle;
|
|
lodash.thru = thru;
|
|
lodash.toArray = toArray;
|
|
lodash.toPairs = toPairs;
|
|
lodash.toPairsIn = toPairsIn;
|
|
lodash.toPath = toPath;
|
|
lodash.toPlainObject = toPlainObject;
|
|
lodash.transform = transform;
|
|
lodash.unary = unary;
|
|
lodash.union = union;
|
|
lodash.unionBy = unionBy;
|
|
lodash.unionWith = unionWith;
|
|
lodash.uniq = uniq;
|
|
lodash.uniqBy = uniqBy;
|
|
lodash.uniqWith = uniqWith;
|
|
lodash.unset = unset;
|
|
lodash.unzip = unzip;
|
|
lodash.unzipWith = unzipWith;
|
|
lodash.update = update;
|
|
lodash.updateWith = updateWith;
|
|
lodash.values = values;
|
|
lodash.valuesIn = valuesIn;
|
|
lodash.without = without;
|
|
lodash.words = words;
|
|
lodash.wrap = wrap;
|
|
lodash.xor = xor;
|
|
lodash.xorBy = xorBy;
|
|
lodash.xorWith = xorWith;
|
|
lodash.zip = zip;
|
|
lodash.zipObject = zipObject;
|
|
lodash.zipObjectDeep = zipObjectDeep;
|
|
lodash.zipWith = zipWith;
|
|
lodash.entries = toPairs;
|
|
lodash.entriesIn = toPairsIn;
|
|
lodash.extend = assignIn;
|
|
lodash.extendWith = assignInWith;
|
|
mixin(lodash, lodash);
|
|
lodash.add = add;
|
|
lodash.attempt = attempt;
|
|
lodash.camelCase = camelCase;
|
|
lodash.capitalize = capitalize;
|
|
lodash.ceil = ceil;
|
|
lodash.clamp = clamp;
|
|
lodash.clone = clone;
|
|
lodash.cloneDeep = cloneDeep;
|
|
lodash.cloneDeepWith = cloneDeepWith;
|
|
lodash.cloneWith = cloneWith;
|
|
lodash.conformsTo = conformsTo;
|
|
lodash.deburr = deburr;
|
|
lodash.defaultTo = defaultTo;
|
|
lodash.divide = divide;
|
|
lodash.endsWith = endsWith;
|
|
lodash.eq = eq;
|
|
lodash.escape = escape;
|
|
lodash.escapeRegExp = escapeRegExp;
|
|
lodash.every = every;
|
|
lodash.find = find;
|
|
lodash.findIndex = findIndex;
|
|
lodash.findKey = findKey;
|
|
lodash.findLast = findLast;
|
|
lodash.findLastIndex = findLastIndex;
|
|
lodash.findLastKey = findLastKey;
|
|
lodash.floor = floor;
|
|
lodash.forEach = forEach;
|
|
lodash.forEachRight = forEachRight;
|
|
lodash.forIn = forIn;
|
|
lodash.forInRight = forInRight;
|
|
lodash.forOwn = forOwn;
|
|
lodash.forOwnRight = forOwnRight;
|
|
lodash.get = get;
|
|
lodash.gt = gt;
|
|
lodash.gte = gte;
|
|
lodash.has = has;
|
|
lodash.hasIn = hasIn;
|
|
lodash.head = head;
|
|
lodash.identity = identity;
|
|
lodash.includes = includes;
|
|
lodash.indexOf = indexOf;
|
|
lodash.inRange = inRange;
|
|
lodash.invoke = invoke;
|
|
lodash.isArguments = isArguments;
|
|
lodash.isArray = isArray;
|
|
lodash.isArrayBuffer = isArrayBuffer;
|
|
lodash.isArrayLike = isArrayLike;
|
|
lodash.isArrayLikeObject = isArrayLikeObject;
|
|
lodash.isBoolean = isBoolean;
|
|
lodash.isBuffer = isBuffer;
|
|
lodash.isDate = isDate;
|
|
lodash.isElement = isElement;
|
|
lodash.isEmpty = isEmpty;
|
|
lodash.isEqual = isEqual;
|
|
lodash.isEqualWith = isEqualWith;
|
|
lodash.isError = isError;
|
|
lodash.isFinite = isFinite2;
|
|
lodash.isFunction = isFunction;
|
|
lodash.isInteger = isInteger;
|
|
lodash.isLength = isLength;
|
|
lodash.isMap = isMap;
|
|
lodash.isMatch = isMatch;
|
|
lodash.isMatchWith = isMatchWith;
|
|
lodash.isNaN = isNaN2;
|
|
lodash.isNative = isNative;
|
|
lodash.isNil = isNil;
|
|
lodash.isNull = isNull;
|
|
lodash.isNumber = isNumber;
|
|
lodash.isObject = isObject;
|
|
lodash.isObjectLike = isObjectLike;
|
|
lodash.isPlainObject = isPlainObject;
|
|
lodash.isRegExp = isRegExp;
|
|
lodash.isSafeInteger = isSafeInteger;
|
|
lodash.isSet = isSet;
|
|
lodash.isString = isString;
|
|
lodash.isSymbol = isSymbol;
|
|
lodash.isTypedArray = isTypedArray;
|
|
lodash.isUndefined = isUndefined;
|
|
lodash.isWeakMap = isWeakMap;
|
|
lodash.isWeakSet = isWeakSet;
|
|
lodash.join = join;
|
|
lodash.kebabCase = kebabCase;
|
|
lodash.last = last;
|
|
lodash.lastIndexOf = lastIndexOf;
|
|
lodash.lowerCase = lowerCase;
|
|
lodash.lowerFirst = lowerFirst;
|
|
lodash.lt = lt;
|
|
lodash.lte = lte;
|
|
lodash.max = max;
|
|
lodash.maxBy = maxBy;
|
|
lodash.mean = mean;
|
|
lodash.meanBy = meanBy;
|
|
lodash.min = min;
|
|
lodash.minBy = minBy;
|
|
lodash.stubArray = stubArray;
|
|
lodash.stubFalse = stubFalse;
|
|
lodash.stubObject = stubObject;
|
|
lodash.stubString = stubString;
|
|
lodash.stubTrue = stubTrue;
|
|
lodash.multiply = multiply;
|
|
lodash.nth = nth;
|
|
lodash.noConflict = noConflict;
|
|
lodash.noop = noop;
|
|
lodash.now = now;
|
|
lodash.pad = pad;
|
|
lodash.padEnd = padEnd;
|
|
lodash.padStart = padStart;
|
|
lodash.parseInt = parseInt2;
|
|
lodash.random = random;
|
|
lodash.reduce = reduce;
|
|
lodash.reduceRight = reduceRight;
|
|
lodash.repeat = repeat;
|
|
lodash.replace = replace;
|
|
lodash.result = result;
|
|
lodash.round = round;
|
|
lodash.runInContext = runInContext;
|
|
lodash.sample = sample;
|
|
lodash.size = size;
|
|
lodash.snakeCase = snakeCase;
|
|
lodash.some = some;
|
|
lodash.sortedIndex = sortedIndex;
|
|
lodash.sortedIndexBy = sortedIndexBy;
|
|
lodash.sortedIndexOf = sortedIndexOf;
|
|
lodash.sortedLastIndex = sortedLastIndex;
|
|
lodash.sortedLastIndexBy = sortedLastIndexBy;
|
|
lodash.sortedLastIndexOf = sortedLastIndexOf;
|
|
lodash.startCase = startCase;
|
|
lodash.startsWith = startsWith;
|
|
lodash.subtract = subtract;
|
|
lodash.sum = sum;
|
|
lodash.sumBy = sumBy;
|
|
lodash.template = template;
|
|
lodash.times = times;
|
|
lodash.toFinite = toFinite;
|
|
lodash.toInteger = toInteger;
|
|
lodash.toLength = toLength;
|
|
lodash.toLower = toLower;
|
|
lodash.toNumber = toNumber;
|
|
lodash.toSafeInteger = toSafeInteger;
|
|
lodash.toString = toString;
|
|
lodash.toUpper = toUpper;
|
|
lodash.trim = trim;
|
|
lodash.trimEnd = trimEnd;
|
|
lodash.trimStart = trimStart;
|
|
lodash.truncate = truncate;
|
|
lodash.unescape = unescape2;
|
|
lodash.uniqueId = uniqueId;
|
|
lodash.upperCase = upperCase;
|
|
lodash.upperFirst = upperFirst;
|
|
lodash.each = forEach;
|
|
lodash.eachRight = forEachRight;
|
|
lodash.first = head;
|
|
mixin(lodash, function() {
|
|
var source = {};
|
|
baseForOwn(lodash, function(func, methodName) {
|
|
if (!hasOwnProperty.call(lodash.prototype, methodName)) {
|
|
source[methodName] = func;
|
|
}
|
|
});
|
|
return source;
|
|
}(), { chain: false });
|
|
lodash.VERSION = VERSION;
|
|
arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
|
|
lodash[methodName].placeholder = lodash;
|
|
});
|
|
arrayEach(["drop", "take"], function(methodName, index) {
|
|
LazyWrapper.prototype[methodName] = function(n) {
|
|
n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0);
|
|
var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
|
|
if (result2.__filtered__) {
|
|
result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
|
|
} else {
|
|
result2.__views__.push({
|
|
size: nativeMin(n, MAX_ARRAY_LENGTH),
|
|
type: methodName + (result2.__dir__ < 0 ? "Right" : "")
|
|
});
|
|
}
|
|
return result2;
|
|
};
|
|
LazyWrapper.prototype[methodName + "Right"] = function(n) {
|
|
return this.reverse()[methodName](n).reverse();
|
|
};
|
|
});
|
|
arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
|
|
var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
|
|
LazyWrapper.prototype[methodName] = function(iteratee2) {
|
|
var result2 = this.clone();
|
|
result2.__iteratees__.push({
|
|
iteratee: getIteratee(iteratee2, 3),
|
|
type
|
|
});
|
|
result2.__filtered__ = result2.__filtered__ || isFilter;
|
|
return result2;
|
|
};
|
|
});
|
|
arrayEach(["head", "last"], function(methodName, index) {
|
|
var takeName = "take" + (index ? "Right" : "");
|
|
LazyWrapper.prototype[methodName] = function() {
|
|
return this[takeName](1).value()[0];
|
|
};
|
|
});
|
|
arrayEach(["initial", "tail"], function(methodName, index) {
|
|
var dropName = "drop" + (index ? "" : "Right");
|
|
LazyWrapper.prototype[methodName] = function() {
|
|
return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
|
|
};
|
|
});
|
|
LazyWrapper.prototype.compact = function() {
|
|
return this.filter(identity);
|
|
};
|
|
LazyWrapper.prototype.find = function(predicate) {
|
|
return this.filter(predicate).head();
|
|
};
|
|
LazyWrapper.prototype.findLast = function(predicate) {
|
|
return this.reverse().find(predicate);
|
|
};
|
|
LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
|
|
if (typeof path == "function") {
|
|
return new LazyWrapper(this);
|
|
}
|
|
return this.map(function(value) {
|
|
return baseInvoke(value, path, args);
|
|
});
|
|
});
|
|
LazyWrapper.prototype.reject = function(predicate) {
|
|
return this.filter(negate(getIteratee(predicate)));
|
|
};
|
|
LazyWrapper.prototype.slice = function(start, end) {
|
|
start = toInteger(start);
|
|
var result2 = this;
|
|
if (result2.__filtered__ && (start > 0 || end < 0)) {
|
|
return new LazyWrapper(result2);
|
|
}
|
|
if (start < 0) {
|
|
result2 = result2.takeRight(-start);
|
|
} else if (start) {
|
|
result2 = result2.drop(start);
|
|
}
|
|
if (end !== undefined2) {
|
|
end = toInteger(end);
|
|
result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
|
|
}
|
|
return result2;
|
|
};
|
|
LazyWrapper.prototype.takeRightWhile = function(predicate) {
|
|
return this.reverse().takeWhile(predicate).reverse();
|
|
};
|
|
LazyWrapper.prototype.toArray = function() {
|
|
return this.take(MAX_ARRAY_LENGTH);
|
|
};
|
|
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
|
|
var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
|
|
if (!lodashFunc) {
|
|
return;
|
|
}
|
|
lodash.prototype[methodName] = function() {
|
|
var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value);
|
|
var interceptor = function(value2) {
|
|
var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));
|
|
return isTaker && chainAll ? result3[0] : result3;
|
|
};
|
|
if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
|
|
isLazy = useLazy = false;
|
|
}
|
|
var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
|
|
if (!retUnwrapped && useLazy) {
|
|
value = onlyLazy ? value : new LazyWrapper(this);
|
|
var result2 = func.apply(value, args);
|
|
result2.__actions__.push({ func: thru, args: [interceptor], thisArg: undefined2 });
|
|
return new LodashWrapper(result2, chainAll);
|
|
}
|
|
if (isUnwrapped && onlyLazy) {
|
|
return func.apply(this, args);
|
|
}
|
|
result2 = this.thru(interceptor);
|
|
return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
|
|
};
|
|
});
|
|
arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
|
|
var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
|
|
lodash.prototype[methodName] = function() {
|
|
var args = arguments;
|
|
if (retUnwrapped && !this.__chain__) {
|
|
var value = this.value();
|
|
return func.apply(isArray(value) ? value : [], args);
|
|
}
|
|
return this[chainName](function(value2) {
|
|
return func.apply(isArray(value2) ? value2 : [], args);
|
|
});
|
|
};
|
|
});
|
|
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
|
|
var lodashFunc = lodash[methodName];
|
|
if (lodashFunc) {
|
|
var key = lodashFunc.name + "";
|
|
if (!hasOwnProperty.call(realNames, key)) {
|
|
realNames[key] = [];
|
|
}
|
|
realNames[key].push({ name: methodName, func: lodashFunc });
|
|
}
|
|
});
|
|
realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{
|
|
name: "wrapper",
|
|
func: undefined2
|
|
}];
|
|
LazyWrapper.prototype.clone = lazyClone;
|
|
LazyWrapper.prototype.reverse = lazyReverse;
|
|
LazyWrapper.prototype.value = lazyValue;
|
|
lodash.prototype.at = wrapperAt;
|
|
lodash.prototype.chain = wrapperChain;
|
|
lodash.prototype.commit = wrapperCommit;
|
|
lodash.prototype.next = wrapperNext;
|
|
lodash.prototype.plant = wrapperPlant;
|
|
lodash.prototype.reverse = wrapperReverse;
|
|
lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
|
|
lodash.prototype.first = lodash.prototype.head;
|
|
if (symIterator) {
|
|
lodash.prototype[symIterator] = wrapperToIterator;
|
|
}
|
|
return lodash;
|
|
};
|
|
var _ = runInContext();
|
|
if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
|
|
root._ = _;
|
|
define(function() {
|
|
return _;
|
|
});
|
|
} else if (freeModule) {
|
|
(freeModule.exports = _)._ = _;
|
|
freeExports._ = _;
|
|
} else {
|
|
root._ = _;
|
|
}
|
|
}).call(exports);
|
|
});
|
|
|
|
// package-shared/functions/backend/serverError.ts
|
|
import fs from "fs";
|
|
async function serverError({
|
|
user,
|
|
message,
|
|
component,
|
|
noMail,
|
|
req
|
|
}) {
|
|
const date = new Date;
|
|
const reqIp = (() => {
|
|
if (!req)
|
|
return null;
|
|
try {
|
|
const forwarded = req.headers["x-forwarded-for"];
|
|
const realIp = req.headers["x-real-ip"];
|
|
const cloudflareIp = req.headers["cf-connecting-ip"];
|
|
const forwardedIp = Array.isArray(forwarded) ? forwarded[0] : forwarded?.split(",")[0];
|
|
const clientIp = cloudflareIp || forwardedIp || realIp || req.socket.remoteAddress;
|
|
if (!clientIp)
|
|
return null;
|
|
return String(clientIp);
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
})();
|
|
try {
|
|
let log = `\uD83D\uDE80 SERVER ERROR ===========================
|
|
Error Message: ${message}\nComponent: ${component}`;
|
|
if (user?.id && user?.first_name && user?.last_name && user?.email) {
|
|
log += `\nUser Id: ${user?.id}\nUser Name: ${user?.first_name} ${user?.last_name}\nUser Email: ${user?.email}`;
|
|
}
|
|
if (req?.url) {
|
|
log += `\nURL: ${req.url}`;
|
|
}
|
|
if (req?.body) {
|
|
log += `\nRequest Body: ${JSON.stringify(req.body, null, 4)}`;
|
|
}
|
|
if (reqIp) {
|
|
log += `\nIP: ${reqIp}`;
|
|
}
|
|
log += `\nDate: ${date.toDateString()}`;
|
|
log += "\n========================================";
|
|
if (!fs.existsSync(`./.tmp/error.log`)) {
|
|
fs.writeFileSync(`./.tmp/error.log`, "", "utf-8");
|
|
}
|
|
const initialText = fs.readFileSync(`./.tmp/error.log`, "utf-8");
|
|
fs.writeFileSync(`./.tmp/error.log`, log);
|
|
fs.appendFileSync(`./.tmp/error.log`, `\n\n\n\n\n${initialText}`);
|
|
} catch (error) {
|
|
console.log("Server Error Reporting Error:", error.message);
|
|
}
|
|
}
|
|
var init_serverError = () => {
|
|
};
|
|
|
|
// node_modules/mysql/lib/protocol/constants/client.js
|
|
var require_client = __commonJS((exports) => {
|
|
exports.CLIENT_LONG_PASSWORD = 1;
|
|
exports.CLIENT_FOUND_ROWS = 2;
|
|
exports.CLIENT_LONG_FLAG = 4;
|
|
exports.CLIENT_CONNECT_WITH_DB = 8;
|
|
exports.CLIENT_NO_SCHEMA = 16;
|
|
exports.CLIENT_COMPRESS = 32;
|
|
exports.CLIENT_ODBC = 64;
|
|
exports.CLIENT_LOCAL_FILES = 128;
|
|
exports.CLIENT_IGNORE_SPACE = 256;
|
|
exports.CLIENT_PROTOCOL_41 = 512;
|
|
exports.CLIENT_INTERACTIVE = 1024;
|
|
exports.CLIENT_SSL = 2048;
|
|
exports.CLIENT_IGNORE_SIGPIPE = 4096;
|
|
exports.CLIENT_TRANSACTIONS = 8192;
|
|
exports.CLIENT_RESERVED = 16384;
|
|
exports.CLIENT_SECURE_CONNECTION = 32768;
|
|
exports.CLIENT_MULTI_STATEMENTS = 65536;
|
|
exports.CLIENT_MULTI_RESULTS = 131072;
|
|
exports.CLIENT_PS_MULTI_RESULTS = 262144;
|
|
exports.CLIENT_PLUGIN_AUTH = 524288;
|
|
exports.CLIENT_SSL_VERIFY_SERVER_CERT = 1073741824;
|
|
exports.CLIENT_REMEMBER_OPTIONS = 2147483648;
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/constants/charsets.js
|
|
var require_charsets = __commonJS((exports) => {
|
|
exports.BIG5_CHINESE_CI = 1;
|
|
exports.LATIN2_CZECH_CS = 2;
|
|
exports.DEC8_SWEDISH_CI = 3;
|
|
exports.CP850_GENERAL_CI = 4;
|
|
exports.LATIN1_GERMAN1_CI = 5;
|
|
exports.HP8_ENGLISH_CI = 6;
|
|
exports.KOI8R_GENERAL_CI = 7;
|
|
exports.LATIN1_SWEDISH_CI = 8;
|
|
exports.LATIN2_GENERAL_CI = 9;
|
|
exports.SWE7_SWEDISH_CI = 10;
|
|
exports.ASCII_GENERAL_CI = 11;
|
|
exports.UJIS_JAPANESE_CI = 12;
|
|
exports.SJIS_JAPANESE_CI = 13;
|
|
exports.CP1251_BULGARIAN_CI = 14;
|
|
exports.LATIN1_DANISH_CI = 15;
|
|
exports.HEBREW_GENERAL_CI = 16;
|
|
exports.TIS620_THAI_CI = 18;
|
|
exports.EUCKR_KOREAN_CI = 19;
|
|
exports.LATIN7_ESTONIAN_CS = 20;
|
|
exports.LATIN2_HUNGARIAN_CI = 21;
|
|
exports.KOI8U_GENERAL_CI = 22;
|
|
exports.CP1251_UKRAINIAN_CI = 23;
|
|
exports.GB2312_CHINESE_CI = 24;
|
|
exports.GREEK_GENERAL_CI = 25;
|
|
exports.CP1250_GENERAL_CI = 26;
|
|
exports.LATIN2_CROATIAN_CI = 27;
|
|
exports.GBK_CHINESE_CI = 28;
|
|
exports.CP1257_LITHUANIAN_CI = 29;
|
|
exports.LATIN5_TURKISH_CI = 30;
|
|
exports.LATIN1_GERMAN2_CI = 31;
|
|
exports.ARMSCII8_GENERAL_CI = 32;
|
|
exports.UTF8_GENERAL_CI = 33;
|
|
exports.CP1250_CZECH_CS = 34;
|
|
exports.UCS2_GENERAL_CI = 35;
|
|
exports.CP866_GENERAL_CI = 36;
|
|
exports.KEYBCS2_GENERAL_CI = 37;
|
|
exports.MACCE_GENERAL_CI = 38;
|
|
exports.MACROMAN_GENERAL_CI = 39;
|
|
exports.CP852_GENERAL_CI = 40;
|
|
exports.LATIN7_GENERAL_CI = 41;
|
|
exports.LATIN7_GENERAL_CS = 42;
|
|
exports.MACCE_BIN = 43;
|
|
exports.CP1250_CROATIAN_CI = 44;
|
|
exports.UTF8MB4_GENERAL_CI = 45;
|
|
exports.UTF8MB4_BIN = 46;
|
|
exports.LATIN1_BIN = 47;
|
|
exports.LATIN1_GENERAL_CI = 48;
|
|
exports.LATIN1_GENERAL_CS = 49;
|
|
exports.CP1251_BIN = 50;
|
|
exports.CP1251_GENERAL_CI = 51;
|
|
exports.CP1251_GENERAL_CS = 52;
|
|
exports.MACROMAN_BIN = 53;
|
|
exports.UTF16_GENERAL_CI = 54;
|
|
exports.UTF16_BIN = 55;
|
|
exports.UTF16LE_GENERAL_CI = 56;
|
|
exports.CP1256_GENERAL_CI = 57;
|
|
exports.CP1257_BIN = 58;
|
|
exports.CP1257_GENERAL_CI = 59;
|
|
exports.UTF32_GENERAL_CI = 60;
|
|
exports.UTF32_BIN = 61;
|
|
exports.UTF16LE_BIN = 62;
|
|
exports.BINARY = 63;
|
|
exports.ARMSCII8_BIN = 64;
|
|
exports.ASCII_BIN = 65;
|
|
exports.CP1250_BIN = 66;
|
|
exports.CP1256_BIN = 67;
|
|
exports.CP866_BIN = 68;
|
|
exports.DEC8_BIN = 69;
|
|
exports.GREEK_BIN = 70;
|
|
exports.HEBREW_BIN = 71;
|
|
exports.HP8_BIN = 72;
|
|
exports.KEYBCS2_BIN = 73;
|
|
exports.KOI8R_BIN = 74;
|
|
exports.KOI8U_BIN = 75;
|
|
exports.LATIN2_BIN = 77;
|
|
exports.LATIN5_BIN = 78;
|
|
exports.LATIN7_BIN = 79;
|
|
exports.CP850_BIN = 80;
|
|
exports.CP852_BIN = 81;
|
|
exports.SWE7_BIN = 82;
|
|
exports.UTF8_BIN = 83;
|
|
exports.BIG5_BIN = 84;
|
|
exports.EUCKR_BIN = 85;
|
|
exports.GB2312_BIN = 86;
|
|
exports.GBK_BIN = 87;
|
|
exports.SJIS_BIN = 88;
|
|
exports.TIS620_BIN = 89;
|
|
exports.UCS2_BIN = 90;
|
|
exports.UJIS_BIN = 91;
|
|
exports.GEOSTD8_GENERAL_CI = 92;
|
|
exports.GEOSTD8_BIN = 93;
|
|
exports.LATIN1_SPANISH_CI = 94;
|
|
exports.CP932_JAPANESE_CI = 95;
|
|
exports.CP932_BIN = 96;
|
|
exports.EUCJPMS_JAPANESE_CI = 97;
|
|
exports.EUCJPMS_BIN = 98;
|
|
exports.CP1250_POLISH_CI = 99;
|
|
exports.UTF16_UNICODE_CI = 101;
|
|
exports.UTF16_ICELANDIC_CI = 102;
|
|
exports.UTF16_LATVIAN_CI = 103;
|
|
exports.UTF16_ROMANIAN_CI = 104;
|
|
exports.UTF16_SLOVENIAN_CI = 105;
|
|
exports.UTF16_POLISH_CI = 106;
|
|
exports.UTF16_ESTONIAN_CI = 107;
|
|
exports.UTF16_SPANISH_CI = 108;
|
|
exports.UTF16_SWEDISH_CI = 109;
|
|
exports.UTF16_TURKISH_CI = 110;
|
|
exports.UTF16_CZECH_CI = 111;
|
|
exports.UTF16_DANISH_CI = 112;
|
|
exports.UTF16_LITHUANIAN_CI = 113;
|
|
exports.UTF16_SLOVAK_CI = 114;
|
|
exports.UTF16_SPANISH2_CI = 115;
|
|
exports.UTF16_ROMAN_CI = 116;
|
|
exports.UTF16_PERSIAN_CI = 117;
|
|
exports.UTF16_ESPERANTO_CI = 118;
|
|
exports.UTF16_HUNGARIAN_CI = 119;
|
|
exports.UTF16_SINHALA_CI = 120;
|
|
exports.UTF16_GERMAN2_CI = 121;
|
|
exports.UTF16_CROATIAN_MYSQL561_CI = 122;
|
|
exports.UTF16_UNICODE_520_CI = 123;
|
|
exports.UTF16_VIETNAMESE_CI = 124;
|
|
exports.UCS2_UNICODE_CI = 128;
|
|
exports.UCS2_ICELANDIC_CI = 129;
|
|
exports.UCS2_LATVIAN_CI = 130;
|
|
exports.UCS2_ROMANIAN_CI = 131;
|
|
exports.UCS2_SLOVENIAN_CI = 132;
|
|
exports.UCS2_POLISH_CI = 133;
|
|
exports.UCS2_ESTONIAN_CI = 134;
|
|
exports.UCS2_SPANISH_CI = 135;
|
|
exports.UCS2_SWEDISH_CI = 136;
|
|
exports.UCS2_TURKISH_CI = 137;
|
|
exports.UCS2_CZECH_CI = 138;
|
|
exports.UCS2_DANISH_CI = 139;
|
|
exports.UCS2_LITHUANIAN_CI = 140;
|
|
exports.UCS2_SLOVAK_CI = 141;
|
|
exports.UCS2_SPANISH2_CI = 142;
|
|
exports.UCS2_ROMAN_CI = 143;
|
|
exports.UCS2_PERSIAN_CI = 144;
|
|
exports.UCS2_ESPERANTO_CI = 145;
|
|
exports.UCS2_HUNGARIAN_CI = 146;
|
|
exports.UCS2_SINHALA_CI = 147;
|
|
exports.UCS2_GERMAN2_CI = 148;
|
|
exports.UCS2_CROATIAN_MYSQL561_CI = 149;
|
|
exports.UCS2_UNICODE_520_CI = 150;
|
|
exports.UCS2_VIETNAMESE_CI = 151;
|
|
exports.UCS2_GENERAL_MYSQL500_CI = 159;
|
|
exports.UTF32_UNICODE_CI = 160;
|
|
exports.UTF32_ICELANDIC_CI = 161;
|
|
exports.UTF32_LATVIAN_CI = 162;
|
|
exports.UTF32_ROMANIAN_CI = 163;
|
|
exports.UTF32_SLOVENIAN_CI = 164;
|
|
exports.UTF32_POLISH_CI = 165;
|
|
exports.UTF32_ESTONIAN_CI = 166;
|
|
exports.UTF32_SPANISH_CI = 167;
|
|
exports.UTF32_SWEDISH_CI = 168;
|
|
exports.UTF32_TURKISH_CI = 169;
|
|
exports.UTF32_CZECH_CI = 170;
|
|
exports.UTF32_DANISH_CI = 171;
|
|
exports.UTF32_LITHUANIAN_CI = 172;
|
|
exports.UTF32_SLOVAK_CI = 173;
|
|
exports.UTF32_SPANISH2_CI = 174;
|
|
exports.UTF32_ROMAN_CI = 175;
|
|
exports.UTF32_PERSIAN_CI = 176;
|
|
exports.UTF32_ESPERANTO_CI = 177;
|
|
exports.UTF32_HUNGARIAN_CI = 178;
|
|
exports.UTF32_SINHALA_CI = 179;
|
|
exports.UTF32_GERMAN2_CI = 180;
|
|
exports.UTF32_CROATIAN_MYSQL561_CI = 181;
|
|
exports.UTF32_UNICODE_520_CI = 182;
|
|
exports.UTF32_VIETNAMESE_CI = 183;
|
|
exports.UTF8_UNICODE_CI = 192;
|
|
exports.UTF8_ICELANDIC_CI = 193;
|
|
exports.UTF8_LATVIAN_CI = 194;
|
|
exports.UTF8_ROMANIAN_CI = 195;
|
|
exports.UTF8_SLOVENIAN_CI = 196;
|
|
exports.UTF8_POLISH_CI = 197;
|
|
exports.UTF8_ESTONIAN_CI = 198;
|
|
exports.UTF8_SPANISH_CI = 199;
|
|
exports.UTF8_SWEDISH_CI = 200;
|
|
exports.UTF8_TURKISH_CI = 201;
|
|
exports.UTF8_CZECH_CI = 202;
|
|
exports.UTF8_DANISH_CI = 203;
|
|
exports.UTF8_LITHUANIAN_CI = 204;
|
|
exports.UTF8_SLOVAK_CI = 205;
|
|
exports.UTF8_SPANISH2_CI = 206;
|
|
exports.UTF8_ROMAN_CI = 207;
|
|
exports.UTF8_PERSIAN_CI = 208;
|
|
exports.UTF8_ESPERANTO_CI = 209;
|
|
exports.UTF8_HUNGARIAN_CI = 210;
|
|
exports.UTF8_SINHALA_CI = 211;
|
|
exports.UTF8_GERMAN2_CI = 212;
|
|
exports.UTF8_CROATIAN_MYSQL561_CI = 213;
|
|
exports.UTF8_UNICODE_520_CI = 214;
|
|
exports.UTF8_VIETNAMESE_CI = 215;
|
|
exports.UTF8_GENERAL_MYSQL500_CI = 223;
|
|
exports.UTF8MB4_UNICODE_CI = 224;
|
|
exports.UTF8MB4_ICELANDIC_CI = 225;
|
|
exports.UTF8MB4_LATVIAN_CI = 226;
|
|
exports.UTF8MB4_ROMANIAN_CI = 227;
|
|
exports.UTF8MB4_SLOVENIAN_CI = 228;
|
|
exports.UTF8MB4_POLISH_CI = 229;
|
|
exports.UTF8MB4_ESTONIAN_CI = 230;
|
|
exports.UTF8MB4_SPANISH_CI = 231;
|
|
exports.UTF8MB4_SWEDISH_CI = 232;
|
|
exports.UTF8MB4_TURKISH_CI = 233;
|
|
exports.UTF8MB4_CZECH_CI = 234;
|
|
exports.UTF8MB4_DANISH_CI = 235;
|
|
exports.UTF8MB4_LITHUANIAN_CI = 236;
|
|
exports.UTF8MB4_SLOVAK_CI = 237;
|
|
exports.UTF8MB4_SPANISH2_CI = 238;
|
|
exports.UTF8MB4_ROMAN_CI = 239;
|
|
exports.UTF8MB4_PERSIAN_CI = 240;
|
|
exports.UTF8MB4_ESPERANTO_CI = 241;
|
|
exports.UTF8MB4_HUNGARIAN_CI = 242;
|
|
exports.UTF8MB4_SINHALA_CI = 243;
|
|
exports.UTF8MB4_GERMAN2_CI = 244;
|
|
exports.UTF8MB4_CROATIAN_MYSQL561_CI = 245;
|
|
exports.UTF8MB4_UNICODE_520_CI = 246;
|
|
exports.UTF8MB4_VIETNAMESE_CI = 247;
|
|
exports.UTF8_GENERAL50_CI = 253;
|
|
exports.ARMSCII8 = exports.ARMSCII8_GENERAL_CI;
|
|
exports.ASCII = exports.ASCII_GENERAL_CI;
|
|
exports.BIG5 = exports.BIG5_CHINESE_CI;
|
|
exports.BINARY = exports.BINARY;
|
|
exports.CP1250 = exports.CP1250_GENERAL_CI;
|
|
exports.CP1251 = exports.CP1251_GENERAL_CI;
|
|
exports.CP1256 = exports.CP1256_GENERAL_CI;
|
|
exports.CP1257 = exports.CP1257_GENERAL_CI;
|
|
exports.CP866 = exports.CP866_GENERAL_CI;
|
|
exports.CP850 = exports.CP850_GENERAL_CI;
|
|
exports.CP852 = exports.CP852_GENERAL_CI;
|
|
exports.CP932 = exports.CP932_JAPANESE_CI;
|
|
exports.DEC8 = exports.DEC8_SWEDISH_CI;
|
|
exports.EUCJPMS = exports.EUCJPMS_JAPANESE_CI;
|
|
exports.EUCKR = exports.EUCKR_KOREAN_CI;
|
|
exports.GB2312 = exports.GB2312_CHINESE_CI;
|
|
exports.GBK = exports.GBK_CHINESE_CI;
|
|
exports.GEOSTD8 = exports.GEOSTD8_GENERAL_CI;
|
|
exports.GREEK = exports.GREEK_GENERAL_CI;
|
|
exports.HEBREW = exports.HEBREW_GENERAL_CI;
|
|
exports.HP8 = exports.HP8_ENGLISH_CI;
|
|
exports.KEYBCS2 = exports.KEYBCS2_GENERAL_CI;
|
|
exports.KOI8R = exports.KOI8R_GENERAL_CI;
|
|
exports.KOI8U = exports.KOI8U_GENERAL_CI;
|
|
exports.LATIN1 = exports.LATIN1_SWEDISH_CI;
|
|
exports.LATIN2 = exports.LATIN2_GENERAL_CI;
|
|
exports.LATIN5 = exports.LATIN5_TURKISH_CI;
|
|
exports.LATIN7 = exports.LATIN7_GENERAL_CI;
|
|
exports.MACCE = exports.MACCE_GENERAL_CI;
|
|
exports.MACROMAN = exports.MACROMAN_GENERAL_CI;
|
|
exports.SJIS = exports.SJIS_JAPANESE_CI;
|
|
exports.SWE7 = exports.SWE7_SWEDISH_CI;
|
|
exports.TIS620 = exports.TIS620_THAI_CI;
|
|
exports.UCS2 = exports.UCS2_GENERAL_CI;
|
|
exports.UJIS = exports.UJIS_JAPANESE_CI;
|
|
exports.UTF16 = exports.UTF16_GENERAL_CI;
|
|
exports.UTF16LE = exports.UTF16LE_GENERAL_CI;
|
|
exports.UTF8 = exports.UTF8_GENERAL_CI;
|
|
exports.UTF8MB4 = exports.UTF8MB4_GENERAL_CI;
|
|
exports.UTF32 = exports.UTF32_GENERAL_CI;
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/constants/ssl_profiles.js
|
|
var require_ssl_profiles = __commonJS((exports) => {
|
|
exports["Amazon RDS"] = {
|
|
ca: [
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIDQzCCAqygAwIBAgIJAOd1tlfiGoEoMA0GCSqGSIb3DQEBBQUAMHUxCzAJBgNV\n" + "BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMRMw\n" + "EQYDVQQKEwpBbWF6b24uY29tMQwwCgYDVQQLEwNSRFMxHDAaBgNVBAMTE2F3cy5h\n" + "bWF6b24uY29tL3Jkcy8wHhcNMTAwNDA1MjI0NDMxWhcNMTUwNDA0MjI0NDMxWjB1\n" + "MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHU2Vh\n" + "dHRsZTETMBEGA1UEChMKQW1hem9uLmNvbTEMMAoGA1UECxMDUkRTMRwwGgYDVQQD\n" + "ExNhd3MuYW1hem9uLmNvbS9yZHMvMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n" + "gQDKhXGU7tizxUR5WaFoMTFcxNxa05PEjZaIOEN5ctkWrqYSRov0/nOMoZjqk8bC\n" + "med9vPFoQGD0OTakPs0jVe3wwmR735hyVwmKIPPsGlaBYj1O6llIpZeQVyupNx56\n" + "UzqtiLaDzh1KcmfqP3qP2dInzBfJQKjiRudo1FWnpPt33QIDAQABo4HaMIHXMB0G\n" + "A1UdDgQWBBT/H3x+cqSkR/ePSIinPtc4yWKe3DCBpwYDVR0jBIGfMIGcgBT/H3x+\n" + "cqSkR/ePSIinPtc4yWKe3KF5pHcwdTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldh\n" + "c2hpbmd0b24xEDAOBgNVBAcTB1NlYXR0bGUxEzARBgNVBAoTCkFtYXpvbi5jb20x\n" + "DDAKBgNVBAsTA1JEUzEcMBoGA1UEAxMTYXdzLmFtYXpvbi5jb20vcmRzL4IJAOd1\n" + "tlfiGoEoMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAvguZy/BDT66x\n" + "GfgnJlyQwnFSeVLQm9u/FIvz4huGjbq9dqnD6h/Gm56QPFdyMEyDiZWaqY6V08lY\n" + "LTBNb4kcIc9/6pc0/ojKciP5QJRm6OiZ4vgG05nF4fYjhU7WClUx7cxq1fKjNc2J\n" + "UCmmYqgiVkAGWRETVo+byOSDZ4swb10=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID9DCCAtygAwIBAgIBQjANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUwOTExMzFaFw0y\n" + "MDAzMDUwOTExMzFaMIGKMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEbMBkGA1UEAwwSQW1hem9uIFJE\n" + "UyBSb290IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuD8nrZ8V\n" + "u+VA8yVlUipCZIKPTDcOILYpUe8Tct0YeQQr0uyl018StdBsa3CjBgvwpDRq1HgF\n" + "Ji2N3+39+shCNspQeE6aYU+BHXhKhIIStt3r7gl/4NqYiDDMWKHxHq0nsGDFfArf\n" + "AOcjZdJagOMqb3fF46flc8k2E7THTm9Sz4L7RY1WdABMuurpICLFE3oHcGdapOb9\n" + "T53pQR+xpHW9atkcf3pf7gbO0rlKVSIoUenBlZipUlp1VZl/OD/E+TtRhDDNdI2J\n" + "P/DSMM3aEsq6ZQkfbz/Ilml+Lx3tJYXUDmp+ZjzMPLk/+3beT8EhrwtcG3VPpvwp\n" + "BIOqsqVVTvw/CwIDAQABo2MwYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUw\n" + "AwEB/zAdBgNVHQ4EFgQUTgLurD72FchM7Sz1BcGPnIQISYMwHwYDVR0jBBgwFoAU\n" + "TgLurD72FchM7Sz1BcGPnIQISYMwDQYJKoZIhvcNAQEFBQADggEBAHZcgIio8pAm\n" + "MjHD5cl6wKjXxScXKtXygWH2BoDMYBJF9yfyKO2jEFxYKbHePpnXB1R04zJSWAw5\n" + "2EUuDI1pSBh9BA82/5PkuNlNeSTB3dXDD2PEPdzVWbSKvUB8ZdooV+2vngL0Zm4r\n" + "47QPyd18yPHrRIbtBtHR/6CwKevLZ394zgExqhnekYKIqqEX41xsUV0Gm6x4vpjf\n" + "2u6O/+YE2U+qyyxHE5Wd5oqde0oo9UUpFETJPVb6Q2cEeQib8PBAyi0i6KnF+kIV\n" + "A9dY7IHSubtCK/i8wxMVqfd5GtbA8mmpeJFwnDvm9rBEsHybl08qlax9syEwsUYr\n" + "/40NawZfTUU=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBjCCAu6gAwIBAgIJAMc0ZzaSUK51MA0GCSqGSIb3DQEBCwUAMIGPMQswCQYD\n" + "VQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\n" + "MCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\n" + "em9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkw\n" + "ODIyMTcwODUwWhcNMjQwODIyMTcwODUwWjCBjzELMAkGA1UEBhMCVVMxEDAOBgNV\n" + "BAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoMGUFtYXpv\n" + "biBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxIDAeBgNV\n" + "BAMMF0FtYXpvbiBSRFMgUm9vdCAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\n" + "AQ8AMIIBCgKCAQEArXnF/E6/Qh+ku3hQTSKPMhQQlCpoWvnIthzX6MK3p5a0eXKZ\n" + "oWIjYcNNG6UwJjp4fUXl6glp53Jobn+tWNX88dNH2n8DVbppSwScVE2LpuL+94vY\n" + "0EYE/XxN7svKea8YvlrqkUBKyxLxTjh+U/KrGOaHxz9v0l6ZNlDbuaZw3qIWdD/I\n" + "6aNbGeRUVtpM6P+bWIoxVl/caQylQS6CEYUk+CpVyJSkopwJlzXT07tMoDL5WgX9\n" + "O08KVgDNz9qP/IGtAcRduRcNioH3E9v981QO1zt/Gpb2f8NqAjUUCUZzOnij6mx9\n" + "McZ+9cWX88CRzR0vQODWuZscgI08NvM69Fn2SQIDAQABo2MwYTAOBgNVHQ8BAf8E\n" + "BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc19g2LzLA5j0Kxc0LjZa\n" + "pmD/vB8wHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJKoZIhvcN\n" + "AQELBQADggEBAHAG7WTmyjzPRIM85rVj+fWHsLIvqpw6DObIjMWokpliCeMINZFV\n" + "ynfgBKsf1ExwbvJNzYFXW6dihnguDG9VMPpi2up/ctQTN8tm9nDKOy08uNZoofMc\n" + "NUZxKCEkVKZv+IL4oHoeayt8egtv3ujJM6V14AstMQ6SwvwvA93EP/Ug2e4WAXHu\n" + "cbI1NAbUgVDqp+DRdfvZkgYKryjTWd/0+1fS8X1bBZVWzl7eirNVnHbSH2ZDpNuY\n" + "0SBd8dj5F6ld3t58ydZbrTHze7JJOd8ijySAp4/kiu9UfZWuTPABzDa/DSdz9Dk/\n" + "zPW4CXXvhLmE02TA9/HeCw3KEHIwicNuEfw=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEATCCAumgAwIBAgIBRDANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzMDZaFw0y\n" + "MDAzMDUyMjAzMDZaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJE\n" + "UyBhcC1ub3J0aGVhc3QtMSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" + "ggEBAMmM2B4PfTXCZjbZMWiDPyxvk/eeNwIRJAhfzesiGUiLozX6CRy3rwC1ZOPV\n" + "AcQf0LB+O8wY88C/cV+d4Q2nBDmnk+Vx7o2MyMh343r5rR3Na+4izd89tkQVt0WW\n" + "vO21KRH5i8EuBjinboOwAwu6IJ+HyiQiM0VjgjrmEr/YzFPL8MgHD/YUHehqjACn\n" + "C0+B7/gu7W4qJzBL2DOf7ub2qszGtwPE+qQzkCRDwE1A4AJmVE++/FLH2Zx78Egg\n" + "fV1sUxPtYgjGH76VyyO6GNKM6rAUMD/q5mnPASQVIXgKbupr618bnH+SWHFjBqZq\n" + "HvDGPMtiiWII41EmGUypyt5AbysCAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIG\n" + "A1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFIiKM0Q6n1K4EmLxs3ZXxINbwEwR\n" + "MB8GA1UdIwQYMBaAFE4C7qw+9hXITO0s9QXBj5yECEmDMA0GCSqGSIb3DQEBBQUA\n" + "A4IBAQBezGbE9Rw/k2e25iGjj5n8r+M3dlye8ORfCE/dijHtxqAKasXHgKX8I9Tw\n" + "JkBiGWiuzqn7gO5MJ0nMMro1+gq29qjZnYX1pDHPgsRjUX8R+juRhgJ3JSHijRbf\n" + "4qNJrnwga7pj94MhcLq9u0f6dxH6dXbyMv21T4TZMTmcFduf1KgaiVx1PEyJjC6r\n" + "M+Ru+A0eM+jJ7uCjUoZKcpX8xkj4nmSnz9NMPog3wdOSB9cAW7XIc5mHa656wr7I\n" + "WJxVcYNHTXIjCcng2zMKd1aCcl2KSFfy56sRfT7J5Wp69QSr+jq8KM55gw8uqAwi\n" + "VPrXn2899T1rcTtFYFP16WXjGuc0\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEATCCAumgAwIBAgIBTDANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTExMDYwMDA1NDZaFw0y\n" + "MDAzMDUwMDA1NDZaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJE\n" + "UyBhcC1ub3J0aGVhc3QtMiBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" + "ggEBAKSwd+RVUzTRH0FgnbwoTK8TMm/zMT4+2BvALpAUe6YXbkisg2goycWuuWLg\n" + "jOpFBB3GtyvXZnkqi7MkDWUmj1a2kf8l2oLyoaZ+Hm9x/sV+IJzOqPvj1XVUGjP6\n" + "yYYnPJmUYqvZeI7fEkIGdFkP2m4/sgsSGsFvpD9FK1bL1Kx2UDpYX0kHTtr18Zm/\n" + "1oN6irqWALSmXMDydb8hE0FB2A1VFyeKE6PnoDj/Y5cPHwPPdEi6/3gkDkSaOG30\n" + "rWeQfL3pOcKqzbHaWTxMphd0DSL/quZ64Nr+Ly65Q5PRcTrtr55ekOUziuqXwk+o\n" + "9QpACMwcJ7ROqOznZTqTzSFVXFECAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIG\n" + "A1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFM6Nox/QWbhzWVvzoJ/y0kGpNPK+\n" + "MB8GA1UdIwQYMBaAFE4C7qw+9hXITO0s9QXBj5yECEmDMA0GCSqGSIb3DQEBBQUA\n" + "A4IBAQCTkWBqNvyRf3Y/W21DwFx3oT/AIWrHt0BdGZO34tavummXemTH9LZ/mqv9\n" + "aljt6ZuDtf5DEQjdsAwXMsyo03ffnP7doWm8iaF1+Mui77ot0TmTsP/deyGwukvJ\n" + "tkxX8bZjDh+EaNauWKr+CYnniNxCQLfFtXYJsfOdVBzK3xNL+Z3ucOQRhr2helWc\n" + "CDQgwfhP1+3pRVKqHvWCPC4R3fT7RZHuRmZ38kndv476GxRntejh+ePffif78bFI\n" + "3rIZCPBGobrrUMycafSbyXteoGca/kA+/IqrAPlk0pWQ4aEL0yTWN2h2dnjoD7oX\n" + "byIuL/g9AGRh97+ssn7D6bDRPTbW\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEATCCAumgAwIBAgIBRTANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzMTlaFw0y\n" + "MDAzMDUyMjAzMTlaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJE\n" + "UyBhcC1zb3V0aGVhc3QtMSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" + "ggEBANaXElmSEYt/UtxHFsARFhSUahTf1KNJzR0Dmay6hqOXQuRVbKRwPd19u5vx\n" + "DdF1sLT7D69IK3VDnUiQScaCv2Dpu9foZt+rLx+cpx1qiQd1UHrvqq8xPzQOqCdC\n" + "RFStq6yVYZ69yfpfoI67AjclMOjl2Vph3ftVnqP0IgVKZdzeC7fd+umGgR9xY0Qr\n" + "Ubhd/lWdsbNvzK3f1TPWcfIKQnpvSt85PIEDJir6/nuJUKMtmJRwTymJf0i+JZ4x\n" + "7dJa341p2kHKcHMgOPW7nJQklGBA70ytjUV6/qebS3yIugr/28mwReflg3TJzVDl\n" + "EOvi6pqbqNbkMuEwGDCmEQIVqgkCAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIG\n" + "A1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFAu93/4k5xbWOsgdCdn+/KdiRuit\n" + "MB8GA1UdIwQYMBaAFE4C7qw+9hXITO0s9QXBj5yECEmDMA0GCSqGSIb3DQEBBQUA\n" + "A4IBAQBlcjSyscpPjf5+MgzMuAsCxByqUt+WFspwcMCpwdaBeHOPSQrXNqX2Sk6P\n" + "kth6oCivA64trWo8tFMvPYlUA1FYVD5WpN0kCK+P5pD4KHlaDsXhuhClJzp/OP8t\n" + "pOyUr5109RHLxqoKB5J5m1XA7rgcFjnMxwBSWFe3/4uMk/+4T53YfCVXuc6QV3i7\n" + "I/2LAJwFf//pTtt6fZenYfCsahnr2nvrNRNyAxcfvGZ/4Opn/mJtR6R/AjvQZHiR\n" + "bkRNKF2GW0ueK5W4FkZVZVhhX9xh1Aj2Ollb+lbOqADaVj+AT3PoJPZ3MPQHKCXm\n" + "xwG0LOLlRr/TfD6li1AfOVTAJXv9\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEATCCAumgAwIBAgIBRjANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzMjRaFw0y\n" + "MDAzMDUyMjAzMjRaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJE\n" + "UyBhcC1zb3V0aGVhc3QtMiBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" + "ggEBAJqBAJutz69hFOh3BtLHZTbwE8eejGGKayn9hu98YMDPzWzGXWCmW+ZYWELA\n" + "cY3cNWNF8K4FqKXFr2ssorBYim1UtYFX8yhydT2hMD5zgQ2sCGUpuidijuPA6zaq\n" + "Z3tdhVR94f0q8mpwpv2zqR9PcqaGDx2VR1x773FupRPRo7mEW1vC3IptHCQlP/zE\n" + "7jQiLl28bDIH2567xg7e7E9WnZToRnhlYdTaDaJsHTzi5mwILi4cihSok7Shv/ME\n" + "hnukvxeSPUpaVtFaBhfBqq055ePq9I+Ns4KGreTKMhU0O9fkkaBaBmPaFgmeX/XO\n" + "n2AX7gMouo3mtv34iDTZ0h6YCGkCAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIG\n" + "A1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFIlQnY0KHYWn1jYumSdJYfwj/Nfw\n" + "MB8GA1UdIwQYMBaAFE4C7qw+9hXITO0s9QXBj5yECEmDMA0GCSqGSIb3DQEBBQUA\n" + "A4IBAQA0wVU6/l41cTzHc4azc4CDYY2Wd90DFWiH9C/mw0SgToYfCJ/5Cfi0NT/Y\n" + "PRnk3GchychCJgoPA/k9d0//IhYEAIiIDjyFVgjbTkKV3sh4RbdldKVOUB9kumz/\n" + "ZpShplsGt3z4QQiVnKfrAgqxWDjR0I0pQKkxXa6Sjkicos9LQxVtJ0XA4ieG1E7z\n" + "zJr+6t80wmzxvkInSaWP3xNJK9azVRTrgQZQlvkbpDbExl4mNTG66VD3bAp6t3Wa\n" + "B49//uDdfZmPkqqbX+hsxp160OH0rxJppwO3Bh869PkDnaPEd/Pxw7PawC+li0gi\n" + "NRV8iCEx85aFxcyOhqn0WZOasxee\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/zCCAuegAwIBAgIBRzANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzMzFaFw0y\n" + "MDAzMDUyMjAzMzFaMIGSMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEjMCEGA1UEAwwaQW1hem9uIFJE\n" + "UyBldS1jZW50cmFsLTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB\n" + "AQDFtP2dhSLuaPOI4ZrrPWsK4OY9ocQBp3yApH1KJYmI9wpQKZG/KCH2E6Oo7JAw\n" + "QORU519r033T+FO2Z7pFPlmz1yrxGXyHpJs8ySx3Yo5S8ncDCdZJCLmtPiq/hahg\n" + "5/0ffexMFUCQaYicFZsrJ/cStdxUV+tSw2JQLD7UxS9J97LQWUPyyG+ZrjYVTVq+\n" + "zudnFmNSe4QoecXMhAFTGJFQXxP7nhSL9Ao5FGgdXy7/JWeWdQIAj8ku6cBDKPa6\n" + "Y6kP+ak+In+Lye8z9qsCD/afUozfWjPR2aA4JoIZVF8dNRShIMo8l0XfgfM2q0+n\n" + "ApZWZ+BjhIO5XuoUgHS3D2YFAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNV\n" + "HRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBRm4GsWIA/M6q+tK8WGHWDGh2gcyTAf\n" + "BgNVHSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOC\n" + "AQEAHpMmeVQNqcxgfQdbDIi5UIy+E7zZykmtAygN1XQrvga9nXTis4kOTN6g5/+g\n" + "HCx7jIXeNJzAbvg8XFqBN84Quqgpl/tQkbpco9Jh1HDs558D5NnZQxNqH5qXQ3Mm\n" + "uPgCw0pYcPOa7bhs07i+MdVwPBsX27CFDtsgAIru8HvKxY1oTZrWnyIRo93tt/pk\n" + "WuItVMVHjaQZVfTCow0aDUbte6Vlw82KjUFq+n2NMSCJDiDKsDDHT6BJc4AJHIq3\n" + "/4Z52MSC9KMr0yAaaoWfW/yMEj9LliQauAgwVjArF4q78rxpfKTG9Rfd8U1BZANP\n" + "7FrFMN0ThjfA1IvmOYcgskY5bQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBSDANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzMzVaFw0y\n" + "MDAzMDUyMjAzMzVaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyBldS13ZXN0LTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx\n" + "PdbqQ0HKRj79Pmocxvjc+P6i4Ux24kgFIl+ckiir1vzkmesc3a58gjrMlCksEObt\n" + "Yihs5IhzEq1ePT0gbfS9GYFp34Uj/MtPwlrfCBWG4d2TcrsKRHr1/EXUYhWqmdrb\n" + "RhX8XqoRhVkbF/auzFSBhTzcGGvZpQ2KIaxRcQfcXlMVhj/pxxAjh8U4F350Fb0h\n" + "nX1jw4/KvEreBL0Xb2lnlGTkwVxaKGSgXEnOgIyOFdOQc61vdome0+eeZsP4jqeR\n" + "TGYJA9izJsRbe2YJxHuazD+548hsPlM3vFzKKEVURCha466rAaYAHy3rKur3HYQx\n" + "Yt+SoKcEz9PXuSGj96ejAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBTebg//h2oeXbZjQ4uuoiuLYzuiPDAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOCAQEA\n" + "TikPaGeZasTPw+4RBemlsyPAjtFFQLo7ddaFdORLgdEysVf8aBqndvbA6MT/v4lj\n" + "GtEtUdF59ZcbWOrVm+fBZ2h/jYJ59dYF/xzb09nyRbdMSzB9+mkSsnOMqluq5y8o\n" + "DY/PfP2vGhEg/2ZncRC7nlQU1Dm8F4lFWEiQ2fi7O1cW852Vmbq61RIfcYsH/9Ma\n" + "kpgk10VZ75b8m3UhmpZ/2uRY+JEHImH5WpcTJ7wNiPNJsciZMznGtrgOnPzYco8L\n" + "cDleOASIZifNMQi9PKOJKvi0ITz0B/imr8KBsW0YjZVJ54HMa7W1lwugSM7aMAs+\n" + "E3Sd5lS+SHwWaOCHwhOEVA==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBSTANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzNDBaFw0y\n" + "MDAzMDUyMjAzNDBaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyBzYS1lYXN0LTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCU\n" + "X4OBnQ5xA6TLJAiFEI6l7bUWjoVJBa/VbMdCCSs2i2dOKmqUaXu2ix2zcPILj3lZ\n" + "GMk3d/2zvTK/cKhcFrewHUBamTeVHdEmynhMQamqNmkM4ptYzFcvEUw1TGxHT4pV\n" + "Q6gSN7+/AJewQvyHexHo8D0+LDN0/Wa9mRm4ixCYH2CyYYJNKaZt9+EZfNu+PPS4\n" + "8iB0TWH0DgQkbWMBfCRgolLLitAZklZ4dvdlEBS7evN1/7ttBxUK6SvkeeSx3zBl\n" + "ww3BlXqc3bvTQL0A+RRysaVyFbvtp9domFaDKZCpMmDFAN/ntx215xmQdrSt+K3F\n" + "cXdGQYHx5q410CAclGnbAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBT6iVWnm/uakS+tEX2mzIfw+8JL0zAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOCAQEA\n" + "FmDD+QuDklXn2EgShwQxV13+txPRuVdOSrutHhoCgMwFWCMtPPtBAKs6KPY7Guvw\n" + "DpJoZSehDiOfsgMirjOWjvfkeWSNvKfjWTVneX7pZD9W5WPnsDBvTbCGezm+v87z\n" + "b+ZM2ZMo98m/wkMcIEAgdSKilR2fuw8rLkAjhYFfs0A7tDgZ9noKwgHvoE4dsrI0\n" + "KZYco6DlP/brASfHTPa2puBLN9McK3v+h0JaSqqm5Ro2Bh56tZkQh8AWy/miuDuK\n" + "3+hNEVdxosxlkM1TPa1DGj0EzzK0yoeerXuH2HX7LlCrrxf6/wdKnjR12PMrLQ4A\n" + "pCqkcWw894z6bV9MAvKe6A==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBQzANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMTU0MDRaFw0y\n" + "MDAzMDUyMTU0MDRaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyB1cy1lYXN0LTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDI\n" + "UIuwh8NusKHk1SqPXcP7OqxY3S/M2ZyQWD3w7Bfihpyyy/fc1w0/suIpX3kbMhAV\n" + "2ESwged2/2zSx4pVnjp/493r4luhSqQYzru78TuPt9bhJIJ51WXunZW2SWkisSaf\n" + "USYUzVN9ezR/bjXTumSUQaLIouJt3OHLX49s+3NAbUyOI8EdvgBQWD68H1epsC0n\n" + "CI5s+pIktyOZ59c4DCDLQcXErQ+tNbDC++oct1ANd/q8p9URonYwGCGOBy7sbCYq\n" + "9eVHh1Iy2M+SNXddVOGw5EuruvHoCIQyOz5Lz4zSuZA9dRbrfztNOpezCNYu6NKM\n" + "n+hzcvdiyxv77uNm8EaxAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBQSQG3TmMe6Sa3KufaPBa72v4QFDzAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOCAQEA\n" + "L/mOZfB3187xTmjOHMqN2G2oSKHBKiQLM9uv8+97qT+XR+TVsBT6b3yoPpMAGhHA\n" + "Pc7nxAF5gPpuzatx0OTLPcmYucFmfqT/1qA5WlgCnMNtczyNMH97lKFTNV7Njtek\n" + "jWEzAEQSyEWrkNpNlC4j6kMYyPzVXQeXUeZTgJ9FNnVZqmvfjip2N22tawMjrCn5\n" + "7KN/zN65EwY2oO9XsaTwwWmBu3NrDdMbzJnbxoWcFWj4RBwanR1XjQOVNhDwmCOl\n" + "/1Et13b8CPyj69PC8BOVU6cfTSx8WUVy0qvYOKHNY9Bqa5BDnIL3IVmUkeTlM1mt\n" + "enRpyBj+Bk9rh/ICdiRKmA==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBSjANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzNDVaFw0y\n" + "MDAzMDUyMjAzNDVaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyB1cy13ZXN0LTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDE\n" + "Dhw+uw/ycaiIhhyu2pXFRimq0DlB8cNtIe8hdqndH8TV/TFrljNgR8QdzOgZtZ9C\n" + "zzQ2GRpInN/qJF6slEd6wO+6TaDBQkPY+07TXNt52POFUhdVkhJXHpE2BS7Xn6J7\n" + "7RFAOeG1IZmc2DDt+sR1BgXzUqHslQGfFYNS0/MBO4P+ya6W7IhruB1qfa4HiYQS\n" + "dbe4MvGWnv0UzwAqdR7OF8+8/5c58YXZIXCO9riYF2ql6KNSL5cyDPcYK5VK0+Q9\n" + "VI6vuJHSMYcF7wLePw8jtBktqAFE/wbdZiIHhZvNyiNWPPNTGUmQbaJ+TzQEHDs5\n" + "8en+/W7JKnPyBOkxxENbAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBS0nw/tFR9bCjgqWTPJkyy4oOD8bzAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOCAQEA\n" + "CXGAY3feAak6lHdqj6+YWjy6yyUnLK37bRxZDsyDVXrPRQaXRzPTzx79jvDwEb/H\n" + "Q/bdQ7zQRWqJcbivQlwhuPJ4kWPUZgSt3JUUuqkMsDzsvj/bwIjlrEFDOdHGh0mi\n" + "eVIngFEjUXjMh+5aHPEF9BlQnB8LfVtKj18e15UDTXFa+xJPFxUR7wDzCfo4WI1m\n" + "sUMG4q1FkGAZgsoyFPZfF8IVvgCuGdR8z30VWKklFxttlK0eGLlPAyIO0CQxPQlo\n" + "saNJrHf4tLOgZIWk+LpDhNd9Et5EzvJ3aURUsKY4pISPPF5WdvM9OE59bERwUErd\n" + "nuOuQWQeeadMceZnauRzJQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBSzANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNTAyMDUyMjAzNTBaFw0y\n" + "MDAzMDUyMjAzNTBaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyB1cy13ZXN0LTIgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDM\n" + "H58SR48U6jyERC1vYTnub34smf5EQVXyzaTmspWGWGzT31NLNZGSDFaa7yef9kdO\n" + "mzJsgebR5tXq6LdwlIoWkKYQ7ycUaadtVKVYdI40QcI3cHn0qLFlg2iBXmWp/B+i\n" + "Z34VuVlCh31Uj5WmhaBoz8t/GRqh1V/aCsf3Wc6jCezH3QfuCjBpzxdOOHN6Ie2v\n" + "xX09O5qmZTvMoRBAvPkxdaPg/Mi7fxueWTbEVk78kuFbF1jHYw8U1BLILIAhcqlq\n" + "x4u8nl73t3O3l/soNUcIwUDK0/S+Kfqhwn9yQyPlhb4Wy3pfnZLJdkyHldktnQav\n" + "9TB9u7KH5Lk0aAYslMLxAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBT8roM4lRnlFHWMPWRz0zkwFZog1jAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQUFAAOCAQEA\n" + "JwrxwgwmPtcdaU7O7WDdYa4hprpOMamI49NDzmE0s10oGrqmLwZygcWU0jT+fJ+Y\n" + "pJe1w0CVfKaeLYNsOBVW3X4ZPmffYfWBheZiaiEflq/P6t7/Eg81gaKYnZ/x1Dfa\n" + "sUYkzPvCkXe9wEz5zdUTOCptDt89rBR9CstL9vE7WYUgiVVmBJffWbHQLtfjv6OF\n" + "NMb0QME981kGRzc2WhgP71YS2hHd1kXtsoYP1yTu4vThSKsoN4bkiHsaC1cRkLoy\n" + "0fFA4wpB3WloMEvCDaUvvH1LZlBXTNlwi9KtcwD4tDxkkBt4tQczKLGpQ/nF/W9n\n" + "8YDWk3IIc1sd0bkZqoau2Q==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/TCCAuWgAwIBAgIBTTANBgkqhkiG9w0BAQsFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNjA1MDMyMTI5MjJaFw0y\n" + "MDAzMDUyMTI5MjJaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UEAwwYQW1hem9uIFJE\n" + "UyBhcC1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\n" + "06eWGLE0TeqL9kyWOLkS8q0fXO97z+xyBV3DKSB2lg2GkgBz3B98MkmkeB0SZy3G\n" + "Ce4uCpCPbFKiFEdiUclOlhZsrBuCeaimxLM3Ig2wuenElO/7TqgaYHYUbT3d+VQW\n" + "GUbLn5GRZJZe1OAClYdOWm7A1CKpuo+cVV1vxbY2nGUQSJPpVn2sT9gnwvjdE60U\n" + "JGYU/RLCTm8zmZBvlWaNIeKDnreIc4rKn6gUnJ2cQn1ryCVleEeyc3xjYDSrjgdn\n" + "FLYGcp9mphqVT0byeQMOk0c7RHpxrCSA0V5V6/CreFV2LteK50qcDQzDSM18vWP/\n" + "p09FoN8O7QrtOeZJzH/lmwIDAQABo2YwZDAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0T\n" + "AQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU2i83QHuEl/d0keXF+69HNJph7cMwHwYD\n" + "VR0jBBgwFoAUTgLurD72FchM7Sz1BcGPnIQISYMwDQYJKoZIhvcNAQELBQADggEB\n" + "ACqnH2VjApoDqoSQOky52QBwsGaj+xWYHW5Gm7EvCqvQuhWMkeBuD6YJmMvNyA9G\n" + "I2lh6/o+sUk/RIsbYbxPRdhNPTOgDR9zsNRw6qxaHztq/CEC+mxDCLa3O1hHBaDV\n" + "BmB3nCZb93BvO0EQSEk7aytKq/f+sjyxqOcs385gintdHGU9uM7gTZHnU9vByJsm\n" + "/TL07Miq67X0NlhIoo3jAk+xHaeKJdxdKATQp0448P5cY20q4b8aMk1twcNaMvCP\n" + "dG4M5doaoUA8OQ/0ukLLae/LBxLeTw04q1/a2SyFaVUX2Twbb1S3xVWwLA8vsyGr\n" + "igXx7B5GgP+IHb6DTjPJAi0=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBTjANBgkqhkiG9w0BAQsFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNjA4MTExOTU4NDVaFw0y\n" + "MDAzMDUxOTU4NDVaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyB1cy1lYXN0LTIgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCp\n" + "WnnUX7wM0zzstccX+4iXKJa9GR0a2PpvB1paEX4QRCgfhEdQWDaSqyrWNgdVCKkt\n" + "1aQkWu5j6VAC2XIG7kKoonm1ZdBVyBLqW5lXNywlaiU9yhJkwo8BR+/OqgE+PLt/\n" + "EO1mlN0PQudja/XkExCXTO29TG2j7F/O7hox6vTyHNHc0H88zS21uPuBE+jivViS\n" + "yzj/BkyoQ85hnkues3f9R6gCGdc+J51JbZnmgzUkvXjAEuKhAm9JksVOxcOKUYe5\n" + "ERhn0U9zjzpfbAITIkul97VVa5IxskFFTHIPJbvRKHJkiF6wTJww/tc9wm+fSCJ1\n" + "+DbQTGZgkQ3bJrqRN29/AgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBSAHQzUYYZbepwKEMvGdHp8wzHnfDAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQsFAAOCAQEA\n" + "MbaEzSYZ+aZeTBxf8yi0ta8K4RdwEJsEmP6IhFFQHYUtva2Cynl4Q9tZg3RMsybT\n" + "9mlnSQQlbN/wqIIXbkrcgFcHoXG9Odm/bDtUwwwDaiEhXVfeQom3G77QHOWMTCGK\n" + "qadwuh5msrb17JdXZoXr4PYHDKP7j0ONfAyFNER2+uecblHfRSpVq5UeF3L6ZJb8\n" + "fSw/GtAV6an+/0r+Qm+PiI2H5XuZ4GmRJYnGMhqWhBYrY7p3jtVnKcsh39wgfUnW\n" + "AvZEZG/yhFyAZW0Essa39LiL5VSq14Y1DOj0wgnhSY/9WHxaAo1HB1T9OeZknYbD\n" + "fl/EGSZ0TEvZkENrXcPlVA==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/zCCAuegAwIBAgIBTzANBgkqhkiG9w0BAQsFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNjA5MTUwMDEwMTFaFw0y\n" + "MDAzMDUwMDEwMTFaMIGSMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEjMCEGA1UEAwwaQW1hem9uIFJE\n" + "UyBjYS1jZW50cmFsLTEgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB\n" + "AQCZYI/iQ6DrS3ny3t1EwX1wAD+3LMgh7Fd01EW5LIuaK2kYIIQpsVKhxLCit/V5\n" + "AGc/1qiJS1Qz9ODLTh0Na6bZW6EakRzuHJLe32KJtoFYPC7Z09UqzXrpA/XL+1hM\n" + "P0ZmCWsU7Nn/EmvfBp9zX3dZp6P6ATrvDuYaVFr+SA7aT3FXpBroqBS1fyzUPs+W\n" + "c6zTR6+yc4zkHX0XQxC5RH6xjgpeRkoOajA/sNo7AQF7KlWmKHbdVF44cvvAhRKZ\n" + "XaoVs/C4GjkaAEPTCbopYdhzg+KLx9eB2BQnYLRrIOQZtRfbQI2Nbj7p3VsRuOW1\n" + "tlcks2w1Gb0YC6w6SuIMFkl1AgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNV\n" + "HRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBToYWxE1lawl6Ks6NsvpbHQ3GKEtzAf\n" + "BgNVHSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQsFAAOC\n" + "AQEAG/8tQ0ooi3hoQpa5EJz0/E5VYBsAz3YxA2HoIonn0jJyG16bzB4yZt4vNQMA\n" + "KsNlQ1uwDWYL1nz63axieUUFIxqxl1KmwfhsmLgZ0Hd2mnTPIl2Hw3uj5+wdgGBg\n" + "agnAZ0bajsBYgD2VGQbqjdk2Qn7Fjy3LEWIvGZx4KyZ99OJ2QxB7JOPdauURAtWA\n" + "DKYkP4LLJxtj07DSzG8kuRWb9B47uqUD+eKDIyjfjbnzGtd9HqqzYFau7EX3HVD9\n" + "9Qhnjl7bTZ6YfAEZ3nH2t3Vc0z76XfGh47rd0pNRhMV+xpok75asKf/lNh5mcUrr\n" + "VKwflyMkQpSbDCmcdJ90N2xEXQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBUDANBgkqhkiG9w0BAQsFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNjEwMTAxNzQ0NDJaFw0y\n" + "MDAzMDUxNzQ0NDJaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyBldS13ZXN0LTIgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDO\n" + "cttLJfubB4XMMIGWNfJISkIdCMGJyOzLiMJaiWB5GYoXKhEl7YGotpy0qklwW3BQ\n" + "a0fmVdcCLX+dIuVQ9iFK+ZcK7zwm7HtdDTCHOCKeOh2IcnU4c/VIokFi6Gn8udM6\n" + "N/Zi5M5OGpVwLVALQU7Yctsn3c95el6MdVx6mJiIPVu7tCVZn88Z2koBQ2gq9P4O\n" + "Sb249SHFqOb03lYDsaqy1NDsznEOhaRBw7DPJFpvmw1lA3/Y6qrExRI06H2VYR2i\n" + "7qxwDV50N58fs10n7Ye1IOxTVJsgEA7X6EkRRXqYaM39Z76R894548WHfwXWjUsi\n" + "MEX0RS0/t1GmnUQjvevDAgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBQBxmcuRSxERYCtNnSr5xNfySokHjAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQsFAAOCAQEA\n" + "UyCUQjsF3nUAABjfEZmpksTuUo07aT3KGYt+EMMFdejnBQ0+2lJJFGtT+CDAk1SD\n" + "RSgfEBon5vvKEtlnTf9a3pv8WXOAkhfxnryr9FH6NiB8obISHNQNPHn0ljT2/T+I\n" + "Y6ytfRvKHa0cu3V0NXbJm2B4KEOt4QCDiFxUIX9z6eB4Kditwu05OgQh6KcogOiP\n" + "JesWxBMXXGoDC1rIYTFO7szwDyOHlCcVXJDNsTJhc32oDWYdeIbW7o/5I+aQsrXZ\n" + "C96HykZcgWzz6sElrQxUaT3IoMw/5nmw4uWKKnZnxgI9bY4fpQwMeBZ96iHfFxvH\n" + "mqfEEuC7uUoPofXdBp2ObQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECjCCAvKgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZMxCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSQwIgYDVQQDDBtBbWF6b24gUkRTIEdvdkNsb3VkIFJvb3QgQ0EwHhcNMTcwNTE5\n" + "MjIzMTE5WhcNMjIwNTE4MTIwMDAwWjCBkzELMAkGA1UEBhMCVVMxEzARBgNVBAgM\n" + "Cldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBX\n" + "ZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJDAiBgNVBAMM\n" + "G0FtYXpvbiBSRFMgdXMtZ292LXdlc3QtMSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\n" + "ggEPADCCAQoCggEBAM8YZLKAzzOdNnoi7Klih26Zkj+OCpDfwx4ZYB6f8L8UoQi5\n" + "8z9ZtIwMjiJ/kO08P1yl4gfc7YZcNFvhGruQZNat3YNpxwUpQcr4mszjuffbL4uz\n" + "+/8FBxALdqCVOJ5Q0EVSfz3d9Bd1pUPL7ARtSpy7bn/tUPyQeI+lODYO906C0TQ3\n" + "b9bjOsgAdBKkHfjLdsknsOZYYIzYWOJyFJJa0B11XjDUNBy/3IuC0KvDl6At0V5b\n" + "8M6cWcKhte2hgjwTYepV+/GTadeube1z5z6mWsN5arOAQUtYDLH6Aztq9mCJzLHm\n" + "RccBugnGl3fRLJ2VjioN8PoGoN9l9hFBy5fnFgsCAwEAAaNmMGQwDgYDVR0PAQH/\n" + "BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFEG7+br8KkvwPd5g\n" + "71Rvh2stclJbMB8GA1UdIwQYMBaAFEkQz6S4NS5lOYKcDjBSuCcVpdzjMA0GCSqG\n" + "SIb3DQEBCwUAA4IBAQBMA327u5ABmhX+aPxljoIbxnydmAFWxW6wNp5+rZrvPig8\n" + "zDRqGQWWr7wWOIjfcWugSElYtf/m9KZHG/Z6+NG7nAoUrdcd1h/IQhb+lFQ2b5g9\n" + "sVzQv/H2JNkfZA8fL/Ko/Tm/f9tcqe0zrGCtT+5u0Nvz35Wl8CEUKLloS5xEb3k5\n" + "7D9IhG3fsE3vHWlWrGCk1cKry3j12wdPG5cUsug0vt34u6rdhP+FsM0tHI15Kjch\n" + "RuUCvyQecy2ZFNAa3jmd5ycNdL63RWe8oayRBpQBxPPCbHfILxGZEdJbCH9aJ2D/\n" + "l8oHIDnvOLdv7/cBjyYuvmprgPtu3QEkbre5Hln/\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIID/DCCAuSgAwIBAgIBUTANBgkqhkiG9w0BAQsFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNzA4MjUyMTM5MjZaFw0y\n" + "MDAzMDUyMTM5MjZaMIGPMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJE\n" + "UyBldS13ZXN0LTMgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+\n" + "xmlEC/3a4cJH+UPwXCE02lC7Zq5NHd0dn6peMeLN8agb6jW4VfSY0NydjRj2DJZ8\n" + "K7wV6sub5NUGT1NuFmvSmdbNR2T59KX0p2dVvxmXHHtIpQ9Y8Aq3ZfhmC5q5Bqgw\n" + "tMA1xayDi7HmoPX3R8kk9ktAZQf6lDeksCvok8idjTu9tiSpDiMwds5BjMsWfyjZ\n" + "d13PTGGNHYVdP692BSyXzSP1Vj84nJKnciW8tAqwIiadreJt5oXyrCXi8ekUMs80\n" + "cUTuGm3aA3Q7PB5ljJMPqz0eVddaiIvmTJ9O3Ez3Du/HpImyMzXjkFaf+oNXf/Hx\n" + "/EW5jCRR6vEiXJcDRDS7AgMBAAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMB\n" + "Af8ECDAGAQH/AgEAMB0GA1UdDgQWBBRZ9mRtS5fHk3ZKhG20Oack4cAqMTAfBgNV\n" + "HSMEGDAWgBROAu6sPvYVyEztLPUFwY+chAhJgzANBgkqhkiG9w0BAQsFAAOCAQEA\n" + "F/u/9L6ExQwD73F/bhCw7PWcwwqsK1mypIdrjdIsu0JSgwWwGCXmrIspA3n3Dqxq\n" + "sMhAJD88s9Em7337t+naar2VyLO63MGwjj+vA4mtvQRKq8ScIpiEc7xN6g8HUMsd\n" + "gPG9lBGfNjuAZsrGJflrko4HyuSM7zHExMjXLH+CXcv/m3lWOZwnIvlVMa4x0Tz0\n" + "A4fklaawryngzeEjuW6zOiYCzjZtPlP8Fw0SpzppJ8VpQfrZ751RDo4yudmPqoPK\n" + "5EUe36L8U+oYBXnC5TlYs9bpVv9o5wJQI5qA9oQE2eFWxF1E0AyZ4V5sgGUBStaX\n" + "BjDDWul0wSo7rt1Tq7XpnA==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEATCCAumgAwIBAgIBTjANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMCVVMx\n" + "EzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "GzAZBgNVBAMMEkFtYXpvbiBSRFMgUm9vdCBDQTAeFw0xNzEyMDEwMDU1NDJaFw0y\n" + "MDAzMDUwMDU1NDJaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3Rv\n" + "bjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\n" + "cywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJE\n" + "UyBhcC1ub3J0aGVhc3QtMyBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" + "ggEBAMZtQNnm/XT19mTa10ftHLzg5UhajoI65JHv4TQNdGXdsv+CQdGYU49BJ9Eu\n" + "3bYgiEtTzR2lQe9zGMvtuJobLhOWuavzp7IixoIQcHkFHN6wJ1CvqrxgvJfBq6Hy\n" + "EuCDCiU+PPDLUNA6XM6Qx3IpHd1wrJkjRB80dhmMSpxmRmx849uFafhN+P1QybsM\n" + "TI0o48VON2+vj+mNuQTyLMMP8D4odSQHjaoG+zyJfJGZeAyqQyoOUOFEyQaHC3TT\n" + "3IDSNCQlpxb9LerbCoKu79WFBBq3CS5cYpg8/fsnV2CniRBFFUumBt5z4dhw9RJU\n" + "qlUXXO1ZyzpGd+c5v6FtrfXtnIUCAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIG\n" + "A1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFETv7ELNplYy/xTeIOInl6nzeiHg\n" + "MB8GA1UdIwQYMBaAFE4C7qw+9hXITO0s9QXBj5yECEmDMA0GCSqGSIb3DQEBBQUA\n" + "A4IBAQCpKxOQcd0tEKb3OtsOY8q/MPwTyustGk2Rt7t9G68idADp8IytB7M0SDRo\n" + "wWZqynEq7orQVKdVOanhEWksNDzGp0+FPAf/KpVvdYCd7ru3+iI+V4ZEp2JFdjuZ\n" + "Zz0PIjS6AgsZqE5Ri1J+NmfmjGZCPhsHnGZiBaenX6K5VRwwwmLN6xtoqrrfR5zL\n" + "QfBeeZNJG6KiM3R/DxJ5rAa6Fz+acrhJ60L7HprhB7SFtj1RCijau3+ZwiGmUOMr\n" + "yKlMv+VgmzSw7o4Hbxy1WVrA6zQsTHHSGf+vkQn2PHvnFMUEu/ZLbTDYFNmTLK91\n" + "K6o4nMsEvhBKgo4z7H1EqqxXhvN2\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDjCCAvagAwIBAgIJAMM61RQn3/kdMA0GCSqGSIb3DQEBCwUAMIGTMQswCQYD\n" + "VQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\n" + "MCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\n" + "em9uIFJEUzEkMCIGA1UEAwwbQW1hem9uIFJEUyBHb3ZDbG91ZCBSb290IENBMB4X\n" + "DTE3MDUxOTIyMjkxMVoXDTIyMDUxODIyMjkxMVowgZMxCzAJBgNVBAYTAlVTMRAw\n" + "DgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQKDBlB\n" + "bWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMSQw\n" + "IgYDVQQDDBtBbWF6b24gUkRTIEdvdkNsb3VkIFJvb3QgQ0EwggEiMA0GCSqGSIb3\n" + "DQEBAQUAA4IBDwAwggEKAoIBAQDGS9bh1FGiJPT+GRb3C5aKypJVDC1H2gbh6n3u\n" + "j8cUiyMXfmm+ak402zdLpSYMaxiQ7oL/B3wEmumIpRDAsQrSp3B/qEeY7ipQGOfh\n" + "q2TXjXGIUjiJ/FaoGqkymHRLG+XkNNBtb7MRItsjlMVNELXECwSiMa3nJL2/YyHW\n" + "nTr1+11/weeZEKgVbCUrOugFkMXnfZIBSn40j6EnRlO2u/NFU5ksK5ak2+j8raZ7\n" + "xW7VXp9S1Tgf1IsWHjGZZZguwCkkh1tHOlHC9gVA3p63WecjrIzcrR/V27atul4m\n" + "tn56s5NwFvYPUIx1dbC8IajLUrepVm6XOwdQCfd02DmOyjWJAgMBAAGjYzBhMA4G\n" + "A1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRJEM+kuDUu\n" + "ZTmCnA4wUrgnFaXc4zAfBgNVHSMEGDAWgBRJEM+kuDUuZTmCnA4wUrgnFaXc4zAN\n" + "BgkqhkiG9w0BAQsFAAOCAQEAcfA7uirXsNZyI2j4AJFVtOTKOZlQwqbyNducnmlg\n" + "/5nug9fAkwM4AgvF5bBOD1Hw6khdsccMwIj+1S7wpL+EYb/nSc8G0qe1p/9lZ/mZ\n" + "ff5g4JOa26lLuCrZDqAk4TzYnt6sQKfa5ZXVUUn0BK3okhiXS0i+NloMyaBCL7vk\n" + "kDwkHwEqflRKfZ9/oFTcCfoiHPA7AdBtaPVr0/Kj9L7k+ouz122huqG5KqX0Zpo8\n" + "S0IGvcd2FZjNSNPttNAK7YuBVsZ0m2nIH1SLp//00v7yAHIgytQwwB17PBcp4NXD\n" + "pCfTa27ng9mMMC2YLqWQpW4TkqjDin2ZC+5X/mbrjzTvVg==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZQxCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSUwIwYDVQQDDBxBbWF6b24gUkRTIGFwLWVhc3QtMSBSb290IENBMB4XDTE5MDIx\n" + "NzAyNDcwMFoXDTIyMDYwMTEyMDAwMFowgY8xCzAJBgNVBAYTAlVTMRMwEQYDVQQI\n" + "DApXYXNoaW5ndG9uMRAwDgYDVQQHDAdTZWF0dGxlMSIwIAYDVQQKDBlBbWF6b24g\n" + "V2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMSAwHgYDVQQD\n" + "DBdBbWF6b24gUkRTIGFwLWVhc3QtMSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBAOcJAUofyJuBuPr5ISHi/Ha5ed8h3eGdzn4MBp6rytPOg9NVGRQs\n" + "O93fNGCIKsUT6gPuk+1f1ncMTV8Y0Fdf4aqGWme+Khm3ZOP3V1IiGnVq0U2xiOmn\n" + "SQ4Q7LoeQC4lC6zpoCHVJyDjZ4pAknQQfsXb77Togdt/tK5ahev0D+Q3gCwAoBoO\n" + "DHKJ6t820qPi63AeGbJrsfNjLKiXlFPDUj4BGir4dUzjEeH7/hx37na1XG/3EcxP\n" + "399cT5k7sY/CR9kctMlUyEEUNQOmhi/ly1Lgtihm3QfjL6K9aGLFNwX35Bkh9aL2\n" + "F058u+n8DP/dPeKUAcJKiQZUmzuen5n57x8CAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFFlqgF4FQlb9yP6c+Q3E\n" + "O3tXv+zOMB8GA1UdIwQYMBaAFK9T6sY/PBZVbnHcNcQXf58P4OuPMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQDeXiS3v1z4jWAo1UvVyKDeHjtrtEH1Rida1eOXauFuEQa5tuOk\n" + "E53Os4haZCW4mOlKjigWs4LN+uLIAe1aFXGo92nGIqyJISHJ1L+bopx/JmIbHMCZ\n" + "0lTNJfR12yBma5VQy7vzeFku/SisKwX0Lov1oHD4MVhJoHbUJYkmAjxorcIHORvh\n" + "I3Vj5XrgDWtLDPL8/Id/roul/L+WX5ir+PGScKBfQIIN2lWdZoqdsx8YWqhm/ikL\n" + "C6qNieSwcvWL7C03ri0DefTQMY54r5wP33QU5hJ71JoaZI3YTeT0Nf+NRL4hM++w\n" + "Q0veeNzBQXg1f/JxfeA39IDIX1kiCf71tGlT\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDDCCAvSgAwIBAgICcEUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNjU2\n" + "MjBaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\n" + "em9uIFJEUyBhcC1ub3J0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\n" + "AAOCAQ8AMIIBCgKCAQEAndtkldmHtk4TVQAyqhAvtEHSMb6pLhyKrIFved1WO3S7\n" + "+I+bWwv9b2W/ljJxLq9kdT43bhvzonNtI4a1LAohS6bqyirmk8sFfsWT3akb+4Sx\n" + "1sjc8Ovc9eqIWJCrUiSvv7+cS7ZTA9AgM1PxvHcsqrcUXiK3Jd/Dax9jdZE1e15s\n" + "BEhb2OEPE+tClFZ+soj8h8Pl2Clo5OAppEzYI4LmFKtp1X/BOf62k4jviXuCSst3\n" + "UnRJzE/CXtjmN6oZySVWSe0rQYuyqRl6//9nK40cfGKyxVnimB8XrrcxUN743Vud\n" + "QQVU0Esm8OVTX013mXWQXJHP2c0aKkog8LOga0vobQIDAQABo2YwZDAOBgNVHQ8B\n" + "Af8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQULmoOS1mFSjj+\n" + "snUPx4DgS3SkLFYwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\n" + "KoZIhvcNAQELBQADggEBAAkVL2P1M2/G9GM3DANVAqYOwmX0Xk58YBHQu6iiQg4j\n" + "b4Ky/qsZIsgT7YBsZA4AOcPKQFgGTWhe9pvhmXqoN3RYltN8Vn7TbUm/ZVDoMsrM\n" + "gwv0+TKxW1/u7s8cXYfHPiTzVSJuOogHx99kBW6b2f99GbP7O1Sv3sLq4j6lVvBX\n" + "Fiacf5LAWC925nvlTzLlBgIc3O9xDtFeAGtZcEtxZJ4fnGXiqEnN4539+nqzIyYq\n" + "nvlgCzyvcfRAxwltrJHuuRu6Maw5AGcd2Y0saMhqOVq9KYKFKuD/927BTrbd2JVf\n" + "2sGWyuPZPCk3gq+5pCjbD0c6DkhcMGI6WwxvM5V/zSM=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDDCCAvSgAwIBAgICOFAwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAxNzQ2\n" + "MjFaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\n" + "em9uIFJEUyBhcC1ub3J0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\n" + "AAOCAQ8AMIIBCgKCAQEAzU72e6XbaJbi4HjJoRNjKxzUEuChKQIt7k3CWzNnmjc5\n" + "8I1MjCpa2W1iw1BYVysXSNSsLOtUsfvBZxi/1uyMn5ZCaf9aeoA9UsSkFSZBjOCN\n" + "DpKPCmfV1zcEOvJz26+1m8WDg+8Oa60QV0ou2AU1tYcw98fOQjcAES0JXXB80P2s\n" + "3UfkNcnDz+l4k7j4SllhFPhH6BQ4lD2NiFAP4HwoG6FeJUn45EPjzrydxjq6v5Fc\n" + "cQ8rGuHADVXotDbEhaYhNjIrsPL+puhjWfhJjheEw8c4whRZNp6gJ/b6WEes/ZhZ\n" + "h32DwsDsZw0BfRDUMgUn8TdecNexHUw8vQWeC181hwIDAQABo2YwZDAOBgNVHQ8B\n" + "Af8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwW9bWgkWkr0U\n" + "lrOsq2kvIdrECDgwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\n" + "KoZIhvcNAQELBQADggEBAEugF0Gj7HVhX0ehPZoGRYRt3PBuI2YjfrrJRTZ9X5wc\n" + "9T8oHmw07mHmNy1qqWvooNJg09bDGfB0k5goC2emDiIiGfc/kvMLI7u+eQOoMKj6\n" + "mkfCncyRN3ty08Po45vTLBFZGUvtQmjM6yKewc4sXiASSBmQUpsMbiHRCL72M5qV\n" + "obcJOjGcIdDTmV1BHdWT+XcjynsGjUqOvQWWhhLPrn4jWe6Xuxll75qlrpn3IrIx\n" + "CRBv/5r7qbcQJPOgwQsyK4kv9Ly8g7YT1/vYBlR3cRsYQjccw5ceWUj2DrMVWhJ4\n" + "prf+E3Aa4vYmLLOUUvKnDQ1k3RGNu56V0tonsQbfsaM=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDDCCAvSgAwIBAgICOYIwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTcyMDA1\n" + "MjlaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\n" + "em9uIFJEUyBhcC1ub3J0aGVhc3QtMyAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\n" + "AAOCAQ8AMIIBCgKCAQEA4dMak8W+XW8y/2F6nRiytFiA4XLwePadqWebGtlIgyCS\n" + "kbug8Jv5w7nlMkuxOxoUeD4WhI6A9EkAn3r0REM/2f0aYnd2KPxeqS2MrtdxxHw1\n" + "xoOxk2x0piNSlOz6yog1idsKR5Wurf94fvM9FdTrMYPPrDabbGqiBMsZZmoHLvA3\n" + "Z+57HEV2tU0Ei3vWeGIqnNjIekS+E06KhASxrkNU5vi611UsnYZlSi0VtJsH4UGV\n" + "LhnHl53aZL0YFO5mn/fzuNG/51qgk/6EFMMhaWInXX49Dia9FnnuWXwVwi6uX1Wn\n" + "7kjoHi5VtmC8ZlGEHroxX2DxEr6bhJTEpcLMnoQMqwIDAQABo2YwZDAOBgNVHQ8B\n" + "Af8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUsUI5Cb3SWB8+\n" + "gv1YLN/ABPMdxSAwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\n" + "KoZIhvcNAQELBQADggEBAJAF3E9PM1uzVL8YNdzb6fwJrxxqI2shvaMVmC1mXS+w\n" + "G0zh4v2hBZOf91l1EO0rwFD7+fxoI6hzQfMxIczh875T6vUXePKVOCOKI5wCrDad\n" + "zQbVqbFbdhsBjF4aUilOdtw2qjjs9JwPuB0VXN4/jY7m21oKEOcnpe36+7OiSPjN\n" + "xngYewCXKrSRqoj3mw+0w/+exYj3Wsush7uFssX18av78G+ehKPIVDXptOCP/N7W\n" + "8iKVNeQ2QGTnu2fzWsGUSvMGyM7yqT+h1ILaT//yQS8er511aHMLc142bD4D9VSy\n" + "DgactwPDTShK/PXqhvNey9v/sKXm4XatZvwcc8KYlW4=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECDCCAvCgAwIBAgICVIYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDQxNzEz\n" + "MDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\n" + "em9uIFJEUyBhcC1zb3V0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" + "DwAwggEKAoIBAQDUYOz1hGL42yUCrcsMSOoU8AeD/3KgZ4q7gP+vAz1WnY9K/kim\n" + "eWN/2Qqzlo3+mxSFQFyD4MyV3+CnCPnBl9Sh1G/F6kThNiJ7dEWSWBQGAB6HMDbC\n" + "BaAsmUc1UIz8sLTL3fO+S9wYhA63Wun0Fbm/Rn2yk/4WnJAaMZcEtYf6e0KNa0LM\n" + "p/kN/70/8cD3iz3dDR8zOZFpHoCtf0ek80QqTich0A9n3JLxR6g6tpwoYviVg89e\n" + "qCjQ4axxOkWWeusLeTJCcY6CkVyFvDAKvcUl1ytM5AiaUkXblE7zDFXRM4qMMRdt\n" + "lPm8d3pFxh0fRYk8bIKnpmtOpz3RIctDrZZxAgMBAAGjZjBkMA4GA1UdDwEB/wQE\n" + "AwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBT99wKJftD3jb4sHoHG\n" + "i3uGlH6W6TAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n" + "9w0BAQsFAAOCAQEAZ17hhr3dII3hUfuHQ1hPWGrpJOX/G9dLzkprEIcCidkmRYl+\n" + "hu1Pe3caRMh/17+qsoEErmnVq5jNY9X1GZL04IZH8YbHc7iRHw3HcWAdhN8633+K\n" + "jYEB2LbJ3vluCGnCejq9djDb6alOugdLMJzxOkHDhMZ6/gYbECOot+ph1tQuZXzD\n" + "tZ7prRsrcuPBChHlPjmGy8M9z8u+kF196iNSUGC4lM8vLkHM7ycc1/ZOwRq9aaTe\n" + "iOghbQQyAEe03MWCyDGtSmDfr0qEk+CHN+6hPiaL8qKt4s+V9P7DeK4iW08ny8Ox\n" + "AVS7u0OK/5+jKMAMrKwpYrBydOjTUTHScocyNw==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDDCCAvSgAwIBAgICY4kwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTMyMDEx\n" + "NDJaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\n" + "em9uIFJEUyBhcC1zb3V0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\n" + "AAOCAQ8AMIIBCgKCAQEAr5u9OuLL/OF/fBNUX2kINJLzFl4DnmrhnLuSeSnBPgbb\n" + "qddjf5EFFJBfv7IYiIWEFPDbDG5hoBwgMup5bZDbas+ZTJTotnnxVJTQ6wlhTmns\n" + "eHECcg2pqGIKGrxZfbQhlj08/4nNAPvyYCTS0bEcmQ1emuDPyvJBYDDLDU6AbCB5\n" + "6Z7YKFQPTiCBblvvNzchjLWF9IpkqiTsPHiEt21sAdABxj9ityStV3ja/W9BfgxH\n" + "wzABSTAQT6FbDwmQMo7dcFOPRX+hewQSic2Rn1XYjmNYzgEHisdUsH7eeXREAcTw\n" + "61TRvaLH8AiOWBnTEJXPAe6wYfrcSd1pD0MXpoB62wIDAQABo2YwZDAOBgNVHQ8B\n" + "Af8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUytwMiomQOgX5\n" + "Ichd+2lDWRUhkikwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\n" + "KoZIhvcNAQELBQADggEBACf6lRDpfCD7BFRqiWM45hqIzffIaysmVfr+Jr+fBTjP\n" + "uYe/ba1omSrNGG23bOcT9LJ8hkQJ9d+FxUwYyICQNWOy6ejicm4z0C3VhphbTPqj\n" + "yjpt9nG56IAcV8BcRJh4o/2IfLNzC/dVuYJV8wj7XzwlvjysenwdrJCoLadkTr1h\n" + "eIdG6Le07sB9IxrGJL9e04afk37h7c8ESGSE4E+oS4JQEi3ATq8ne1B9DQ9SasXi\n" + "IRmhNAaISDzOPdyLXi9N9V9Lwe/DHcja7hgLGYx3UqfjhLhOKwp8HtoZORixAmOI\n" + "HfILgNmwyugAbuZoCazSKKBhQ0wgO0WZ66ZKTMG8Oho=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEDDCCAvSgAwIBAgICEkYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxOTUz\n" + "NDdaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\n" + "em9uIFJEUyBhcC1zb3V0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\n" + "AAOCAQ8AMIIBCgKCAQEAufodI2Flker8q7PXZG0P0vmFSlhQDw907A6eJuF/WeMo\n" + "GHnll3b4S6nC3oRS3nGeRMHbyU2KKXDwXNb3Mheu+ox+n5eb/BJ17eoj9HbQR1cd\n" + "gEkIciiAltf8gpMMQH4anP7TD+HNFlZnP7ii3geEJB2GGXSxgSWvUzH4etL67Zmn\n" + "TpGDWQMB0T8lK2ziLCMF4XAC/8xDELN/buHCNuhDpxpPebhct0T+f6Arzsiswt2j\n" + "7OeNeLLZwIZvVwAKF7zUFjC6m7/VmTQC8nidVY559D6l0UhhU0Co/txgq3HVsMOH\n" + "PbxmQUwJEKAzQXoIi+4uZzHFZrvov/nDTNJUhC6DqwIDAQABo2YwZDAOBgNVHQ8B\n" + "Af8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwaZpaCme+EiV\n" + "M5gcjeHZSTgOn4owHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\n" + "KoZIhvcNAQELBQADggEBAAR6a2meCZuXO2TF9bGqKGtZmaah4pH2ETcEVUjkvXVz\n" + "sl+ZKbYjrun+VkcMGGKLUjS812e7eDF726ptoku9/PZZIxlJB0isC/0OyixI8N4M\n" + "NsEyvp52XN9QundTjkl362bomPnHAApeU0mRbMDRR2JdT70u6yAzGLGsUwMkoNnw\n" + "1VR4XKhXHYGWo7KMvFrZ1KcjWhubxLHxZWXRulPVtGmyWg/MvE6KF+2XMLhojhUL\n" + "+9jB3Fpn53s6KMx5tVq1x8PukHmowcZuAF8k+W4gk8Y68wIwynrdZrKRyRv6CVtR\n" + "FZ8DeJgoNZT3y/GT254VqMxxfuy2Ccb/RInd16tEvVk=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECjCCAvKgAwIBAgICEzUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAyMDUy\n" + "MjVaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\n" + "em9uIFJEUyBjYS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\n" + "ggEPADCCAQoCggEBAOxHqdcPSA2uBjsCP4DLSlqSoPuQ/X1kkJLusVRKiQE2zayB\n" + "viuCBt4VB9Qsh2rW3iYGM+usDjltGnI1iUWA5KHcvHszSMkWAOYWLiMNKTlg6LCp\n" + "XnE89tvj5dIH6U8WlDvXLdjB/h30gW9JEX7S8supsBSci2GxEzb5mRdKaDuuF/0O\n" + "qvz4YE04pua3iZ9QwmMFuTAOYzD1M72aOpj+7Ac+YLMM61qOtU+AU6MndnQkKoQi\n" + "qmUN2A9IFaqHFzRlSdXwKCKUA4otzmz+/N3vFwjb5F4DSsbsrMfjeHMo6o/nb6Nh\n" + "YDb0VJxxPee6TxSuN7CQJ2FxMlFUezcoXqwqXD0CAwEAAaNmMGQwDgYDVR0PAQH/\n" + "BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFDGGpon9WfIpsggE\n" + "CxHq8hZ7E2ESMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\n" + "SIb3DQEBCwUAA4IBAQAvpeQYEGZvoTVLgV9rd2+StPYykMsmFjWQcyn3dBTZRXC2\n" + "lKq7QhQczMAOhEaaN29ZprjQzsA2X/UauKzLR2Uyqc2qOeO9/YOl0H3qauo8C/W9\n" + "r8xqPbOCDLEXlOQ19fidXyyEPHEq5WFp8j+fTh+s8WOx2M7IuC0ANEetIZURYhSp\n" + "xl9XOPRCJxOhj7JdelhpweX0BJDNHeUFi0ClnFOws8oKQ7sQEv66d5ddxqqZ3NVv\n" + "RbCvCtEutQMOUMIuaygDlMn1anSM8N7Wndx8G6+Uy67AnhjGx7jw/0YPPxopEj6x\n" + "JXP8j0sJbcT9K/9/fPVLNT25RvQ/93T2+IQL4Ca2\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECjCCAvKgAwIBAgICV2YwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExOTM2\n" + "MjBaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\n" + "em9uIFJEUyBldS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\n" + "ggEPADCCAQoCggEBAMEx54X2pHVv86APA0RWqxxRNmdkhAyp2R1cFWumKQRofoFv\n" + "n+SPXdkpIINpMuEIGJANozdiEz7SPsrAf8WHyD93j/ZxrdQftRcIGH41xasetKGl\n" + "I67uans8d+pgJgBKGb/Z+B5m+UsIuEVekpvgpwKtmmaLFC/NCGuSsJoFsRqoa6Gh\n" + "m34W6yJoY87UatddCqLY4IIXaBFsgK9Q/wYzYLbnWM6ZZvhJ52VMtdhcdzeTHNW0\n" + "5LGuXJOF7Ahb4JkEhoo6TS2c0NxB4l4MBfBPgti+O7WjR3FfZHpt18A6Zkq6A2u6\n" + "D/oTSL6c9/3sAaFTFgMyL3wHb2YlW0BPiljZIqECAwEAAaNmMGQwDgYDVR0PAQH/\n" + "BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFOcAToAc6skWffJa\n" + "TnreaswAfrbcMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\n" + "SIb3DQEBCwUAA4IBAQA1d0Whc1QtspK496mFWfFEQNegLh0a9GWYlJm+Htcj5Nxt\n" + "DAIGXb+8xrtOZFHmYP7VLCT5Zd2C+XytqseK/+s07iAr0/EPF+O2qcyQWMN5KhgE\n" + "cXw2SwuP9FPV3i+YAm11PBVeenrmzuk9NrdHQ7TxU4v7VGhcsd2C++0EisrmquWH\n" + "mgIfmVDGxphwoES52cY6t3fbnXmTkvENvR+h3rj+fUiSz0aSo+XZUGHPgvuEKM/W\n" + "CBD9Smc9CBoBgvy7BgHRgRUmwtABZHFUIEjHI5rIr7ZvYn+6A0O6sogRfvVYtWFc\n" + "qpyrW1YX8mD0VlJ8fGKM3G+aCOsiiPKDV/Uafrm+\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECDCCAvCgAwIBAgICGAcwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIxODE5\n" + "NDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\n" + "em9uIFJEUyBldS1ub3J0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" + "DwAwggEKAoIBAQCiIYnhe4UNBbdBb/nQxl5giM0XoVHWNrYV5nB0YukA98+TPn9v\n" + "Aoj1RGYmtryjhrf01Kuv8SWO+Eom95L3zquoTFcE2gmxCfk7bp6qJJ3eHOJB+QUO\n" + "XsNRh76fwDzEF1yTeZWH49oeL2xO13EAx4PbZuZpZBttBM5zAxgZkqu4uWQczFEs\n" + "JXfla7z2fvWmGcTagX10O5C18XaFroV0ubvSyIi75ue9ykg/nlFAeB7O0Wxae88e\n" + "uhiBEFAuLYdqWnsg3459NfV8Yi1GnaitTym6VI3tHKIFiUvkSiy0DAlAGV2iiyJE\n" + "q+DsVEO4/hSINJEtII4TMtysOsYPpINqeEzRAgMBAAGjZjBkMA4GA1UdDwEB/wQE\n" + "AwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBRR0UpnbQyjnHChgmOc\n" + "hnlc0PogzTAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n" + "9w0BAQsFAAOCAQEAKJD4xVzSf4zSGTBJrmamo86jl1NHQxXUApAZuBZEc8tqC6TI\n" + "T5CeoSr9CMuVC8grYyBjXblC4OsM5NMvmsrXl/u5C9dEwtBFjo8mm53rOOIm1fxl\n" + "I1oYB/9mtO9ANWjkykuLzWeBlqDT/i7ckaKwalhLODsRDO73vRhYNjsIUGloNsKe\n" + "pxw3dzHwAZx4upSdEVG4RGCZ1D0LJ4Gw40OfD69hfkDfRVVxKGrbEzqxXRvovmDc\n" + "tKLdYZO/6REoca36v4BlgIs1CbUXJGLSXUwtg7YXGLSVBJ/U0+22iGJmBSNcoyUN\n" + "cjPFD9JQEhDDIYYKSGzIYpvslvGc4T5ISXFiuQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICYpgwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExNzMx\n" + "NDhaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyBldS13ZXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBAMk3YdSZ64iAYp6MyyKtYJtNzv7zFSnnNf6vv0FB4VnfITTMmOyZ\n" + "LXqKAT2ahZ00hXi34ewqJElgU6eUZT/QlzdIu359TEZyLVPwURflL6SWgdG01Q5X\n" + "O++7fSGcBRyIeuQWs9FJNIIqK8daF6qw0Rl5TXfu7P9dBc3zkgDXZm2DHmxGDD69\n" + "7liQUiXzoE1q2Z9cA8+jirDioJxN9av8hQt12pskLQumhlArsMIhjhHRgF03HOh5\n" + "tvi+RCfihVOxELyIRTRpTNiIwAqfZxxTWFTgfn+gijTmd0/1DseAe82aYic8JbuS\n" + "EMbrDduAWsqrnJ4GPzxHKLXX0JasCUcWyMECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPLtsq1NrwJXO13C9eHt\n" + "sLY11AGwMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQAnWBKj5xV1A1mYd0kIgDdkjCwQkiKF5bjIbGkT3YEFFbXoJlSP\n" + "0lZZ/hDaOHI8wbLT44SzOvPEEmWF9EE7SJzkvSdQrUAWR9FwDLaU427ALI3ngNHy\n" + "lGJ2hse1fvSRNbmg8Sc9GBv8oqNIBPVuw+AJzHTacZ1OkyLZrz1c1QvwvwN2a+Jd\n" + "vH0V0YIhv66llKcYDMUQJAQi4+8nbRxXWv6Gq3pvrFoorzsnkr42V3JpbhnYiK+9\n" + "nRKd4uWl62KRZjGkfMbmsqZpj2fdSWMY1UGyN1k+kDmCSWYdrTRDP0xjtIocwg+A\n" + "J116n4hV/5mbA0BaPiS2krtv17YAeHABZcvz\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICZIEwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIyMTMy\n" + "MzJaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyBldS13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBALGiwqjiF7xIjT0Sx7zB3764K2T2a1DHnAxEOr+/EIftWKxWzT3u\n" + "PFwS2eEZcnKqSdRQ+vRzonLBeNLO4z8aLjQnNbkizZMBuXGm4BqRm1Kgq3nlLDQn\n" + "7YqdijOq54SpShvR/8zsO4sgMDMmHIYAJJOJqBdaus2smRt0NobIKc0liy7759KB\n" + "6kmQ47Gg+kfIwxrQA5zlvPLeQImxSoPi9LdbRoKvu7Iot7SOa+jGhVBh3VdqndJX\n" + "7tm/saj4NE375csmMETFLAOXjat7zViMRwVorX4V6AzEg1vkzxXpA9N7qywWIT5Y\n" + "fYaq5M8i6vvLg0CzrH9fHORtnkdjdu1y+0MCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFFOhOx1yt3Z7mvGB9jBv\n" + "2ymdZwiOMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQBehqY36UGDvPVU9+vtaYGr38dBbp+LzkjZzHwKT1XJSSUc2wqM\n" + "hnCIQKilonrTIvP1vmkQi8qHPvDRtBZKqvz/AErW/ZwQdZzqYNFd+BmOXaeZWV0Q\n" + "oHtDzXmcwtP8aUQpxN0e1xkWb1E80qoy+0uuRqb/50b/R4Q5qqSfJhkn6z8nwB10\n" + "7RjLtJPrK8igxdpr3tGUzfAOyiPrIDncY7UJaL84GFp7WWAkH0WG3H8Y8DRcRXOU\n" + "mqDxDLUP3rNuow3jnGxiUY+gGX5OqaZg4f4P6QzOSmeQYs6nLpH0PiN00+oS1BbD\n" + "bpWdZEttILPI+vAYkU4QuBKKDjJL6HbSd+cn\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICJDQwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNzAz\n" + "MTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyBldS13ZXN0LTMgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBAL9bL7KE0n02DLVtlZ2PL+g/BuHpMYFq2JnE2RgompGurDIZdjmh\n" + "1pxfL3nT+QIVMubuAOy8InRfkRxfpxyjKYdfLJTPJG+jDVL+wDcPpACFVqoV7Prg\n" + "pVYEV0lc5aoYw4bSeYFhdzgim6F8iyjoPnObjll9mo4XsHzSoqJLCd0QC+VG9Fw2\n" + "q+GDRZrLRmVM2oNGDRbGpGIFg77aRxRapFZa8SnUgs2AqzuzKiprVH5i0S0M6dWr\n" + "i+kk5epmTtkiDHceX+dP/0R1NcnkCPoQ9TglyXyPdUdTPPRfKCq12dftqll+u4mV\n" + "ARdN6WFjovxax8EAP2OAUTi1afY+1JFMj+sCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFLfhrbrO5exkCVgxW0x3\n" + "Y2mAi8lNMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQAigQ5VBNGyw+OZFXwxeJEAUYaXVoP/qrhTOJ6mCE2DXUVEoJeV\n" + "SxScy/TlFA9tJXqmit8JH8VQ/xDL4ubBfeMFAIAo4WzNWDVoeVMqphVEcDWBHsI1\n" + "AETWzfsapRS9yQekOMmxg63d/nV8xewIl8aNVTHdHYXMqhhik47VrmaVEok1UQb3\n" + "O971RadLXIEbVd9tjY5bMEHm89JsZDnDEw1hQXBb67Elu64OOxoKaHBgUH8AZn/2\n" + "zFsL1ynNUjOhCSAA15pgd1vjwc0YsBbAEBPcHBWYBEyME6NLNarjOzBl4FMtATSF\n" + "wWCKRGkvqN8oxYhwR2jf2rR5Mu4DWkK5Q8Ep\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEEjCCAvqgAwIBAgIJANew34ehz5l8MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\n" + "VQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\n" + "MCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\n" + "em9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBtZS1zb3V0aC0xIFJvb3QgQ0Ew\n" + "HhcNMTkwNTEwMjE0ODI3WhcNMjQwNTA4MjE0ODI3WjCBlTELMAkGA1UEBhMCVVMx\n" + "EDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\n" + "GUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\n" + "JjAkBgNVBAMMHUFtYXpvbiBSRFMgbWUtc291dGgtMSBSb290IENBMIIBIjANBgkq\n" + "hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp7BYV88MukcY+rq0r79+C8UzkT30fEfT\n" + "aPXbx1d6M7uheGN4FMaoYmL+JE1NZPaMRIPTHhFtLSdPccInvenRDIatcXX+jgOk\n" + "UA6lnHQ98pwN0pfDUyz/Vph4jBR9LcVkBbe0zdoKKp+HGbMPRU0N2yNrog9gM5O8\n" + "gkU/3O2csJ/OFQNnj4c2NQloGMUpEmedwJMOyQQfcUyt9CvZDfIPNnheUS29jGSw\n" + "ERpJe/AENu8Pxyc72jaXQuD+FEi2Ck6lBkSlWYQFhTottAeGvVFNCzKszCntrtqd\n" + "rdYUwurYsLTXDHv9nW2hfDUQa0mhXf9gNDOBIVAZugR9NqNRNyYLHQIDAQABo2Mw\n" + "YTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54cf\n" + "DjgwBx4ycBH8+/r8WXdaiqYwHwYDVR0jBBgwFoAU54cfDjgwBx4ycBH8+/r8WXda\n" + "iqYwDQYJKoZIhvcNAQELBQADggEBAIIMTSPx/dR7jlcxggr+O6OyY49Rlap2laKA\n" + "eC/XI4ySP3vQkIFlP822U9Kh8a9s46eR0uiwV4AGLabcu0iKYfXjPkIprVCqeXV7\n" + "ny9oDtrbflyj7NcGdZLvuzSwgl9SYTJp7PVCZtZutsPYlbJrBPHwFABvAkMvRtDB\n" + "hitIg4AESDGPoCl94sYHpfDfjpUDMSrAMDUyO6DyBdZH5ryRMAs3lGtsmkkNUrso\n" + "aTW6R05681Z0mvkRdb+cdXtKOSuDZPoe2wJJIaz3IlNQNSrB5TImMYgmt6iAsFhv\n" + "3vfTSTKrZDNTJn4ybG6pq1zWExoXsktZPylJly6R3RBwV6nwqBM=\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICQ2QwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDUxODQ2\n" + "MjlaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyBzYS1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBAMMvR+ReRnOzqJzoaPipNTt1Z2VA968jlN1+SYKUrYM3No+Vpz0H\n" + "M6Tn0oYB66ByVsXiGc28ulsqX1HbHsxqDPwvQTKvO7SrmDokoAkjJgLocOLUAeld\n" + "5AwvUjxGRP6yY90NV7X786MpnYb2Il9DIIaV9HjCmPt+rjy2CZjS0UjPjCKNfB8J\n" + "bFjgW6GGscjeyGb/zFwcom5p4j0rLydbNaOr9wOyQrtt3ZQWLYGY9Zees/b8pmcc\n" + "Jt+7jstZ2UMV32OO/kIsJ4rMUn2r/uxccPwAc1IDeRSSxOrnFKhW3Cu69iB3bHp7\n" + "JbawY12g7zshE4I14sHjv3QoXASoXjx4xgMCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFI1Fc/Ql2jx+oJPgBVYq\n" + "ccgP0pQ8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQB4VVVabVp70myuYuZ3vltQIWqSUMhkaTzehMgGcHjMf9iLoZ/I\n" + "93KiFUSGnek5cRePyS9wcpp0fcBT3FvkjpUdCjVtdttJgZFhBxgTd8y26ImdDDMR\n" + "4+BUuhI5msvjL08f+Vkkpu1GQcGmyFVPFOy/UY8iefu+QyUuiBUnUuEDd49Hw0Fn\n" + "/kIPII6Vj82a2mWV/Q8e+rgN8dIRksRjKI03DEoP8lhPlsOkhdwU6Uz9Vu6NOB2Q\n" + "Ls1kbcxAc7cFSyRVJEhh12Sz9d0q/CQSTFsVJKOjSNQBQfVnLz1GwO/IieUEAr4C\n" + "jkTntH0r1LX5b/GwN4R887LvjAEdTbg1his7\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICJVUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTkxODE2\n" + "NTNaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyB1cy1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBAM3i/k2u6cqbMdcISGRvh+m+L0yaSIoOXjtpNEoIftAipTUYoMhL\n" + "InXGlQBVA4shkekxp1N7HXe1Y/iMaPEyb3n+16pf3vdjKl7kaSkIhjdUz3oVUEYt\n" + "i8Z/XeJJ9H2aEGuiZh3kHixQcZczn8cg3dA9aeeyLSEnTkl/npzLf//669Ammyhs\n" + "XcAo58yvT0D4E0D/EEHf2N7HRX7j/TlyWvw/39SW0usiCrHPKDLxByLojxLdHzso\n" + "QIp/S04m+eWn6rmD+uUiRteN1hI5ncQiA3wo4G37mHnUEKo6TtTUh+sd/ku6a8HK\n" + "glMBcgqudDI90s1OpuIAWmuWpY//8xEG2YECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPqhoWZcrVY9mU7tuemR\n" + "RBnQIj1jMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQB6zOLZ+YINEs72heHIWlPZ8c6WY8MDU+Be5w1M+BK2kpcVhCUK\n" + "PJO4nMXpgamEX8DIiaO7emsunwJzMSvavSPRnxXXTKIc0i/g1EbiDjnYX9d85DkC\n" + "E1LaAUCmCZBVi9fIe0H2r9whIh4uLWZA41oMnJx/MOmo3XyMfQoWcqaSFlMqfZM4\n" + "0rNoB/tdHLNuV4eIdaw2mlHxdWDtF4oH+HFm+2cVBUVC1jXKrFv/euRVtsTT+A6i\n" + "h2XBHKxQ1Y4HgAn0jACP2QSPEmuoQEIa57bEKEcZsBR8SDY6ZdTd2HLRIApcCOSF\n" + "MRM8CKLeF658I0XgF8D5EsYoKPsA+74Z+jDH\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECDCCAvCgAwIBAgIDAIVCMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\n" + "UzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\n" + "CgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\n" + "UzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTEzMTcw\n" + "NjQxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\n" + "c2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\n" + "U2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\n" + "YXpvbiBSRFMgdXMtZWFzdC0yIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" + "DwAwggEKAoIBAQDE+T2xYjUbxOp+pv+gRA3FO24+1zCWgXTDF1DHrh1lsPg5k7ht\n" + "2KPYzNc+Vg4E+jgPiW0BQnA6jStX5EqVh8BU60zELlxMNvpg4KumniMCZ3krtMUC\n" + "au1NF9rM7HBh+O+DYMBLK5eSIVt6lZosOb7bCi3V6wMLA8YqWSWqabkxwN4w0vXI\n" + "8lu5uXXFRemHnlNf+yA/4YtN4uaAyd0ami9+klwdkZfkrDOaiy59haOeBGL8EB/c\n" + "dbJJlguHH5CpCscs3RKtOOjEonXnKXldxarFdkMzi+aIIjQ8GyUOSAXHtQHb3gZ4\n" + "nS6Ey0CMlwkB8vUObZU9fnjKJcL5QCQqOfwvAgMBAAGjZjBkMA4GA1UdDwEB/wQE\n" + "AwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQUPuRHohPxx4VjykmH\n" + "6usGrLL1ETAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n" + "9w0BAQsFAAOCAQEAUdR9Vb3y33Yj6X6KGtuthZ08SwjImVQPtknzpajNE5jOJAh8\n" + "quvQnU9nlnMO85fVDU1Dz3lLHGJ/YG1pt1Cqq2QQ200JcWCvBRgdvH6MjHoDQpqZ\n" + "HvQ3vLgOGqCLNQKFuet9BdpsHzsctKvCVaeBqbGpeCtt3Hh/26tgx0rorPLw90A2\n" + "V8QSkZJjlcKkLa58N5CMM8Xz8KLWg3MZeT4DmlUXVCukqK2RGuP2L+aME8dOxqNv\n" + "OnOz1zrL5mR2iJoDpk8+VE/eBDmJX40IJk6jBjWoxAO/RXq+vBozuF5YHN1ujE92\n" + "tO8HItgTp37XT8bJBAiAnt5mxw+NLSqtxk2QdQ==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIECDCCAvCgAwIBAgIDAIkHMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\n" + "UzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\n" + "CgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\n" + "UzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTA2MTc0\n" + "MDIxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\n" + "c2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\n" + "U2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\n" + "YXpvbiBSRFMgdXMtd2VzdC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" + "DwAwggEKAoIBAQDD2yzbbAl77OofTghDMEf624OvU0eS9O+lsdO0QlbfUfWa1Kd6\n" + "0WkgjkLZGfSRxEHMCnrv4UPBSK/Qwn6FTjkDLgemhqBtAnplN4VsoDL+BkRX4Wwq\n" + "/dSQJE2b+0hm9w9UMVGFDEq1TMotGGTD2B71eh9HEKzKhGzqiNeGsiX4VV+LJzdH\n" + "uM23eGisNqmd4iJV0zcAZ+Gbh2zK6fqTOCvXtm7Idccv8vZZnyk1FiWl3NR4WAgK\n" + "AkvWTIoFU3Mt7dIXKKClVmvssG8WHCkd3Xcb4FHy/G756UZcq67gMMTX/9fOFM/v\n" + "l5C0+CHl33Yig1vIDZd+fXV1KZD84dEJfEvHAgMBAAGjZjBkMA4GA1UdDwEB/wQE\n" + "AwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBR+ap20kO/6A7pPxo3+\n" + "T3CfqZpQWjAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n" + "9w0BAQsFAAOCAQEAHCJky2tPjPttlDM/RIqExupBkNrnSYnOK4kr9xJ3sl8UF2DA\n" + "PAnYsjXp3rfcjN/k/FVOhxwzi3cXJF/2Tjj39Bm/OEfYTOJDNYtBwB0VVH4ffa/6\n" + "tZl87jaIkrxJcreeeHqYMnIxeN0b/kliyA+a5L2Yb0VPjt9INq34QDc1v74FNZ17\n" + "4z8nr1nzg4xsOWu0Dbjo966lm4nOYIGBRGOKEkHZRZ4mEiMgr3YLkv8gSmeitx57\n" + "Z6dVemNtUic/LVo5Iqw4n3TBS0iF2C1Q1xT/s3h+0SXZlfOWttzSluDvoMv5PvCd\n" + "pFjNn+aXLAALoihL1MJSsxydtsLjOBro5eK0Vw==\n" + "-----END CERTIFICATE-----\n",
|
|
"-----BEGIN CERTIFICATE-----\n" + "MIIEBzCCAu+gAwIBAgICUYkwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\n" + "MRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\n" + "DBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\n" + "MSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxODIx\n" + "MTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\n" + "aGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\n" + "ZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\n" + "em9uIFJEUyB1cy13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\n" + "ADCCAQoCggEBANCEZBZyu6yJQFZBJmSUZfSZd3Ui2gitczMKC4FLr0QzkbxY+cLa\n" + "uVONIOrPt4Rwi+3h/UdnUg917xao3S53XDf1TDMFEYp4U8EFPXqCn/GXBIWlU86P\n" + "PvBN+gzw3nS+aco7WXb+woTouvFVkk8FGU7J532llW8o/9ydQyDIMtdIkKTuMfho\n" + "OiNHSaNc+QXQ32TgvM9A/6q7ksUoNXGCP8hDOkSZ/YOLiI5TcdLh/aWj00ziL5bj\n" + "pvytiMZkilnc9dLY9QhRNr0vGqL0xjmWdoEXz9/OwjmCihHqJq+20MJPsvFm7D6a\n" + "2NKybR9U+ddrjb8/iyLOjURUZnj5O+2+OPcCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\n" + "AgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFEBxMBdv81xuzqcK5TVu\n" + "pHj+Aor8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\n" + "DQEBCwUAA4IBAQBZkfiVqGoJjBI37aTlLOSjLcjI75L5wBrwO39q+B4cwcmpj58P\n" + "3sivv+jhYfAGEbQnGRzjuFoyPzWnZ1DesRExX+wrmHsLLQbF2kVjLZhEJMHF9eB7\n" + "GZlTPdTzHErcnuXkwA/OqyXMpj9aghcQFuhCNguEfnROY9sAoK2PTfnTz9NJHL+Q\n" + "UpDLEJEUfc0GZMVWYhahc0x38ZnSY2SKacIPECQrTI0KpqZv/P+ijCEcMD9xmYEb\n" + "jL4en+XKS1uJpw5fIU5Sj0MxhdGstH6S84iAE5J3GM3XHklGSFwwqPYvuTXvANH6\n" + "uboynxRgSae59jIlAK6Jrr6GWMwQRbgcaAlW\n" + "-----END CERTIFICATE-----\n"
|
|
]
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/ConnectionConfig.js
|
|
var require_ConnectionConfig = __commonJS((exports, module) => {
|
|
var urlParse = __require("url").parse;
|
|
var ClientConstants = require_client();
|
|
var Charsets = require_charsets();
|
|
var SSLProfiles = null;
|
|
module.exports = ConnectionConfig;
|
|
function ConnectionConfig(options) {
|
|
if (typeof options === "string") {
|
|
options = ConnectionConfig.parseUrl(options);
|
|
}
|
|
this.host = options.host || "localhost";
|
|
this.port = options.port || 3306;
|
|
this.localAddress = options.localAddress;
|
|
this.socketPath = options.socketPath;
|
|
this.user = options.user || undefined;
|
|
this.password = options.password || undefined;
|
|
this.database = options.database;
|
|
this.connectTimeout = options.connectTimeout === undefined ? 10 * 1000 : options.connectTimeout;
|
|
this.insecureAuth = options.insecureAuth || false;
|
|
this.supportBigNumbers = options.supportBigNumbers || false;
|
|
this.bigNumberStrings = options.bigNumberStrings || false;
|
|
this.dateStrings = options.dateStrings || false;
|
|
this.debug = options.debug;
|
|
this.trace = options.trace !== false;
|
|
this.stringifyObjects = options.stringifyObjects || false;
|
|
this.timezone = options.timezone || "local";
|
|
this.flags = options.flags || "";
|
|
this.queryFormat = options.queryFormat;
|
|
this.pool = options.pool || undefined;
|
|
this.ssl = typeof options.ssl === "string" ? ConnectionConfig.getSSLProfile(options.ssl) : options.ssl || false;
|
|
this.localInfile = options.localInfile === undefined ? true : options.localInfile;
|
|
this.multipleStatements = options.multipleStatements || false;
|
|
this.typeCast = options.typeCast === undefined ? true : options.typeCast;
|
|
if (this.timezone[0] === " ") {
|
|
this.timezone = "+" + this.timezone.substr(1);
|
|
}
|
|
if (this.ssl) {
|
|
this.ssl.rejectUnauthorized = this.ssl.rejectUnauthorized !== false;
|
|
}
|
|
this.maxPacketSize = 0;
|
|
this.charsetNumber = options.charset ? ConnectionConfig.getCharsetNumber(options.charset) : options.charsetNumber || Charsets.UTF8_GENERAL_CI;
|
|
var defaultFlags = ConnectionConfig.getDefaultFlags(options);
|
|
this.clientFlags = ConnectionConfig.mergeFlags(defaultFlags, options.flags);
|
|
}
|
|
ConnectionConfig.mergeFlags = function mergeFlags(defaultFlags, userFlags) {
|
|
var allFlags = ConnectionConfig.parseFlagList(defaultFlags);
|
|
var newFlags = ConnectionConfig.parseFlagList(userFlags);
|
|
for (var flag in newFlags) {
|
|
if (allFlags[flag] !== false) {
|
|
allFlags[flag] = newFlags[flag];
|
|
}
|
|
}
|
|
var flags = 0;
|
|
for (var flag in allFlags) {
|
|
if (allFlags[flag]) {
|
|
flags |= ClientConstants["CLIENT_" + flag] || 0;
|
|
}
|
|
}
|
|
return flags;
|
|
};
|
|
ConnectionConfig.getCharsetNumber = function getCharsetNumber(charset) {
|
|
var num = Charsets[charset.toUpperCase()];
|
|
if (num === undefined) {
|
|
throw new TypeError("Unknown charset \'" + charset + "\'");
|
|
}
|
|
return num;
|
|
};
|
|
ConnectionConfig.getDefaultFlags = function getDefaultFlags(options) {
|
|
var defaultFlags = [
|
|
"-COMPRESS",
|
|
"-CONNECT_ATTRS",
|
|
"+CONNECT_WITH_DB",
|
|
"+FOUND_ROWS",
|
|
"+IGNORE_SIGPIPE",
|
|
"+IGNORE_SPACE",
|
|
"+LOCAL_FILES",
|
|
"+LONG_FLAG",
|
|
"+LONG_PASSWORD",
|
|
"+MULTI_RESULTS",
|
|
"+ODBC",
|
|
"-PLUGIN_AUTH",
|
|
"+PROTOCOL_41",
|
|
"+PS_MULTI_RESULTS",
|
|
"+RESERVED",
|
|
"+SECURE_CONNECTION",
|
|
"+TRANSACTIONS"
|
|
];
|
|
if (options && options.localInfile !== undefined && !options.localInfile) {
|
|
defaultFlags.push("-LOCAL_FILES");
|
|
}
|
|
if (options && options.multipleStatements) {
|
|
defaultFlags.push("+MULTI_STATEMENTS");
|
|
}
|
|
return defaultFlags;
|
|
};
|
|
ConnectionConfig.getSSLProfile = function getSSLProfile(name) {
|
|
if (!SSLProfiles) {
|
|
SSLProfiles = require_ssl_profiles();
|
|
}
|
|
var ssl = SSLProfiles[name];
|
|
if (ssl === undefined) {
|
|
throw new TypeError("Unknown SSL profile \'" + name + "\'");
|
|
}
|
|
return ssl;
|
|
};
|
|
ConnectionConfig.parseFlagList = function parseFlagList(flagList) {
|
|
var allFlags = Object.create(null);
|
|
if (!flagList) {
|
|
return allFlags;
|
|
}
|
|
var flags = !Array.isArray(flagList) ? String(flagList || "").toUpperCase().split(/\s*,+\s*/) : flagList;
|
|
for (var i = 0;i < flags.length; i++) {
|
|
var flag = flags[i];
|
|
var offset = 1;
|
|
var state = flag[0];
|
|
if (state === undefined) {
|
|
continue;
|
|
}
|
|
if (state !== "-" && state !== "+") {
|
|
offset = 0;
|
|
state = "+";
|
|
}
|
|
allFlags[flag.substr(offset)] = state === "+";
|
|
}
|
|
return allFlags;
|
|
};
|
|
ConnectionConfig.parseUrl = function(url) {
|
|
url = urlParse(url, true);
|
|
var options = {
|
|
host: url.hostname,
|
|
port: url.port,
|
|
database: url.pathname.substr(1)
|
|
};
|
|
if (url.auth) {
|
|
var auth = url.auth.split(":");
|
|
options.user = auth.shift();
|
|
options.password = auth.join(":");
|
|
}
|
|
if (url.query) {
|
|
for (var key in url.query) {
|
|
var value = url.query[key];
|
|
try {
|
|
options[key] = JSON.parse(value);
|
|
} catch (err) {
|
|
options[key] = value;
|
|
}
|
|
}
|
|
}
|
|
return options;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/PacketHeader.js
|
|
var require_PacketHeader = __commonJS((exports, module) => {
|
|
module.exports = PacketHeader;
|
|
function PacketHeader(length, number) {
|
|
this.length = length;
|
|
this.number = number;
|
|
}
|
|
});
|
|
|
|
// node_modules/bignumber.js/bignumber.js
|
|
var require_bignumber = __commonJS((exports, module) => {
|
|
(function(globalObject) {
|
|
var BigNumber, isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 100000000000000, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [1, 10, 100, 1000, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 10000000000, 100000000000, 1000000000000, 10000000000000], SQRT_BASE = 1e7, MAX = 1e9;
|
|
function clone(configObject) {
|
|
var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
|
|
prefix: "",
|
|
groupSize: 3,
|
|
secondaryGroupSize: 0,
|
|
groupSeparator: ",",
|
|
decimalSeparator: ".",
|
|
fractionGroupSize: 0,
|
|
fractionGroupSeparator: "\xA0",
|
|
suffix: ""
|
|
}, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
function BigNumber2(v, b) {
|
|
var alphabet, c, caseChanged, e, i, isNum, len, str, x = this;
|
|
if (!(x instanceof BigNumber2))
|
|
return new BigNumber2(v, b);
|
|
if (b == null) {
|
|
if (v && v._isBigNumber === true) {
|
|
x.s = v.s;
|
|
if (!v.c || v.e > MAX_EXP) {
|
|
x.c = x.e = null;
|
|
} else if (v.e < MIN_EXP) {
|
|
x.c = [x.e = 0];
|
|
} else {
|
|
x.e = v.e;
|
|
x.c = v.c.slice();
|
|
}
|
|
return;
|
|
}
|
|
if ((isNum = typeof v == "number") && v * 0 == 0) {
|
|
x.s = 1 / v < 0 ? (v = -v, -1) : 1;
|
|
if (v === ~~v) {
|
|
for (e = 0, i = v;i >= 10; i /= 10, e++)
|
|
;
|
|
if (e > MAX_EXP) {
|
|
x.c = x.e = null;
|
|
} else {
|
|
x.e = e;
|
|
x.c = [v];
|
|
}
|
|
return;
|
|
}
|
|
str = String(v);
|
|
} else {
|
|
if (!isNumeric.test(str = String(v)))
|
|
return parseNumeric(x, str, isNum);
|
|
x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
|
|
}
|
|
if ((e = str.indexOf(".")) > -1)
|
|
str = str.replace(".", "");
|
|
if ((i = str.search(/e/i)) > 0) {
|
|
if (e < 0)
|
|
e = i;
|
|
e += +str.slice(i + 1);
|
|
str = str.substring(0, i);
|
|
} else if (e < 0) {
|
|
e = str.length;
|
|
}
|
|
} else {
|
|
intCheck(b, 2, ALPHABET.length, "Base");
|
|
if (b == 10) {
|
|
x = new BigNumber2(v);
|
|
return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
|
|
}
|
|
str = String(v);
|
|
if (isNum = typeof v == "number") {
|
|
if (v * 0 != 0)
|
|
return parseNumeric(x, str, isNum, b);
|
|
x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
|
|
if (BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) {
|
|
throw Error(tooManyDigits + v);
|
|
}
|
|
} else {
|
|
x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
|
|
}
|
|
alphabet = ALPHABET.slice(0, b);
|
|
e = i = 0;
|
|
for (len = str.length;i < len; i++) {
|
|
if (alphabet.indexOf(c = str.charAt(i)) < 0) {
|
|
if (c == ".") {
|
|
if (i > e) {
|
|
e = len;
|
|
continue;
|
|
}
|
|
} else if (!caseChanged) {
|
|
if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {
|
|
caseChanged = true;
|
|
i = -1;
|
|
e = 0;
|
|
continue;
|
|
}
|
|
}
|
|
return parseNumeric(x, String(v), isNum, b);
|
|
}
|
|
}
|
|
isNum = false;
|
|
str = convertBase(str, b, 10, x.s);
|
|
if ((e = str.indexOf(".")) > -1)
|
|
str = str.replace(".", "");
|
|
else
|
|
e = str.length;
|
|
}
|
|
for (i = 0;str.charCodeAt(i) === 48; i++)
|
|
;
|
|
for (len = str.length;str.charCodeAt(--len) === 48; )
|
|
;
|
|
if (str = str.slice(i, ++len)) {
|
|
len -= i;
|
|
if (isNum && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
|
|
throw Error(tooManyDigits + x.s * v);
|
|
}
|
|
if ((e = e - i - 1) > MAX_EXP) {
|
|
x.c = x.e = null;
|
|
} else if (e < MIN_EXP) {
|
|
x.c = [x.e = 0];
|
|
} else {
|
|
x.e = e;
|
|
x.c = [];
|
|
i = (e + 1) % LOG_BASE;
|
|
if (e < 0)
|
|
i += LOG_BASE;
|
|
if (i < len) {
|
|
if (i)
|
|
x.c.push(+str.slice(0, i));
|
|
for (len -= LOG_BASE;i < len; ) {
|
|
x.c.push(+str.slice(i, i += LOG_BASE));
|
|
}
|
|
i = LOG_BASE - (str = str.slice(i)).length;
|
|
} else {
|
|
i -= len;
|
|
}
|
|
for (;i--; str += "0")
|
|
;
|
|
x.c.push(+str);
|
|
}
|
|
} else {
|
|
x.c = [x.e = 0];
|
|
}
|
|
}
|
|
BigNumber2.clone = clone;
|
|
BigNumber2.ROUND_UP = 0;
|
|
BigNumber2.ROUND_DOWN = 1;
|
|
BigNumber2.ROUND_CEIL = 2;
|
|
BigNumber2.ROUND_FLOOR = 3;
|
|
BigNumber2.ROUND_HALF_UP = 4;
|
|
BigNumber2.ROUND_HALF_DOWN = 5;
|
|
BigNumber2.ROUND_HALF_EVEN = 6;
|
|
BigNumber2.ROUND_HALF_CEIL = 7;
|
|
BigNumber2.ROUND_HALF_FLOOR = 8;
|
|
BigNumber2.EUCLID = 9;
|
|
BigNumber2.config = BigNumber2.set = function(obj) {
|
|
var p, v;
|
|
if (obj != null) {
|
|
if (typeof obj == "object") {
|
|
if (obj.hasOwnProperty(p = "DECIMAL_PLACES")) {
|
|
v = obj[p];
|
|
intCheck(v, 0, MAX, p);
|
|
DECIMAL_PLACES = v;
|
|
}
|
|
if (obj.hasOwnProperty(p = "ROUNDING_MODE")) {
|
|
v = obj[p];
|
|
intCheck(v, 0, 8, p);
|
|
ROUNDING_MODE = v;
|
|
}
|
|
if (obj.hasOwnProperty(p = "EXPONENTIAL_AT")) {
|
|
v = obj[p];
|
|
if (v && v.pop) {
|
|
intCheck(v[0], -MAX, 0, p);
|
|
intCheck(v[1], 0, MAX, p);
|
|
TO_EXP_NEG = v[0];
|
|
TO_EXP_POS = v[1];
|
|
} else {
|
|
intCheck(v, -MAX, MAX, p);
|
|
TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
|
|
}
|
|
}
|
|
if (obj.hasOwnProperty(p = "RANGE")) {
|
|
v = obj[p];
|
|
if (v && v.pop) {
|
|
intCheck(v[0], -MAX, -1, p);
|
|
intCheck(v[1], 1, MAX, p);
|
|
MIN_EXP = v[0];
|
|
MAX_EXP = v[1];
|
|
} else {
|
|
intCheck(v, -MAX, MAX, p);
|
|
if (v) {
|
|
MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
|
|
} else {
|
|
throw Error(bignumberError + p + " cannot be zero: " + v);
|
|
}
|
|
}
|
|
}
|
|
if (obj.hasOwnProperty(p = "CRYPTO")) {
|
|
v = obj[p];
|
|
if (v === !!v) {
|
|
if (v) {
|
|
if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
|
|
CRYPTO = v;
|
|
} else {
|
|
CRYPTO = !v;
|
|
throw Error(bignumberError + "crypto unavailable");
|
|
}
|
|
} else {
|
|
CRYPTO = v;
|
|
}
|
|
} else {
|
|
throw Error(bignumberError + p + " not true or false: " + v);
|
|
}
|
|
}
|
|
if (obj.hasOwnProperty(p = "MODULO_MODE")) {
|
|
v = obj[p];
|
|
intCheck(v, 0, 9, p);
|
|
MODULO_MODE = v;
|
|
}
|
|
if (obj.hasOwnProperty(p = "POW_PRECISION")) {
|
|
v = obj[p];
|
|
intCheck(v, 0, MAX, p);
|
|
POW_PRECISION = v;
|
|
}
|
|
if (obj.hasOwnProperty(p = "FORMAT")) {
|
|
v = obj[p];
|
|
if (typeof v == "object")
|
|
FORMAT = v;
|
|
else
|
|
throw Error(bignumberError + p + " not an object: " + v);
|
|
}
|
|
if (obj.hasOwnProperty(p = "ALPHABET")) {
|
|
v = obj[p];
|
|
if (typeof v == "string" && !/^.$|[+-.\s]|(.).*\1/.test(v)) {
|
|
ALPHABET = v;
|
|
} else {
|
|
throw Error(bignumberError + p + " invalid: " + v);
|
|
}
|
|
}
|
|
} else {
|
|
throw Error(bignumberError + "Object expected: " + obj);
|
|
}
|
|
}
|
|
return {
|
|
DECIMAL_PLACES,
|
|
ROUNDING_MODE,
|
|
EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
|
|
RANGE: [MIN_EXP, MAX_EXP],
|
|
CRYPTO,
|
|
MODULO_MODE,
|
|
POW_PRECISION,
|
|
FORMAT,
|
|
ALPHABET
|
|
};
|
|
};
|
|
BigNumber2.isBigNumber = function(v) {
|
|
if (!v || v._isBigNumber !== true)
|
|
return false;
|
|
if (!BigNumber2.DEBUG)
|
|
return true;
|
|
var i, n, c = v.c, e = v.e, s = v.s;
|
|
out:
|
|
if ({}.toString.call(c) == "[object Array]") {
|
|
if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
|
|
if (c[0] === 0) {
|
|
if (e === 0 && c.length === 1)
|
|
return true;
|
|
break out;
|
|
}
|
|
i = (e + 1) % LOG_BASE;
|
|
if (i < 1)
|
|
i += LOG_BASE;
|
|
if (String(c[0]).length == i) {
|
|
for (i = 0;i < c.length; i++) {
|
|
n = c[i];
|
|
if (n < 0 || n >= BASE || n !== mathfloor(n))
|
|
break out;
|
|
}
|
|
if (n !== 0)
|
|
return true;
|
|
}
|
|
}
|
|
} else if (c === null && e === null && (s === null || s === 1 || s === -1)) {
|
|
return true;
|
|
}
|
|
throw Error(bignumberError + "Invalid BigNumber: " + v);
|
|
};
|
|
BigNumber2.maximum = BigNumber2.max = function() {
|
|
return maxOrMin(arguments, P.lt);
|
|
};
|
|
BigNumber2.minimum = BigNumber2.min = function() {
|
|
return maxOrMin(arguments, P.gt);
|
|
};
|
|
BigNumber2.random = function() {
|
|
var pow2_53 = 9007199254740992;
|
|
var random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
|
|
return mathfloor(Math.random() * pow2_53);
|
|
} : function() {
|
|
return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
|
|
};
|
|
return function(dp) {
|
|
var a, b, e, k, v, i = 0, c = [], rand = new BigNumber2(ONE);
|
|
if (dp == null)
|
|
dp = DECIMAL_PLACES;
|
|
else
|
|
intCheck(dp, 0, MAX);
|
|
k = mathceil(dp / LOG_BASE);
|
|
if (CRYPTO) {
|
|
if (crypto.getRandomValues) {
|
|
a = crypto.getRandomValues(new Uint32Array(k *= 2));
|
|
for (;i < k; ) {
|
|
v = a[i] * 131072 + (a[i + 1] >>> 11);
|
|
if (v >= 9000000000000000) {
|
|
b = crypto.getRandomValues(new Uint32Array(2));
|
|
a[i] = b[0];
|
|
a[i + 1] = b[1];
|
|
} else {
|
|
c.push(v % 100000000000000);
|
|
i += 2;
|
|
}
|
|
}
|
|
i = k / 2;
|
|
} else if (crypto.randomBytes) {
|
|
a = crypto.randomBytes(k *= 7);
|
|
for (;i < k; ) {
|
|
v = (a[i] & 31) * 281474976710656 + a[i + 1] * 1099511627776 + a[i + 2] * 4294967296 + a[i + 3] * 16777216 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
|
|
if (v >= 9000000000000000) {
|
|
crypto.randomBytes(7).copy(a, i);
|
|
} else {
|
|
c.push(v % 100000000000000);
|
|
i += 7;
|
|
}
|
|
}
|
|
i = k / 7;
|
|
} else {
|
|
CRYPTO = false;
|
|
throw Error(bignumberError + "crypto unavailable");
|
|
}
|
|
}
|
|
if (!CRYPTO) {
|
|
for (;i < k; ) {
|
|
v = random53bitInt();
|
|
if (v < 9000000000000000)
|
|
c[i++] = v % 100000000000000;
|
|
}
|
|
}
|
|
k = c[--i];
|
|
dp %= LOG_BASE;
|
|
if (k && dp) {
|
|
v = POWS_TEN[LOG_BASE - dp];
|
|
c[i] = mathfloor(k / v) * v;
|
|
}
|
|
for (;c[i] === 0; c.pop(), i--)
|
|
;
|
|
if (i < 0) {
|
|
c = [e = 0];
|
|
} else {
|
|
for (e = -1;c[0] === 0; c.splice(0, 1), e -= LOG_BASE)
|
|
;
|
|
for (i = 1, v = c[0];v >= 10; v /= 10, i++)
|
|
;
|
|
if (i < LOG_BASE)
|
|
e -= LOG_BASE - i;
|
|
}
|
|
rand.e = e;
|
|
rand.c = c;
|
|
return rand;
|
|
};
|
|
}();
|
|
BigNumber2.sum = function() {
|
|
var i = 1, args = arguments, sum = new BigNumber2(args[0]);
|
|
for (;i < args.length; )
|
|
sum = sum.plus(args[i++]);
|
|
return sum;
|
|
};
|
|
convertBase = function() {
|
|
var decimal = "0123456789";
|
|
function toBaseOut(str, baseIn, baseOut, alphabet) {
|
|
var j, arr = [0], arrL, i = 0, len = str.length;
|
|
for (;i < len; ) {
|
|
for (arrL = arr.length;arrL--; arr[arrL] *= baseIn)
|
|
;
|
|
arr[0] += alphabet.indexOf(str.charAt(i++));
|
|
for (j = 0;j < arr.length; j++) {
|
|
if (arr[j] > baseOut - 1) {
|
|
if (arr[j + 1] == null)
|
|
arr[j + 1] = 0;
|
|
arr[j + 1] += arr[j] / baseOut | 0;
|
|
arr[j] %= baseOut;
|
|
}
|
|
}
|
|
}
|
|
return arr.reverse();
|
|
}
|
|
return function(str, baseIn, baseOut, sign, callerIsToString) {
|
|
var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
|
|
if (i >= 0) {
|
|
k = POW_PRECISION;
|
|
POW_PRECISION = 0;
|
|
str = str.replace(".", "");
|
|
y = new BigNumber2(baseIn);
|
|
x = y.pow(str.length - i);
|
|
POW_PRECISION = k;
|
|
y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, "0"), 10, baseOut, decimal);
|
|
y.e = y.c.length;
|
|
}
|
|
xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));
|
|
e = k = xc.length;
|
|
for (;xc[--k] == 0; xc.pop())
|
|
;
|
|
if (!xc[0])
|
|
return alphabet.charAt(0);
|
|
if (i < 0) {
|
|
--e;
|
|
} else {
|
|
x.c = xc;
|
|
x.e = e;
|
|
x.s = sign;
|
|
x = div(x, y, dp, rm, baseOut);
|
|
xc = x.c;
|
|
r = x.r;
|
|
e = x.e;
|
|
}
|
|
d = e + dp + 1;
|
|
i = xc[d];
|
|
k = baseOut / 2;
|
|
r = r || d < 0 || xc[d + 1] != null;
|
|
r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));
|
|
if (d < 1 || !xc[0]) {
|
|
str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
|
|
} else {
|
|
xc.length = d;
|
|
if (r) {
|
|
for (--baseOut;++xc[--d] > baseOut; ) {
|
|
xc[d] = 0;
|
|
if (!d) {
|
|
++e;
|
|
xc = [1].concat(xc);
|
|
}
|
|
}
|
|
}
|
|
for (k = xc.length;!xc[--k]; )
|
|
;
|
|
for (i = 0, str = "";i <= k; str += alphabet.charAt(xc[i++]))
|
|
;
|
|
str = toFixedPoint(str, e, alphabet.charAt(0));
|
|
}
|
|
return str;
|
|
};
|
|
}();
|
|
div = function() {
|
|
function multiply(x, k, base) {
|
|
var m, temp, xlo, xhi, carry = 0, i = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
|
|
for (x = x.slice();i--; ) {
|
|
xlo = x[i] % SQRT_BASE;
|
|
xhi = x[i] / SQRT_BASE | 0;
|
|
m = khi * xlo + xhi * klo;
|
|
temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;
|
|
carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
|
|
x[i] = temp % base;
|
|
}
|
|
if (carry)
|
|
x = [carry].concat(x);
|
|
return x;
|
|
}
|
|
function compare2(a, b, aL, bL) {
|
|
var i, cmp;
|
|
if (aL != bL) {
|
|
cmp = aL > bL ? 1 : -1;
|
|
} else {
|
|
for (i = cmp = 0;i < aL; i++) {
|
|
if (a[i] != b[i]) {
|
|
cmp = a[i] > b[i] ? 1 : -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return cmp;
|
|
}
|
|
function subtract(a, b, aL, base) {
|
|
var i = 0;
|
|
for (;aL--; ) {
|
|
a[aL] -= i;
|
|
i = a[aL] < b[aL] ? 1 : 0;
|
|
a[aL] = i * base + a[aL] - b[aL];
|
|
}
|
|
for (;!a[0] && a.length > 1; a.splice(0, 1))
|
|
;
|
|
}
|
|
return function(x, y, dp, rm, base) {
|
|
var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
|
|
if (!xc || !xc[0] || !yc || !yc[0]) {
|
|
return new BigNumber2(!x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : xc && xc[0] == 0 || !yc ? s * 0 : s / 0);
|
|
}
|
|
q = new BigNumber2(s);
|
|
qc = q.c = [];
|
|
e = x.e - y.e;
|
|
s = dp + e + 1;
|
|
if (!base) {
|
|
base = BASE;
|
|
e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
|
|
s = s / LOG_BASE | 0;
|
|
}
|
|
for (i = 0;yc[i] == (xc[i] || 0); i++)
|
|
;
|
|
if (yc[i] > (xc[i] || 0))
|
|
e--;
|
|
if (s < 0) {
|
|
qc.push(1);
|
|
more = true;
|
|
} else {
|
|
xL = xc.length;
|
|
yL = yc.length;
|
|
i = 0;
|
|
s += 2;
|
|
n = mathfloor(base / (yc[0] + 1));
|
|
if (n > 1) {
|
|
yc = multiply(yc, n, base);
|
|
xc = multiply(xc, n, base);
|
|
yL = yc.length;
|
|
xL = xc.length;
|
|
}
|
|
xi = yL;
|
|
rem = xc.slice(0, yL);
|
|
remL = rem.length;
|
|
for (;remL < yL; rem[remL++] = 0)
|
|
;
|
|
yz = yc.slice();
|
|
yz = [0].concat(yz);
|
|
yc0 = yc[0];
|
|
if (yc[1] >= base / 2)
|
|
yc0++;
|
|
do {
|
|
n = 0;
|
|
cmp = compare2(yc, rem, yL, remL);
|
|
if (cmp < 0) {
|
|
rem0 = rem[0];
|
|
if (yL != remL)
|
|
rem0 = rem0 * base + (rem[1] || 0);
|
|
n = mathfloor(rem0 / yc0);
|
|
if (n > 1) {
|
|
if (n >= base)
|
|
n = base - 1;
|
|
prod = multiply(yc, n, base);
|
|
prodL = prod.length;
|
|
remL = rem.length;
|
|
while (compare2(prod, rem, prodL, remL) == 1) {
|
|
n--;
|
|
subtract(prod, yL < prodL ? yz : yc, prodL, base);
|
|
prodL = prod.length;
|
|
cmp = 1;
|
|
}
|
|
} else {
|
|
if (n == 0) {
|
|
cmp = n = 1;
|
|
}
|
|
prod = yc.slice();
|
|
prodL = prod.length;
|
|
}
|
|
if (prodL < remL)
|
|
prod = [0].concat(prod);
|
|
subtract(rem, prod, remL, base);
|
|
remL = rem.length;
|
|
if (cmp == -1) {
|
|
while (compare2(yc, rem, yL, remL) < 1) {
|
|
n++;
|
|
subtract(rem, yL < remL ? yz : yc, remL, base);
|
|
remL = rem.length;
|
|
}
|
|
}
|
|
} else if (cmp === 0) {
|
|
n++;
|
|
rem = [0];
|
|
}
|
|
qc[i++] = n;
|
|
if (rem[0]) {
|
|
rem[remL++] = xc[xi] || 0;
|
|
} else {
|
|
rem = [xc[xi]];
|
|
remL = 1;
|
|
}
|
|
} while ((xi++ < xL || rem[0] != null) && s--);
|
|
more = rem[0] != null;
|
|
if (!qc[0])
|
|
qc.splice(0, 1);
|
|
}
|
|
if (base == BASE) {
|
|
for (i = 1, s = qc[0];s >= 10; s /= 10, i++)
|
|
;
|
|
round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
|
|
} else {
|
|
q.e = e;
|
|
q.r = +more;
|
|
}
|
|
return q;
|
|
};
|
|
}();
|
|
function format(n, i, rm, id) {
|
|
var c0, e, ne, len, str;
|
|
if (rm == null)
|
|
rm = ROUNDING_MODE;
|
|
else
|
|
intCheck(rm, 0, 8);
|
|
if (!n.c)
|
|
return n.toString();
|
|
c0 = n.c[0];
|
|
ne = n.e;
|
|
if (i == null) {
|
|
str = coeffToString(n.c);
|
|
str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
|
|
} else {
|
|
n = round(new BigNumber2(n), i, rm);
|
|
e = n.e;
|
|
str = coeffToString(n.c);
|
|
len = str.length;
|
|
if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
|
|
for (;len < i; str += "0", len++)
|
|
;
|
|
str = toExponential(str, e);
|
|
} else {
|
|
i -= ne;
|
|
str = toFixedPoint(str, e, "0");
|
|
if (e + 1 > len) {
|
|
if (--i > 0)
|
|
for (str += ".";i--; str += "0")
|
|
;
|
|
} else {
|
|
i += e - len;
|
|
if (i > 0) {
|
|
if (e + 1 == len)
|
|
str += ".";
|
|
for (;i--; str += "0")
|
|
;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return n.s < 0 && c0 ? "-" + str : str;
|
|
}
|
|
function maxOrMin(args, method) {
|
|
var n, i = 1, m = new BigNumber2(args[0]);
|
|
for (;i < args.length; i++) {
|
|
n = new BigNumber2(args[i]);
|
|
if (!n.s) {
|
|
m = n;
|
|
break;
|
|
} else if (method.call(m, n)) {
|
|
m = n;
|
|
}
|
|
}
|
|
return m;
|
|
}
|
|
function normalise(n, c, e) {
|
|
var i = 1, j = c.length;
|
|
for (;!c[--j]; c.pop())
|
|
;
|
|
for (j = c[0];j >= 10; j /= 10, i++)
|
|
;
|
|
if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {
|
|
n.c = n.e = null;
|
|
} else if (e < MIN_EXP) {
|
|
n.c = [n.e = 0];
|
|
} else {
|
|
n.e = e;
|
|
n.c = c;
|
|
}
|
|
return n;
|
|
}
|
|
parseNumeric = function() {
|
|
var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
|
|
return function(x, str, isNum, b) {
|
|
var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
|
|
if (isInfinityOrNaN.test(s)) {
|
|
x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
|
|
} else {
|
|
if (!isNum) {
|
|
s = s.replace(basePrefix, function(m, p1, p2) {
|
|
base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
|
|
return !b || b == base ? p1 : m;
|
|
});
|
|
if (b) {
|
|
base = b;
|
|
s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
|
|
}
|
|
if (str != s)
|
|
return new BigNumber2(s, base);
|
|
}
|
|
if (BigNumber2.DEBUG) {
|
|
throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
|
|
}
|
|
x.s = null;
|
|
}
|
|
x.c = x.e = null;
|
|
};
|
|
}();
|
|
function round(x, sd, rm, r) {
|
|
var d, i, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
|
|
if (xc) {
|
|
out: {
|
|
for (d = 1, k = xc[0];k >= 10; k /= 10, d++)
|
|
;
|
|
i = sd - d;
|
|
if (i < 0) {
|
|
i += LOG_BASE;
|
|
j = sd;
|
|
n = xc[ni = 0];
|
|
rd = n / pows10[d - j - 1] % 10 | 0;
|
|
} else {
|
|
ni = mathceil((i + 1) / LOG_BASE);
|
|
if (ni >= xc.length) {
|
|
if (r) {
|
|
for (;xc.length <= ni; xc.push(0))
|
|
;
|
|
n = rd = 0;
|
|
d = 1;
|
|
i %= LOG_BASE;
|
|
j = i - LOG_BASE + 1;
|
|
} else {
|
|
break out;
|
|
}
|
|
} else {
|
|
n = k = xc[ni];
|
|
for (d = 1;k >= 10; k /= 10, d++)
|
|
;
|
|
i %= LOG_BASE;
|
|
j = i - LOG_BASE + d;
|
|
rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;
|
|
}
|
|
}
|
|
r = r || sd < 0 || xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
|
|
r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
|
|
if (sd < 1 || !xc[0]) {
|
|
xc.length = 0;
|
|
if (r) {
|
|
sd -= x.e + 1;
|
|
xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
|
|
x.e = -sd || 0;
|
|
} else {
|
|
xc[0] = x.e = 0;
|
|
}
|
|
return x;
|
|
}
|
|
if (i == 0) {
|
|
xc.length = ni;
|
|
k = 1;
|
|
ni--;
|
|
} else {
|
|
xc.length = ni + 1;
|
|
k = pows10[LOG_BASE - i];
|
|
xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
|
|
}
|
|
if (r) {
|
|
for (;; ) {
|
|
if (ni == 0) {
|
|
for (i = 1, j = xc[0];j >= 10; j /= 10, i++)
|
|
;
|
|
j = xc[0] += k;
|
|
for (k = 1;j >= 10; j /= 10, k++)
|
|
;
|
|
if (i != k) {
|
|
x.e++;
|
|
if (xc[0] == BASE)
|
|
xc[0] = 1;
|
|
}
|
|
break;
|
|
} else {
|
|
xc[ni] += k;
|
|
if (xc[ni] != BASE)
|
|
break;
|
|
xc[ni--] = 0;
|
|
k = 1;
|
|
}
|
|
}
|
|
}
|
|
for (i = xc.length;xc[--i] === 0; xc.pop())
|
|
;
|
|
}
|
|
if (x.e > MAX_EXP) {
|
|
x.c = x.e = null;
|
|
} else if (x.e < MIN_EXP) {
|
|
x.c = [x.e = 0];
|
|
}
|
|
}
|
|
return x;
|
|
}
|
|
function valueOf(n) {
|
|
var str, e = n.e;
|
|
if (e === null)
|
|
return n.toString();
|
|
str = coeffToString(n.c);
|
|
str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0");
|
|
return n.s < 0 ? "-" + str : str;
|
|
}
|
|
P.absoluteValue = P.abs = function() {
|
|
var x = new BigNumber2(this);
|
|
if (x.s < 0)
|
|
x.s = 1;
|
|
return x;
|
|
};
|
|
P.comparedTo = function(y, b) {
|
|
return compare(this, new BigNumber2(y, b));
|
|
};
|
|
P.decimalPlaces = P.dp = function(dp, rm) {
|
|
var c, n, v, x = this;
|
|
if (dp != null) {
|
|
intCheck(dp, 0, MAX);
|
|
if (rm == null)
|
|
rm = ROUNDING_MODE;
|
|
else
|
|
intCheck(rm, 0, 8);
|
|
return round(new BigNumber2(x), dp + x.e + 1, rm);
|
|
}
|
|
if (!(c = x.c))
|
|
return null;
|
|
n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
|
|
if (v = c[v])
|
|
for (;v % 10 == 0; v /= 10, n--)
|
|
;
|
|
if (n < 0)
|
|
n = 0;
|
|
return n;
|
|
};
|
|
P.dividedBy = P.div = function(y, b) {
|
|
return div(this, new BigNumber2(y, b), DECIMAL_PLACES, ROUNDING_MODE);
|
|
};
|
|
P.dividedToIntegerBy = P.idiv = function(y, b) {
|
|
return div(this, new BigNumber2(y, b), 0, 1);
|
|
};
|
|
P.exponentiatedBy = P.pow = function(n, m) {
|
|
var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
|
|
n = new BigNumber2(n);
|
|
if (n.c && !n.isInteger()) {
|
|
throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
|
|
}
|
|
if (m != null)
|
|
m = new BigNumber2(m);
|
|
nIsBig = n.e > 14;
|
|
if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
|
|
y = new BigNumber2(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));
|
|
return m ? y.mod(m) : y;
|
|
}
|
|
nIsNeg = n.s < 0;
|
|
if (m) {
|
|
if (m.c ? !m.c[0] : !m.s)
|
|
return new BigNumber2(NaN);
|
|
isModExp = !nIsNeg && x.isInteger() && m.isInteger();
|
|
if (isModExp)
|
|
x = x.mod(m);
|
|
} else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 240000000 : x.c[0] < 80000000000000 || nIsBig && x.c[0] <= 99999750000000))) {
|
|
k = x.s < 0 && isOdd(n) ? -0 : 0;
|
|
if (x.e > -1)
|
|
k = 1 / k;
|
|
return new BigNumber2(nIsNeg ? 1 / k : k);
|
|
} else if (POW_PRECISION) {
|
|
k = mathceil(POW_PRECISION / LOG_BASE + 2);
|
|
}
|
|
if (nIsBig) {
|
|
half = new BigNumber2(0.5);
|
|
if (nIsNeg)
|
|
n.s = 1;
|
|
nIsOdd = isOdd(n);
|
|
} else {
|
|
i = Math.abs(+valueOf(n));
|
|
nIsOdd = i % 2;
|
|
}
|
|
y = new BigNumber2(ONE);
|
|
for (;; ) {
|
|
if (nIsOdd) {
|
|
y = y.times(x);
|
|
if (!y.c)
|
|
break;
|
|
if (k) {
|
|
if (y.c.length > k)
|
|
y.c.length = k;
|
|
} else if (isModExp) {
|
|
y = y.mod(m);
|
|
}
|
|
}
|
|
if (i) {
|
|
i = mathfloor(i / 2);
|
|
if (i === 0)
|
|
break;
|
|
nIsOdd = i % 2;
|
|
} else {
|
|
n = n.times(half);
|
|
round(n, n.e + 1, 1);
|
|
if (n.e > 14) {
|
|
nIsOdd = isOdd(n);
|
|
} else {
|
|
i = +valueOf(n);
|
|
if (i === 0)
|
|
break;
|
|
nIsOdd = i % 2;
|
|
}
|
|
}
|
|
x = x.times(x);
|
|
if (k) {
|
|
if (x.c && x.c.length > k)
|
|
x.c.length = k;
|
|
} else if (isModExp) {
|
|
x = x.mod(m);
|
|
}
|
|
}
|
|
if (isModExp)
|
|
return y;
|
|
if (nIsNeg)
|
|
y = ONE.div(y);
|
|
return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
|
|
};
|
|
P.integerValue = function(rm) {
|
|
var n = new BigNumber2(this);
|
|
if (rm == null)
|
|
rm = ROUNDING_MODE;
|
|
else
|
|
intCheck(rm, 0, 8);
|
|
return round(n, n.e + 1, rm);
|
|
};
|
|
P.isEqualTo = P.eq = function(y, b) {
|
|
return compare(this, new BigNumber2(y, b)) === 0;
|
|
};
|
|
P.isFinite = function() {
|
|
return !!this.c;
|
|
};
|
|
P.isGreaterThan = P.gt = function(y, b) {
|
|
return compare(this, new BigNumber2(y, b)) > 0;
|
|
};
|
|
P.isGreaterThanOrEqualTo = P.gte = function(y, b) {
|
|
return (b = compare(this, new BigNumber2(y, b))) === 1 || b === 0;
|
|
};
|
|
P.isInteger = function() {
|
|
return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
|
|
};
|
|
P.isLessThan = P.lt = function(y, b) {
|
|
return compare(this, new BigNumber2(y, b)) < 0;
|
|
};
|
|
P.isLessThanOrEqualTo = P.lte = function(y, b) {
|
|
return (b = compare(this, new BigNumber2(y, b))) === -1 || b === 0;
|
|
};
|
|
P.isNaN = function() {
|
|
return !this.s;
|
|
};
|
|
P.isNegative = function() {
|
|
return this.s < 0;
|
|
};
|
|
P.isPositive = function() {
|
|
return this.s > 0;
|
|
};
|
|
P.isZero = function() {
|
|
return !!this.c && this.c[0] == 0;
|
|
};
|
|
P.minus = function(y, b) {
|
|
var i, j, t, xLTy, x = this, a = x.s;
|
|
y = new BigNumber2(y, b);
|
|
b = y.s;
|
|
if (!a || !b)
|
|
return new BigNumber2(NaN);
|
|
if (a != b) {
|
|
y.s = -b;
|
|
return x.plus(y);
|
|
}
|
|
var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
|
|
if (!xe || !ye) {
|
|
if (!xc || !yc)
|
|
return xc ? (y.s = -b, y) : new BigNumber2(yc ? x : NaN);
|
|
if (!xc[0] || !yc[0]) {
|
|
return yc[0] ? (y.s = -b, y) : new BigNumber2(xc[0] ? x : ROUNDING_MODE == 3 ? -0 : 0);
|
|
}
|
|
}
|
|
xe = bitFloor(xe);
|
|
ye = bitFloor(ye);
|
|
xc = xc.slice();
|
|
if (a = xe - ye) {
|
|
if (xLTy = a < 0) {
|
|
a = -a;
|
|
t = xc;
|
|
} else {
|
|
ye = xe;
|
|
t = yc;
|
|
}
|
|
t.reverse();
|
|
for (b = a;b--; t.push(0))
|
|
;
|
|
t.reverse();
|
|
} else {
|
|
j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
|
|
for (a = b = 0;b < j; b++) {
|
|
if (xc[b] != yc[b]) {
|
|
xLTy = xc[b] < yc[b];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (xLTy)
|
|
t = xc, xc = yc, yc = t, y.s = -y.s;
|
|
b = (j = yc.length) - (i = xc.length);
|
|
if (b > 0)
|
|
for (;b--; xc[i++] = 0)
|
|
;
|
|
b = BASE - 1;
|
|
for (;j > a; ) {
|
|
if (xc[--j] < yc[j]) {
|
|
for (i = j;i && !xc[--i]; xc[i] = b)
|
|
;
|
|
--xc[i];
|
|
xc[j] += BASE;
|
|
}
|
|
xc[j] -= yc[j];
|
|
}
|
|
for (;xc[0] == 0; xc.splice(0, 1), --ye)
|
|
;
|
|
if (!xc[0]) {
|
|
y.s = ROUNDING_MODE == 3 ? -1 : 1;
|
|
y.c = [y.e = 0];
|
|
return y;
|
|
}
|
|
return normalise(y, xc, ye);
|
|
};
|
|
P.modulo = P.mod = function(y, b) {
|
|
var q, s, x = this;
|
|
y = new BigNumber2(y, b);
|
|
if (!x.c || !y.s || y.c && !y.c[0]) {
|
|
return new BigNumber2(NaN);
|
|
} else if (!y.c || x.c && !x.c[0]) {
|
|
return new BigNumber2(x);
|
|
}
|
|
if (MODULO_MODE == 9) {
|
|
s = y.s;
|
|
y.s = 1;
|
|
q = div(x, y, 0, 3);
|
|
y.s = s;
|
|
q.s *= s;
|
|
} else {
|
|
q = div(x, y, 0, MODULO_MODE);
|
|
}
|
|
y = x.minus(q.times(y));
|
|
if (!y.c[0] && MODULO_MODE == 1)
|
|
y.s = x.s;
|
|
return y;
|
|
};
|
|
P.multipliedBy = P.times = function(y, b) {
|
|
var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber2(y, b)).c;
|
|
if (!xc || !yc || !xc[0] || !yc[0]) {
|
|
if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
|
|
y.c = y.e = y.s = null;
|
|
} else {
|
|
y.s *= x.s;
|
|
if (!xc || !yc) {
|
|
y.c = y.e = null;
|
|
} else {
|
|
y.c = [0];
|
|
y.e = 0;
|
|
}
|
|
}
|
|
return y;
|
|
}
|
|
e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
|
|
y.s *= x.s;
|
|
xcL = xc.length;
|
|
ycL = yc.length;
|
|
if (xcL < ycL)
|
|
zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;
|
|
for (i = xcL + ycL, zc = [];i--; zc.push(0))
|
|
;
|
|
base = BASE;
|
|
sqrtBase = SQRT_BASE;
|
|
for (i = ycL;--i >= 0; ) {
|
|
c = 0;
|
|
ylo = yc[i] % sqrtBase;
|
|
yhi = yc[i] / sqrtBase | 0;
|
|
for (k = xcL, j = i + k;j > i; ) {
|
|
xlo = xc[--k] % sqrtBase;
|
|
xhi = xc[k] / sqrtBase | 0;
|
|
m = yhi * xlo + xhi * ylo;
|
|
xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c;
|
|
c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
|
|
zc[j--] = xlo % base;
|
|
}
|
|
zc[j] = c;
|
|
}
|
|
if (c) {
|
|
++e;
|
|
} else {
|
|
zc.splice(0, 1);
|
|
}
|
|
return normalise(y, zc, e);
|
|
};
|
|
P.negated = function() {
|
|
var x = new BigNumber2(this);
|
|
x.s = -x.s || null;
|
|
return x;
|
|
};
|
|
P.plus = function(y, b) {
|
|
var t, x = this, a = x.s;
|
|
y = new BigNumber2(y, b);
|
|
b = y.s;
|
|
if (!a || !b)
|
|
return new BigNumber2(NaN);
|
|
if (a != b) {
|
|
y.s = -b;
|
|
return x.minus(y);
|
|
}
|
|
var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
|
|
if (!xe || !ye) {
|
|
if (!xc || !yc)
|
|
return new BigNumber2(a / 0);
|
|
if (!xc[0] || !yc[0])
|
|
return yc[0] ? y : new BigNumber2(xc[0] ? x : a * 0);
|
|
}
|
|
xe = bitFloor(xe);
|
|
ye = bitFloor(ye);
|
|
xc = xc.slice();
|
|
if (a = xe - ye) {
|
|
if (a > 0) {
|
|
ye = xe;
|
|
t = yc;
|
|
} else {
|
|
a = -a;
|
|
t = xc;
|
|
}
|
|
t.reverse();
|
|
for (;a--; t.push(0))
|
|
;
|
|
t.reverse();
|
|
}
|
|
a = xc.length;
|
|
b = yc.length;
|
|
if (a - b < 0)
|
|
t = yc, yc = xc, xc = t, b = a;
|
|
for (a = 0;b; ) {
|
|
a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
|
|
xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
|
|
}
|
|
if (a) {
|
|
xc = [a].concat(xc);
|
|
++ye;
|
|
}
|
|
return normalise(y, xc, ye);
|
|
};
|
|
P.precision = P.sd = function(sd, rm) {
|
|
var c, n, v, x = this;
|
|
if (sd != null && sd !== !!sd) {
|
|
intCheck(sd, 1, MAX);
|
|
if (rm == null)
|
|
rm = ROUNDING_MODE;
|
|
else
|
|
intCheck(rm, 0, 8);
|
|
return round(new BigNumber2(x), sd, rm);
|
|
}
|
|
if (!(c = x.c))
|
|
return null;
|
|
v = c.length - 1;
|
|
n = v * LOG_BASE + 1;
|
|
if (v = c[v]) {
|
|
for (;v % 10 == 0; v /= 10, n--)
|
|
;
|
|
for (v = c[0];v >= 10; v /= 10, n++)
|
|
;
|
|
}
|
|
if (sd && x.e + 1 > n)
|
|
n = x.e + 1;
|
|
return n;
|
|
};
|
|
P.shiftedBy = function(k) {
|
|
intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
|
|
return this.times("1e" + k);
|
|
};
|
|
P.squareRoot = P.sqrt = function() {
|
|
var m, n, r, rep, t, x = this, c = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
|
|
if (s !== 1 || !c || !c[0]) {
|
|
return new BigNumber2(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
|
|
}
|
|
s = Math.sqrt(+valueOf(x));
|
|
if (s == 0 || s == 1 / 0) {
|
|
n = coeffToString(c);
|
|
if ((n.length + e) % 2 == 0)
|
|
n += "0";
|
|
s = Math.sqrt(+n);
|
|
e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
|
|
if (s == 1 / 0) {
|
|
n = "1e" + e;
|
|
} else {
|
|
n = s.toExponential();
|
|
n = n.slice(0, n.indexOf("e") + 1) + e;
|
|
}
|
|
r = new BigNumber2(n);
|
|
} else {
|
|
r = new BigNumber2(s + "");
|
|
}
|
|
if (r.c[0]) {
|
|
e = r.e;
|
|
s = e + dp;
|
|
if (s < 3)
|
|
s = 0;
|
|
for (;; ) {
|
|
t = r;
|
|
r = half.times(t.plus(div(x, t, dp, 1)));
|
|
if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {
|
|
if (r.e < e)
|
|
--s;
|
|
n = n.slice(s - 3, s + 1);
|
|
if (n == "9999" || !rep && n == "4999") {
|
|
if (!rep) {
|
|
round(t, t.e + DECIMAL_PLACES + 2, 0);
|
|
if (t.times(t).eq(x)) {
|
|
r = t;
|
|
break;
|
|
}
|
|
}
|
|
dp += 4;
|
|
s += 4;
|
|
rep = 1;
|
|
} else {
|
|
if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
|
|
round(r, r.e + DECIMAL_PLACES + 2, 1);
|
|
m = !r.times(r).eq(x);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
|
|
};
|
|
P.toExponential = function(dp, rm) {
|
|
if (dp != null) {
|
|
intCheck(dp, 0, MAX);
|
|
dp++;
|
|
}
|
|
return format(this, dp, rm, 1);
|
|
};
|
|
P.toFixed = function(dp, rm) {
|
|
if (dp != null) {
|
|
intCheck(dp, 0, MAX);
|
|
dp = dp + this.e + 1;
|
|
}
|
|
return format(this, dp, rm);
|
|
};
|
|
P.toFormat = function(dp, rm, format2) {
|
|
var str, x = this;
|
|
if (format2 == null) {
|
|
if (dp != null && rm && typeof rm == "object") {
|
|
format2 = rm;
|
|
rm = null;
|
|
} else if (dp && typeof dp == "object") {
|
|
format2 = dp;
|
|
dp = rm = null;
|
|
} else {
|
|
format2 = FORMAT;
|
|
}
|
|
} else if (typeof format2 != "object") {
|
|
throw Error(bignumberError + "Argument not an object: " + format2);
|
|
}
|
|
str = x.toFixed(dp, rm);
|
|
if (x.c) {
|
|
var i, arr = str.split("."), g1 = +format2.groupSize, g2 = +format2.secondaryGroupSize, groupSeparator = format2.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
|
|
if (g2)
|
|
i = g1, g1 = g2, g2 = i, len -= i;
|
|
if (g1 > 0 && len > 0) {
|
|
i = len % g1 || g1;
|
|
intPart = intDigits.substr(0, i);
|
|
for (;i < len; i += g1)
|
|
intPart += groupSeparator + intDigits.substr(i, g1);
|
|
if (g2 > 0)
|
|
intPart += groupSeparator + intDigits.slice(i);
|
|
if (isNeg)
|
|
intPart = "-" + intPart;
|
|
}
|
|
str = fractionPart ? intPart + (format2.decimalSeparator || "") + ((g2 = +format2.fractionGroupSize) ? fractionPart.replace(new RegExp("\\d{" + g2 + "}\\B", "g"), "$&" + (format2.fractionGroupSeparator || "")) : fractionPart) : intPart;
|
|
}
|
|
return (format2.prefix || "") + str + (format2.suffix || "");
|
|
};
|
|
P.toFraction = function(md) {
|
|
var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s, x = this, xc = x.c;
|
|
if (md != null) {
|
|
n = new BigNumber2(md);
|
|
if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
|
|
throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
|
|
}
|
|
}
|
|
if (!xc)
|
|
return new BigNumber2(x);
|
|
d = new BigNumber2(ONE);
|
|
n1 = d0 = new BigNumber2(ONE);
|
|
d1 = n0 = new BigNumber2(ONE);
|
|
s = coeffToString(xc);
|
|
e = d.e = s.length - x.e - 1;
|
|
d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
|
|
md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;
|
|
exp = MAX_EXP;
|
|
MAX_EXP = 1 / 0;
|
|
n = new BigNumber2(s);
|
|
n0.c[0] = 0;
|
|
for (;; ) {
|
|
q = div(n, d, 0, 1);
|
|
d2 = d0.plus(q.times(d1));
|
|
if (d2.comparedTo(md) == 1)
|
|
break;
|
|
d0 = d1;
|
|
d1 = d2;
|
|
n1 = n0.plus(q.times(d2 = n1));
|
|
n0 = d2;
|
|
d = n.minus(q.times(d2 = d));
|
|
n = d2;
|
|
}
|
|
d2 = div(md.minus(d0), d1, 0, 1);
|
|
n0 = n0.plus(d2.times(n1));
|
|
d0 = d0.plus(d2.times(d1));
|
|
n0.s = n1.s = x.s;
|
|
e = e * 2;
|
|
r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];
|
|
MAX_EXP = exp;
|
|
return r;
|
|
};
|
|
P.toNumber = function() {
|
|
return +valueOf(this);
|
|
};
|
|
P.toPrecision = function(sd, rm) {
|
|
if (sd != null)
|
|
intCheck(sd, 1, MAX);
|
|
return format(this, sd, rm, 2);
|
|
};
|
|
P.toString = function(b) {
|
|
var str, n = this, s = n.s, e = n.e;
|
|
if (e === null) {
|
|
if (s) {
|
|
str = "Infinity";
|
|
if (s < 0)
|
|
str = "-" + str;
|
|
} else {
|
|
str = "NaN";
|
|
}
|
|
} else {
|
|
if (b == null) {
|
|
str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
|
|
} else if (b === 10) {
|
|
n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
|
|
str = toFixedPoint(coeffToString(n.c), n.e, "0");
|
|
} else {
|
|
intCheck(b, 2, ALPHABET.length, "Base");
|
|
str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, true);
|
|
}
|
|
if (s < 0 && n.c[0])
|
|
str = "-" + str;
|
|
}
|
|
return str;
|
|
};
|
|
P.valueOf = P.toJSON = function() {
|
|
return valueOf(this);
|
|
};
|
|
P._isBigNumber = true;
|
|
if (configObject != null)
|
|
BigNumber2.set(configObject);
|
|
return BigNumber2;
|
|
}
|
|
function bitFloor(n) {
|
|
var i = n | 0;
|
|
return n > 0 || n === i ? i : i - 1;
|
|
}
|
|
function coeffToString(a) {
|
|
var s, z, i = 1, j = a.length, r = a[0] + "";
|
|
for (;i < j; ) {
|
|
s = a[i++] + "";
|
|
z = LOG_BASE - s.length;
|
|
for (;z--; s = "0" + s)
|
|
;
|
|
r += s;
|
|
}
|
|
for (j = r.length;r.charCodeAt(--j) === 48; )
|
|
;
|
|
return r.slice(0, j + 1 || 1);
|
|
}
|
|
function compare(x, y) {
|
|
var a, b, xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;
|
|
if (!i || !j)
|
|
return null;
|
|
a = xc && !xc[0];
|
|
b = yc && !yc[0];
|
|
if (a || b)
|
|
return a ? b ? 0 : -j : i;
|
|
if (i != j)
|
|
return i;
|
|
a = i < 0;
|
|
b = k == l;
|
|
if (!xc || !yc)
|
|
return b ? 0 : !xc ^ a ? 1 : -1;
|
|
if (!b)
|
|
return k > l ^ a ? 1 : -1;
|
|
j = (k = xc.length) < (l = yc.length) ? k : l;
|
|
for (i = 0;i < j; i++)
|
|
if (xc[i] != yc[i])
|
|
return xc[i] > yc[i] ^ a ? 1 : -1;
|
|
return k == l ? 0 : k > l ^ a ? 1 : -1;
|
|
}
|
|
function intCheck(n, min, max, name) {
|
|
if (n < min || n > max || n !== mathfloor(n)) {
|
|
throw Error(bignumberError + (name || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
|
|
}
|
|
}
|
|
function isOdd(n) {
|
|
var k = n.c.length - 1;
|
|
return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
|
|
}
|
|
function toExponential(str, e) {
|
|
return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
|
|
}
|
|
function toFixedPoint(str, e, z) {
|
|
var len, zs;
|
|
if (e < 0) {
|
|
for (zs = z + ".";++e; zs += z)
|
|
;
|
|
str = zs + str;
|
|
} else {
|
|
len = str.length;
|
|
if (++e > len) {
|
|
for (zs = z, e -= len;--e; zs += z)
|
|
;
|
|
str += zs;
|
|
} else if (e < len) {
|
|
str = str.slice(0, e) + "." + str.slice(e);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
BigNumber = clone();
|
|
BigNumber["default"] = BigNumber.BigNumber = BigNumber;
|
|
if (typeof define == "function" && define.amd) {
|
|
define(function() {
|
|
return BigNumber;
|
|
});
|
|
} else if (typeof module != "undefined" && module.exports) {
|
|
module.exports = BigNumber;
|
|
} else {
|
|
if (!globalObject) {
|
|
globalObject = typeof self != "undefined" && self ? self : window;
|
|
}
|
|
globalObject.BigNumber = BigNumber;
|
|
}
|
|
})(exports);
|
|
});
|
|
|
|
// node_modules/safe-buffer/index.js
|
|
var require_safe_buffer = __commonJS((exports, module) => {
|
|
var buffer = __require("buffer");
|
|
var Buffer2 = buffer.Buffer;
|
|
function copyProps(src, dst) {
|
|
for (var key in src) {
|
|
dst[key] = src[key];
|
|
}
|
|
}
|
|
if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
|
|
module.exports = buffer;
|
|
} else {
|
|
copyProps(buffer, exports);
|
|
exports.Buffer = SafeBuffer;
|
|
}
|
|
function SafeBuffer(arg, encodingOrOffset, length) {
|
|
return Buffer2(arg, encodingOrOffset, length);
|
|
}
|
|
copyProps(Buffer2, SafeBuffer);
|
|
SafeBuffer.from = function(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
throw new TypeError("Argument must not be a number");
|
|
}
|
|
return Buffer2(arg, encodingOrOffset, length);
|
|
};
|
|
SafeBuffer.alloc = function(size, fill, encoding) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
var buf = Buffer2(size);
|
|
if (fill !== undefined) {
|
|
if (typeof encoding === "string") {
|
|
buf.fill(fill, encoding);
|
|
} else {
|
|
buf.fill(fill);
|
|
}
|
|
} else {
|
|
buf.fill(0);
|
|
}
|
|
return buf;
|
|
};
|
|
SafeBuffer.allocUnsafe = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return Buffer2(size);
|
|
};
|
|
SafeBuffer.allocUnsafeSlow = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return buffer.SlowBuffer(size);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/BufferList.js
|
|
var require_BufferList = __commonJS((exports, module) => {
|
|
module.exports = BufferList;
|
|
function BufferList() {
|
|
this.bufs = [];
|
|
this.size = 0;
|
|
}
|
|
BufferList.prototype.shift = function shift() {
|
|
var buf = this.bufs.shift();
|
|
if (buf) {
|
|
this.size -= buf.length;
|
|
}
|
|
return buf;
|
|
};
|
|
BufferList.prototype.push = function push(buf) {
|
|
if (!buf || !buf.length) {
|
|
return;
|
|
}
|
|
this.bufs.push(buf);
|
|
this.size += buf.length;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/Parser.js
|
|
var require_Parser = __commonJS((exports, module) => {
|
|
var PacketHeader = require_PacketHeader();
|
|
var BigNumber = require_bignumber();
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var BufferList = require_BufferList();
|
|
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
|
var MUL_32BIT = Math.pow(2, 32);
|
|
var PACKET_HEADER_LENGTH = 4;
|
|
module.exports = Parser;
|
|
function Parser(options) {
|
|
options = options || {};
|
|
this._supportBigNumbers = options.config && options.config.supportBigNumbers;
|
|
this._buffer = Buffer2.alloc(0);
|
|
this._nextBuffers = new BufferList;
|
|
this._longPacketBuffers = new BufferList;
|
|
this._offset = 0;
|
|
this._packetEnd = null;
|
|
this._packetHeader = null;
|
|
this._packetOffset = null;
|
|
this._onError = options.onError || function(err) {
|
|
throw err;
|
|
};
|
|
this._onPacket = options.onPacket || function() {
|
|
};
|
|
this._nextPacketNumber = 0;
|
|
this._encoding = "utf-8";
|
|
this._paused = false;
|
|
}
|
|
Parser.prototype.write = function write(chunk) {
|
|
this._nextBuffers.push(chunk);
|
|
while (!this._paused) {
|
|
var packetHeader = this._tryReadPacketHeader();
|
|
if (!packetHeader) {
|
|
break;
|
|
}
|
|
if (!this._combineNextBuffers(packetHeader.length)) {
|
|
break;
|
|
}
|
|
this._parsePacket(packetHeader);
|
|
}
|
|
};
|
|
Parser.prototype.append = function append(chunk) {
|
|
if (!chunk || chunk.length === 0) {
|
|
return;
|
|
}
|
|
var sliceEnd = this._buffer.length;
|
|
var sliceStart = this._packetOffset === null ? this._offset : this._packetOffset;
|
|
var sliceLength = sliceEnd - sliceStart;
|
|
var buffer = null;
|
|
var chunks = !(chunk instanceof Array || Array.isArray(chunk)) ? [chunk] : chunk;
|
|
var length = 0;
|
|
var offset = 0;
|
|
for (var i = 0;i < chunks.length; i++) {
|
|
length += chunks[i].length;
|
|
}
|
|
if (sliceLength !== 0) {
|
|
buffer = Buffer2.allocUnsafe(sliceLength + length);
|
|
offset = 0;
|
|
offset += this._buffer.copy(buffer, 0, sliceStart, sliceEnd);
|
|
for (var i = 0;i < chunks.length; i++) {
|
|
offset += chunks[i].copy(buffer, offset);
|
|
}
|
|
} else if (chunks.length > 1) {
|
|
buffer = Buffer2.allocUnsafe(length);
|
|
offset = 0;
|
|
for (var i = 0;i < chunks.length; i++) {
|
|
offset += chunks[i].copy(buffer, offset);
|
|
}
|
|
} else {
|
|
buffer = chunks[0];
|
|
}
|
|
this._buffer = buffer;
|
|
this._offset = this._offset - sliceStart;
|
|
this._packetEnd = this._packetEnd !== null ? this._packetEnd - sliceStart : null;
|
|
this._packetOffset = this._packetOffset !== null ? this._packetOffset - sliceStart : null;
|
|
};
|
|
Parser.prototype.pause = function() {
|
|
this._paused = true;
|
|
};
|
|
Parser.prototype.resume = function() {
|
|
this._paused = false;
|
|
process.nextTick(this.write.bind(this));
|
|
};
|
|
Parser.prototype.peak = function peak(offset) {
|
|
return this._buffer[this._offset + (offset >>> 0)];
|
|
};
|
|
Parser.prototype.parseUnsignedNumber = function parseUnsignedNumber(bytes) {
|
|
if (bytes === 1) {
|
|
return this._buffer[this._offset++];
|
|
}
|
|
var buffer = this._buffer;
|
|
var offset = this._offset + bytes - 1;
|
|
var value = 0;
|
|
if (bytes > 4) {
|
|
var err = new Error("parseUnsignedNumber: Supports only up to 4 bytes");
|
|
err.offset = this._offset - this._packetOffset - 1;
|
|
err.code = "PARSER_UNSIGNED_TOO_LONG";
|
|
throw err;
|
|
}
|
|
while (offset >= this._offset) {
|
|
value = (value << 8 | buffer[offset]) >>> 0;
|
|
offset--;
|
|
}
|
|
this._offset += bytes;
|
|
return value;
|
|
};
|
|
Parser.prototype.parseLengthCodedString = function() {
|
|
var length = this.parseLengthCodedNumber();
|
|
if (length === null) {
|
|
return null;
|
|
}
|
|
return this.parseString(length);
|
|
};
|
|
Parser.prototype.parseLengthCodedBuffer = function() {
|
|
var length = this.parseLengthCodedNumber();
|
|
if (length === null) {
|
|
return null;
|
|
}
|
|
return this.parseBuffer(length);
|
|
};
|
|
Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
|
|
if (this._offset >= this._buffer.length) {
|
|
var err = new Error("Parser: read past end");
|
|
err.offset = this._offset - this._packetOffset;
|
|
err.code = "PARSER_READ_PAST_END";
|
|
throw err;
|
|
}
|
|
var bits = this._buffer[this._offset++];
|
|
if (bits <= 250) {
|
|
return bits;
|
|
}
|
|
switch (bits) {
|
|
case 251:
|
|
return null;
|
|
case 252:
|
|
return this.parseUnsignedNumber(2);
|
|
case 253:
|
|
return this.parseUnsignedNumber(3);
|
|
case 254:
|
|
break;
|
|
default:
|
|
var err = new Error("Unexpected first byte" + (bits ? ": 0x" + bits.toString(16) : ""));
|
|
err.offset = this._offset - this._packetOffset - 1;
|
|
err.code = "PARSER_BAD_LENGTH_BYTE";
|
|
throw err;
|
|
}
|
|
var low = this.parseUnsignedNumber(4);
|
|
var high = this.parseUnsignedNumber(4);
|
|
var value;
|
|
if (high >>> 21) {
|
|
value = BigNumber(MUL_32BIT).times(high).plus(low).toString();
|
|
if (this._supportBigNumbers) {
|
|
return value;
|
|
}
|
|
var err = new Error("parseLengthCodedNumber: JS precision range exceeded, " + 'number is >= 53 bit: "' + value + '"');
|
|
err.offset = this._offset - this._packetOffset - 8;
|
|
err.code = "PARSER_JS_PRECISION_RANGE_EXCEEDED";
|
|
throw err;
|
|
}
|
|
value = low + MUL_32BIT * high;
|
|
return value;
|
|
};
|
|
Parser.prototype.parseFiller = function(length) {
|
|
return this.parseBuffer(length);
|
|
};
|
|
Parser.prototype.parseNullTerminatedBuffer = function() {
|
|
var end = this._nullByteOffset();
|
|
var value = this._buffer.slice(this._offset, end);
|
|
this._offset = end + 1;
|
|
return value;
|
|
};
|
|
Parser.prototype.parseNullTerminatedString = function() {
|
|
var end = this._nullByteOffset();
|
|
var value = this._buffer.toString(this._encoding, this._offset, end);
|
|
this._offset = end + 1;
|
|
return value;
|
|
};
|
|
Parser.prototype._nullByteOffset = function() {
|
|
var offset = this._offset;
|
|
while (this._buffer[offset] !== 0) {
|
|
offset++;
|
|
if (offset >= this._buffer.length) {
|
|
var err = new Error("Offset of null terminated string not found.");
|
|
err.offset = this._offset - this._packetOffset;
|
|
err.code = "PARSER_MISSING_NULL_BYTE";
|
|
throw err;
|
|
}
|
|
}
|
|
return offset;
|
|
};
|
|
Parser.prototype.parsePacketTerminatedBuffer = function parsePacketTerminatedBuffer() {
|
|
var length = this._packetEnd - this._offset;
|
|
return this.parseBuffer(length);
|
|
};
|
|
Parser.prototype.parsePacketTerminatedString = function() {
|
|
var length = this._packetEnd - this._offset;
|
|
return this.parseString(length);
|
|
};
|
|
Parser.prototype.parseBuffer = function(length) {
|
|
var response = Buffer2.alloc(length);
|
|
this._buffer.copy(response, 0, this._offset, this._offset + length);
|
|
this._offset += length;
|
|
return response;
|
|
};
|
|
Parser.prototype.parseString = function(length) {
|
|
var offset = this._offset;
|
|
var end = offset + length;
|
|
var value = this._buffer.toString(this._encoding, offset, end);
|
|
this._offset = end;
|
|
return value;
|
|
};
|
|
Parser.prototype.parseGeometryValue = function() {
|
|
var buffer = this.parseLengthCodedBuffer();
|
|
var offset = 4;
|
|
if (buffer === null || !buffer.length) {
|
|
return null;
|
|
}
|
|
function parseGeometry() {
|
|
var result = null;
|
|
var byteOrder = buffer.readUInt8(offset);
|
|
offset += 1;
|
|
var wkbType = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
|
offset += 4;
|
|
switch (wkbType) {
|
|
case 1:
|
|
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
result = { x, y };
|
|
break;
|
|
case 2:
|
|
var numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
|
offset += 4;
|
|
result = [];
|
|
for (var i = numPoints;i > 0; i--) {
|
|
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
result.push({ x, y });
|
|
}
|
|
break;
|
|
case 3:
|
|
var numRings = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
|
offset += 4;
|
|
result = [];
|
|
for (var i = numRings;i > 0; i--) {
|
|
var numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
|
offset += 4;
|
|
var line = [];
|
|
for (var j = numPoints;j > 0; j--) {
|
|
var x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
var y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
|
|
offset += 8;
|
|
line.push({ x, y });
|
|
}
|
|
result.push(line);
|
|
}
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
var num = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
|
offset += 4;
|
|
var result = [];
|
|
for (var i = num;i > 0; i--) {
|
|
result.push(parseGeometry());
|
|
}
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
return parseGeometry();
|
|
};
|
|
Parser.prototype.reachedPacketEnd = function() {
|
|
return this._offset === this._packetEnd;
|
|
};
|
|
Parser.prototype.incrementPacketNumber = function() {
|
|
var currentPacketNumber = this._nextPacketNumber;
|
|
this._nextPacketNumber = (this._nextPacketNumber + 1) % 256;
|
|
return currentPacketNumber;
|
|
};
|
|
Parser.prototype.resetPacketNumber = function() {
|
|
this._nextPacketNumber = 0;
|
|
};
|
|
Parser.prototype.packetLength = function packetLength() {
|
|
if (!this._packetHeader) {
|
|
return null;
|
|
}
|
|
return this._packetHeader.length + this._longPacketBuffers.size;
|
|
};
|
|
Parser.prototype._combineNextBuffers = function _combineNextBuffers(bytes) {
|
|
var length = this._buffer.length - this._offset;
|
|
if (length >= bytes) {
|
|
return true;
|
|
}
|
|
if (length + this._nextBuffers.size < bytes) {
|
|
return false;
|
|
}
|
|
var buffers = [];
|
|
var bytesNeeded = bytes - length;
|
|
while (bytesNeeded > 0) {
|
|
var buffer = this._nextBuffers.shift();
|
|
buffers.push(buffer);
|
|
bytesNeeded -= buffer.length;
|
|
}
|
|
this.append(buffers);
|
|
return true;
|
|
};
|
|
Parser.prototype._combineLongPacketBuffers = function _combineLongPacketBuffers() {
|
|
if (!this._longPacketBuffers.size) {
|
|
return;
|
|
}
|
|
var remainingBytes = this._buffer.length - this._offset;
|
|
var trailingPacketBytes = this._buffer.length - this._packetEnd;
|
|
var buf = null;
|
|
var buffer = Buffer2.allocUnsafe(remainingBytes + this._longPacketBuffers.size);
|
|
var offset = 0;
|
|
while (buf = this._longPacketBuffers.shift()) {
|
|
offset += buf.copy(buffer, offset);
|
|
}
|
|
this._buffer.copy(buffer, offset, this._offset);
|
|
this._buffer = buffer;
|
|
this._offset = 0;
|
|
this._packetEnd = this._buffer.length - trailingPacketBytes;
|
|
this._packetOffset = 0;
|
|
};
|
|
Parser.prototype._parsePacket = function _parsePacket(packetHeader) {
|
|
this._packetEnd = this._offset + packetHeader.length;
|
|
this._packetOffset = this._offset;
|
|
if (packetHeader.length === MAX_PACKET_LENGTH) {
|
|
this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
|
|
this._advanceToNextPacket();
|
|
return;
|
|
}
|
|
this._combineLongPacketBuffers();
|
|
var hadException = true;
|
|
try {
|
|
this._onPacket(packetHeader);
|
|
hadException = false;
|
|
} catch (err) {
|
|
if (!err || typeof err.code !== "string" || err.code.substr(0, 7) !== "PARSER_") {
|
|
throw err;
|
|
}
|
|
this._onError(err);
|
|
hadException = false;
|
|
} finally {
|
|
this._advanceToNextPacket();
|
|
if (hadException) {
|
|
process.nextTick(this.write.bind(this));
|
|
}
|
|
}
|
|
};
|
|
Parser.prototype._tryReadPacketHeader = function _tryReadPacketHeader() {
|
|
if (this._packetHeader) {
|
|
return this._packetHeader;
|
|
}
|
|
if (!this._combineNextBuffers(PACKET_HEADER_LENGTH)) {
|
|
return null;
|
|
}
|
|
this._packetHeader = new PacketHeader(this.parseUnsignedNumber(3), this.parseUnsignedNumber(1));
|
|
if (this._packetHeader.number !== this._nextPacketNumber) {
|
|
var err = new Error("Packets out of order. Got: " + this._packetHeader.number + " " + "Expected: " + this._nextPacketNumber);
|
|
err.code = "PROTOCOL_PACKETS_OUT_OF_ORDER";
|
|
err.fatal = true;
|
|
this._onError(err);
|
|
}
|
|
this.incrementPacketNumber();
|
|
return this._packetHeader;
|
|
};
|
|
Parser.prototype._advanceToNextPacket = function() {
|
|
this._offset = this._packetEnd;
|
|
this._packetHeader = null;
|
|
this._packetEnd = null;
|
|
this._packetOffset = null;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/AuthSwitchRequestPacket.js
|
|
var require_AuthSwitchRequestPacket = __commonJS((exports, module) => {
|
|
module.exports = AuthSwitchRequestPacket;
|
|
function AuthSwitchRequestPacket(options) {
|
|
options = options || {};
|
|
this.status = 254;
|
|
this.authMethodName = options.authMethodName;
|
|
this.authMethodData = options.authMethodData;
|
|
}
|
|
AuthSwitchRequestPacket.prototype.parse = function parse(parser) {
|
|
this.status = parser.parseUnsignedNumber(1);
|
|
this.authMethodName = parser.parseNullTerminatedString();
|
|
this.authMethodData = parser.parsePacketTerminatedBuffer();
|
|
};
|
|
AuthSwitchRequestPacket.prototype.write = function write(writer) {
|
|
writer.writeUnsignedNumber(1, this.status);
|
|
writer.writeNullTerminatedString(this.authMethodName);
|
|
writer.writeBuffer(this.authMethodData);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/AuthSwitchResponsePacket.js
|
|
var require_AuthSwitchResponsePacket = __commonJS((exports, module) => {
|
|
module.exports = AuthSwitchResponsePacket;
|
|
function AuthSwitchResponsePacket(options) {
|
|
options = options || {};
|
|
this.data = options.data;
|
|
}
|
|
AuthSwitchResponsePacket.prototype.parse = function parse(parser) {
|
|
this.data = parser.parsePacketTerminatedBuffer();
|
|
};
|
|
AuthSwitchResponsePacket.prototype.write = function write(writer) {
|
|
writer.writeBuffer(this.data);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js
|
|
var require_ClientAuthenticationPacket = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
module.exports = ClientAuthenticationPacket;
|
|
function ClientAuthenticationPacket(options) {
|
|
options = options || {};
|
|
this.clientFlags = options.clientFlags;
|
|
this.maxPacketSize = options.maxPacketSize;
|
|
this.charsetNumber = options.charsetNumber;
|
|
this.filler = undefined;
|
|
this.user = options.user;
|
|
this.scrambleBuff = options.scrambleBuff;
|
|
this.database = options.database;
|
|
this.protocol41 = options.protocol41;
|
|
}
|
|
ClientAuthenticationPacket.prototype.parse = function(parser) {
|
|
if (this.protocol41) {
|
|
this.clientFlags = parser.parseUnsignedNumber(4);
|
|
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
|
this.charsetNumber = parser.parseUnsignedNumber(1);
|
|
this.filler = parser.parseFiller(23);
|
|
this.user = parser.parseNullTerminatedString();
|
|
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
|
this.database = parser.parseNullTerminatedString();
|
|
} else {
|
|
this.clientFlags = parser.parseUnsignedNumber(2);
|
|
this.maxPacketSize = parser.parseUnsignedNumber(3);
|
|
this.user = parser.parseNullTerminatedString();
|
|
this.scrambleBuff = parser.parseBuffer(8);
|
|
this.database = parser.parseLengthCodedBuffer();
|
|
}
|
|
};
|
|
ClientAuthenticationPacket.prototype.write = function(writer) {
|
|
if (this.protocol41) {
|
|
writer.writeUnsignedNumber(4, this.clientFlags);
|
|
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
|
writer.writeUnsignedNumber(1, this.charsetNumber);
|
|
writer.writeFiller(23);
|
|
writer.writeNullTerminatedString(this.user);
|
|
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
|
writer.writeNullTerminatedString(this.database);
|
|
} else {
|
|
writer.writeUnsignedNumber(2, this.clientFlags);
|
|
writer.writeUnsignedNumber(3, this.maxPacketSize);
|
|
writer.writeNullTerminatedString(this.user);
|
|
writer.writeBuffer(this.scrambleBuff);
|
|
if (this.database && this.database.length) {
|
|
writer.writeFiller(1);
|
|
writer.writeBuffer(Buffer2.from(this.database));
|
|
}
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ComChangeUserPacket.js
|
|
var require_ComChangeUserPacket = __commonJS((exports, module) => {
|
|
module.exports = ComChangeUserPacket;
|
|
function ComChangeUserPacket(options) {
|
|
options = options || {};
|
|
this.command = 17;
|
|
this.user = options.user;
|
|
this.scrambleBuff = options.scrambleBuff;
|
|
this.database = options.database;
|
|
this.charsetNumber = options.charsetNumber;
|
|
}
|
|
ComChangeUserPacket.prototype.parse = function(parser) {
|
|
this.command = parser.parseUnsignedNumber(1);
|
|
this.user = parser.parseNullTerminatedString();
|
|
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
|
this.database = parser.parseNullTerminatedString();
|
|
this.charsetNumber = parser.parseUnsignedNumber(1);
|
|
};
|
|
ComChangeUserPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.command);
|
|
writer.writeNullTerminatedString(this.user);
|
|
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
|
writer.writeNullTerminatedString(this.database);
|
|
writer.writeUnsignedNumber(2, this.charsetNumber);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ComPingPacket.js
|
|
var require_ComPingPacket = __commonJS((exports, module) => {
|
|
module.exports = ComPingPacket;
|
|
function ComPingPacket() {
|
|
this.command = 14;
|
|
}
|
|
ComPingPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.command);
|
|
};
|
|
ComPingPacket.prototype.parse = function(parser) {
|
|
this.command = parser.parseUnsignedNumber(1);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ComQueryPacket.js
|
|
var require_ComQueryPacket = __commonJS((exports, module) => {
|
|
module.exports = ComQueryPacket;
|
|
function ComQueryPacket(sql) {
|
|
this.command = 3;
|
|
this.sql = sql;
|
|
}
|
|
ComQueryPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.command);
|
|
writer.writeString(this.sql);
|
|
};
|
|
ComQueryPacket.prototype.parse = function(parser) {
|
|
this.command = parser.parseUnsignedNumber(1);
|
|
this.sql = parser.parsePacketTerminatedString();
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ComQuitPacket.js
|
|
var require_ComQuitPacket = __commonJS((exports, module) => {
|
|
module.exports = ComQuitPacket;
|
|
function ComQuitPacket() {
|
|
this.command = 1;
|
|
}
|
|
ComQuitPacket.prototype.parse = function parse(parser) {
|
|
this.command = parser.parseUnsignedNumber(1);
|
|
};
|
|
ComQuitPacket.prototype.write = function write(writer) {
|
|
writer.writeUnsignedNumber(1, this.command);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ComStatisticsPacket.js
|
|
var require_ComStatisticsPacket = __commonJS((exports, module) => {
|
|
module.exports = ComStatisticsPacket;
|
|
function ComStatisticsPacket() {
|
|
this.command = 9;
|
|
}
|
|
ComStatisticsPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.command);
|
|
};
|
|
ComStatisticsPacket.prototype.parse = function(parser) {
|
|
this.command = parser.parseUnsignedNumber(1);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/EmptyPacket.js
|
|
var require_EmptyPacket = __commonJS((exports, module) => {
|
|
module.exports = EmptyPacket;
|
|
function EmptyPacket() {
|
|
}
|
|
EmptyPacket.prototype.parse = function parse() {
|
|
};
|
|
EmptyPacket.prototype.write = function write() {
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/EofPacket.js
|
|
var require_EofPacket = __commonJS((exports, module) => {
|
|
module.exports = EofPacket;
|
|
function EofPacket(options) {
|
|
options = options || {};
|
|
this.fieldCount = undefined;
|
|
this.warningCount = options.warningCount;
|
|
this.serverStatus = options.serverStatus;
|
|
this.protocol41 = options.protocol41;
|
|
}
|
|
EofPacket.prototype.parse = function(parser) {
|
|
this.fieldCount = parser.parseUnsignedNumber(1);
|
|
if (this.protocol41) {
|
|
this.warningCount = parser.parseUnsignedNumber(2);
|
|
this.serverStatus = parser.parseUnsignedNumber(2);
|
|
}
|
|
};
|
|
EofPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, 254);
|
|
if (this.protocol41) {
|
|
writer.writeUnsignedNumber(2, this.warningCount);
|
|
writer.writeUnsignedNumber(2, this.serverStatus);
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ErrorPacket.js
|
|
var require_ErrorPacket = __commonJS((exports, module) => {
|
|
module.exports = ErrorPacket;
|
|
function ErrorPacket(options) {
|
|
options = options || {};
|
|
this.fieldCount = options.fieldCount;
|
|
this.errno = options.errno;
|
|
this.sqlStateMarker = options.sqlStateMarker;
|
|
this.sqlState = options.sqlState;
|
|
this.message = options.message;
|
|
}
|
|
ErrorPacket.prototype.parse = function(parser) {
|
|
this.fieldCount = parser.parseUnsignedNumber(1);
|
|
this.errno = parser.parseUnsignedNumber(2);
|
|
if (parser.peak() === 35) {
|
|
this.sqlStateMarker = parser.parseString(1);
|
|
this.sqlState = parser.parseString(5);
|
|
}
|
|
this.message = parser.parsePacketTerminatedString();
|
|
};
|
|
ErrorPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, 255);
|
|
writer.writeUnsignedNumber(2, this.errno);
|
|
if (this.sqlStateMarker) {
|
|
writer.writeString(this.sqlStateMarker);
|
|
writer.writeString(this.sqlState);
|
|
}
|
|
writer.writeString(this.message);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/constants/types.js
|
|
var require_types = __commonJS((exports) => {
|
|
exports.DECIMAL = 0;
|
|
exports.TINY = 1;
|
|
exports.SHORT = 2;
|
|
exports.LONG = 3;
|
|
exports.FLOAT = 4;
|
|
exports.DOUBLE = 5;
|
|
exports.NULL = 6;
|
|
exports.TIMESTAMP = 7;
|
|
exports.LONGLONG = 8;
|
|
exports.INT24 = 9;
|
|
exports.DATE = 10;
|
|
exports.TIME = 11;
|
|
exports.DATETIME = 12;
|
|
exports.YEAR = 13;
|
|
exports.NEWDATE = 14;
|
|
exports.VARCHAR = 15;
|
|
exports.BIT = 16;
|
|
exports.TIMESTAMP2 = 17;
|
|
exports.DATETIME2 = 18;
|
|
exports.TIME2 = 19;
|
|
exports.JSON = 245;
|
|
exports.NEWDECIMAL = 246;
|
|
exports.ENUM = 247;
|
|
exports.SET = 248;
|
|
exports.TINY_BLOB = 249;
|
|
exports.MEDIUM_BLOB = 250;
|
|
exports.LONG_BLOB = 251;
|
|
exports.BLOB = 252;
|
|
exports.VAR_STRING = 253;
|
|
exports.STRING = 254;
|
|
exports.GEOMETRY = 255;
|
|
exports[0] = "DECIMAL";
|
|
exports[1] = "TINY";
|
|
exports[2] = "SHORT";
|
|
exports[3] = "LONG";
|
|
exports[4] = "FLOAT";
|
|
exports[5] = "DOUBLE";
|
|
exports[6] = "NULL";
|
|
exports[7] = "TIMESTAMP";
|
|
exports[8] = "LONGLONG";
|
|
exports[9] = "INT24";
|
|
exports[10] = "DATE";
|
|
exports[11] = "TIME";
|
|
exports[12] = "DATETIME";
|
|
exports[13] = "YEAR";
|
|
exports[14] = "NEWDATE";
|
|
exports[15] = "VARCHAR";
|
|
exports[16] = "BIT";
|
|
exports[17] = "TIMESTAMP2";
|
|
exports[18] = "DATETIME2";
|
|
exports[19] = "TIME2";
|
|
exports[245] = "JSON";
|
|
exports[246] = "NEWDECIMAL";
|
|
exports[247] = "ENUM";
|
|
exports[248] = "SET";
|
|
exports[249] = "TINY_BLOB";
|
|
exports[250] = "MEDIUM_BLOB";
|
|
exports[251] = "LONG_BLOB";
|
|
exports[252] = "BLOB";
|
|
exports[253] = "VAR_STRING";
|
|
exports[254] = "STRING";
|
|
exports[255] = "GEOMETRY";
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/Field.js
|
|
var require_Field = __commonJS((exports, module) => {
|
|
var Types = require_types();
|
|
module.exports = Field;
|
|
function Field(options) {
|
|
options = options || {};
|
|
this.parser = options.parser;
|
|
this.packet = options.packet;
|
|
this.db = options.packet.db;
|
|
this.table = options.packet.table;
|
|
this.name = options.packet.name;
|
|
this.type = Types[options.packet.type];
|
|
this.length = options.packet.length;
|
|
}
|
|
Field.prototype.string = function() {
|
|
return this.parser.parseLengthCodedString();
|
|
};
|
|
Field.prototype.buffer = function() {
|
|
return this.parser.parseLengthCodedBuffer();
|
|
};
|
|
Field.prototype.geometry = function() {
|
|
return this.parser.parseGeometryValue();
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/FieldPacket.js
|
|
var require_FieldPacket = __commonJS((exports, module) => {
|
|
module.exports = FieldPacket;
|
|
function FieldPacket(options) {
|
|
options = options || {};
|
|
this.catalog = options.catalog;
|
|
this.db = options.db;
|
|
this.table = options.table;
|
|
this.orgTable = options.orgTable;
|
|
this.name = options.name;
|
|
this.orgName = options.orgName;
|
|
this.charsetNr = options.charsetNr;
|
|
this.length = options.length;
|
|
this.type = options.type;
|
|
this.flags = options.flags;
|
|
this.decimals = options.decimals;
|
|
this.default = options.default;
|
|
this.zeroFill = options.zeroFill;
|
|
this.protocol41 = options.protocol41;
|
|
}
|
|
FieldPacket.prototype.parse = function(parser) {
|
|
if (this.protocol41) {
|
|
this.catalog = parser.parseLengthCodedString();
|
|
this.db = parser.parseLengthCodedString();
|
|
this.table = parser.parseLengthCodedString();
|
|
this.orgTable = parser.parseLengthCodedString();
|
|
this.name = parser.parseLengthCodedString();
|
|
this.orgName = parser.parseLengthCodedString();
|
|
if (parser.parseLengthCodedNumber() !== 12) {
|
|
var err = new TypeError("Received invalid field length");
|
|
err.code = "PARSER_INVALID_FIELD_LENGTH";
|
|
throw err;
|
|
}
|
|
this.charsetNr = parser.parseUnsignedNumber(2);
|
|
this.length = parser.parseUnsignedNumber(4);
|
|
this.type = parser.parseUnsignedNumber(1);
|
|
this.flags = parser.parseUnsignedNumber(2);
|
|
this.decimals = parser.parseUnsignedNumber(1);
|
|
var filler = parser.parseBuffer(2);
|
|
if (filler[0] !== 0 || filler[1] !== 0) {
|
|
var err = new TypeError("Received invalid filler");
|
|
err.code = "PARSER_INVALID_FILLER";
|
|
throw err;
|
|
}
|
|
this.zeroFill = this.flags & 64 ? true : false;
|
|
if (parser.reachedPacketEnd()) {
|
|
return;
|
|
}
|
|
this.default = parser.parseLengthCodedString();
|
|
} else {
|
|
this.table = parser.parseLengthCodedString();
|
|
this.name = parser.parseLengthCodedString();
|
|
this.length = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
|
this.type = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
|
}
|
|
};
|
|
FieldPacket.prototype.write = function(writer) {
|
|
if (this.protocol41) {
|
|
writer.writeLengthCodedString(this.catalog);
|
|
writer.writeLengthCodedString(this.db);
|
|
writer.writeLengthCodedString(this.table);
|
|
writer.writeLengthCodedString(this.orgTable);
|
|
writer.writeLengthCodedString(this.name);
|
|
writer.writeLengthCodedString(this.orgName);
|
|
writer.writeLengthCodedNumber(12);
|
|
writer.writeUnsignedNumber(2, this.charsetNr || 0);
|
|
writer.writeUnsignedNumber(4, this.length || 0);
|
|
writer.writeUnsignedNumber(1, this.type || 0);
|
|
writer.writeUnsignedNumber(2, this.flags || 0);
|
|
writer.writeUnsignedNumber(1, this.decimals || 0);
|
|
writer.writeFiller(2);
|
|
if (this.default !== undefined) {
|
|
writer.writeLengthCodedString(this.default);
|
|
}
|
|
} else {
|
|
writer.writeLengthCodedString(this.table);
|
|
writer.writeLengthCodedString(this.name);
|
|
writer.writeUnsignedNumber(1, 1);
|
|
writer.writeUnsignedNumber(1, this.length);
|
|
writer.writeUnsignedNumber(1, 1);
|
|
writer.writeUnsignedNumber(1, this.type);
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js
|
|
var require_HandshakeInitializationPacket = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var Client = require_client();
|
|
module.exports = HandshakeInitializationPacket;
|
|
function HandshakeInitializationPacket(options) {
|
|
options = options || {};
|
|
this.protocolVersion = options.protocolVersion;
|
|
this.serverVersion = options.serverVersion;
|
|
this.threadId = options.threadId;
|
|
this.scrambleBuff1 = options.scrambleBuff1;
|
|
this.filler1 = options.filler1;
|
|
this.serverCapabilities1 = options.serverCapabilities1;
|
|
this.serverLanguage = options.serverLanguage;
|
|
this.serverStatus = options.serverStatus;
|
|
this.serverCapabilities2 = options.serverCapabilities2;
|
|
this.scrambleLength = options.scrambleLength;
|
|
this.filler2 = options.filler2;
|
|
this.scrambleBuff2 = options.scrambleBuff2;
|
|
this.filler3 = options.filler3;
|
|
this.pluginData = options.pluginData;
|
|
this.protocol41 = options.protocol41;
|
|
if (this.protocol41) {
|
|
this.serverCapabilities1 |= Client.CLIENT_PROTOCOL_41;
|
|
}
|
|
}
|
|
HandshakeInitializationPacket.prototype.parse = function(parser) {
|
|
this.protocolVersion = parser.parseUnsignedNumber(1);
|
|
this.serverVersion = parser.parseNullTerminatedString();
|
|
this.threadId = parser.parseUnsignedNumber(4);
|
|
this.scrambleBuff1 = parser.parseBuffer(8);
|
|
this.filler1 = parser.parseFiller(1);
|
|
this.serverCapabilities1 = parser.parseUnsignedNumber(2);
|
|
this.serverLanguage = parser.parseUnsignedNumber(1);
|
|
this.serverStatus = parser.parseUnsignedNumber(2);
|
|
this.protocol41 = (this.serverCapabilities1 & 1 << 9) > 0;
|
|
if (this.protocol41) {
|
|
this.serverCapabilities2 = parser.parseUnsignedNumber(2);
|
|
this.scrambleLength = parser.parseUnsignedNumber(1);
|
|
this.filler2 = parser.parseFiller(10);
|
|
this.scrambleBuff2 = parser.parseBuffer(12);
|
|
this.filler3 = parser.parseFiller(1);
|
|
} else {
|
|
this.filler2 = parser.parseFiller(13);
|
|
}
|
|
if (parser.reachedPacketEnd()) {
|
|
return;
|
|
}
|
|
this.pluginData = parser.parsePacketTerminatedString();
|
|
var lastChar = this.pluginData.length - 1;
|
|
if (this.pluginData[lastChar] === "\0") {
|
|
this.pluginData = this.pluginData.substr(0, lastChar);
|
|
}
|
|
};
|
|
HandshakeInitializationPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.protocolVersion);
|
|
writer.writeNullTerminatedString(this.serverVersion);
|
|
writer.writeUnsignedNumber(4, this.threadId);
|
|
writer.writeBuffer(this.scrambleBuff1);
|
|
writer.writeFiller(1);
|
|
writer.writeUnsignedNumber(2, this.serverCapabilities1);
|
|
writer.writeUnsignedNumber(1, this.serverLanguage);
|
|
writer.writeUnsignedNumber(2, this.serverStatus);
|
|
if (this.protocol41) {
|
|
writer.writeUnsignedNumber(2, this.serverCapabilities2);
|
|
writer.writeUnsignedNumber(1, this.scrambleLength);
|
|
writer.writeFiller(10);
|
|
}
|
|
writer.writeNullTerminatedBuffer(this.scrambleBuff2);
|
|
if (this.pluginData !== undefined) {
|
|
writer.writeNullTerminatedString(this.pluginData);
|
|
}
|
|
};
|
|
HandshakeInitializationPacket.prototype.scrambleBuff = function() {
|
|
var buffer = null;
|
|
if (typeof this.scrambleBuff2 === "undefined") {
|
|
buffer = Buffer2.from(this.scrambleBuff1);
|
|
} else {
|
|
buffer = Buffer2.allocUnsafe(this.scrambleBuff1.length + this.scrambleBuff2.length);
|
|
this.scrambleBuff1.copy(buffer, 0);
|
|
this.scrambleBuff2.copy(buffer, this.scrambleBuff1.length);
|
|
}
|
|
return buffer;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/LocalDataFilePacket.js
|
|
var require_LocalDataFilePacket = __commonJS((exports, module) => {
|
|
module.exports = LocalDataFilePacket;
|
|
function LocalDataFilePacket(data) {
|
|
this.data = data;
|
|
}
|
|
LocalDataFilePacket.prototype.write = function(writer) {
|
|
writer.writeBuffer(this.data);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/LocalInfileRequestPacket.js
|
|
var require_LocalInfileRequestPacket = __commonJS((exports, module) => {
|
|
module.exports = LocalInfileRequestPacket;
|
|
function LocalInfileRequestPacket(options) {
|
|
options = options || {};
|
|
this.filename = options.filename;
|
|
}
|
|
LocalInfileRequestPacket.prototype.parse = function parse(parser) {
|
|
if (parser.parseLengthCodedNumber() !== null) {
|
|
var err = new TypeError("Received invalid field length");
|
|
err.code = "PARSER_INVALID_FIELD_LENGTH";
|
|
throw err;
|
|
}
|
|
this.filename = parser.parsePacketTerminatedString();
|
|
};
|
|
LocalInfileRequestPacket.prototype.write = function write(writer) {
|
|
writer.writeLengthCodedNumber(null);
|
|
writer.writeString(this.filename);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/OkPacket.js
|
|
var require_OkPacket = __commonJS((exports, module) => {
|
|
var ER_UPDATE_INFO_REGEXP = /^[^:0-9]+: [0-9]+[^:0-9]+: ([0-9]+)[^:0-9]+: [0-9]+[^:0-9]*$/;
|
|
module.exports = OkPacket;
|
|
function OkPacket(options) {
|
|
options = options || {};
|
|
this.fieldCount = undefined;
|
|
this.affectedRows = undefined;
|
|
this.insertId = undefined;
|
|
this.serverStatus = undefined;
|
|
this.warningCount = undefined;
|
|
this.message = undefined;
|
|
this.protocol41 = options.protocol41;
|
|
}
|
|
OkPacket.prototype.parse = function(parser) {
|
|
this.fieldCount = parser.parseUnsignedNumber(1);
|
|
this.affectedRows = parser.parseLengthCodedNumber();
|
|
this.insertId = parser.parseLengthCodedNumber();
|
|
if (this.protocol41) {
|
|
this.serverStatus = parser.parseUnsignedNumber(2);
|
|
this.warningCount = parser.parseUnsignedNumber(2);
|
|
}
|
|
this.message = parser.parsePacketTerminatedString();
|
|
this.changedRows = 0;
|
|
var m = ER_UPDATE_INFO_REGEXP.exec(this.message);
|
|
if (m !== null) {
|
|
this.changedRows = parseInt(m[1], 10);
|
|
}
|
|
};
|
|
OkPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, 0);
|
|
writer.writeLengthCodedNumber(this.affectedRows || 0);
|
|
writer.writeLengthCodedNumber(this.insertId || 0);
|
|
if (this.protocol41) {
|
|
writer.writeUnsignedNumber(2, this.serverStatus || 0);
|
|
writer.writeUnsignedNumber(2, this.warningCount || 0);
|
|
}
|
|
writer.writeString(this.message);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/OldPasswordPacket.js
|
|
var require_OldPasswordPacket = __commonJS((exports, module) => {
|
|
module.exports = OldPasswordPacket;
|
|
function OldPasswordPacket(options) {
|
|
options = options || {};
|
|
this.scrambleBuff = options.scrambleBuff;
|
|
}
|
|
OldPasswordPacket.prototype.parse = function(parser) {
|
|
this.scrambleBuff = parser.parsePacketTerminatedBuffer();
|
|
};
|
|
OldPasswordPacket.prototype.write = function(writer) {
|
|
writer.writeBuffer(this.scrambleBuff);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/ResultSetHeaderPacket.js
|
|
var require_ResultSetHeaderPacket = __commonJS((exports, module) => {
|
|
module.exports = ResultSetHeaderPacket;
|
|
function ResultSetHeaderPacket(options) {
|
|
options = options || {};
|
|
this.fieldCount = options.fieldCount;
|
|
}
|
|
ResultSetHeaderPacket.prototype.parse = function(parser) {
|
|
this.fieldCount = parser.parseLengthCodedNumber();
|
|
};
|
|
ResultSetHeaderPacket.prototype.write = function(writer) {
|
|
writer.writeLengthCodedNumber(this.fieldCount);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/RowDataPacket.js
|
|
var require_RowDataPacket = __commonJS((exports, module) => {
|
|
var Types = require_types();
|
|
var Charsets = require_charsets();
|
|
var Field = require_Field();
|
|
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
|
module.exports = RowDataPacket;
|
|
function RowDataPacket() {
|
|
}
|
|
Object.defineProperty(RowDataPacket.prototype, "parse", {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: parse
|
|
});
|
|
Object.defineProperty(RowDataPacket.prototype, "_typeCast", {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: typeCast
|
|
});
|
|
function parse(parser, fieldPackets, typeCast2, nestTables, connection) {
|
|
var self2 = this;
|
|
var next = function() {
|
|
return self2._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings);
|
|
};
|
|
for (var i = 0;i < fieldPackets.length; i++) {
|
|
var fieldPacket = fieldPackets[i];
|
|
var value;
|
|
if (typeof typeCast2 === "function") {
|
|
value = typeCast2.apply(connection, [new Field({ packet: fieldPacket, parser }), next]);
|
|
} else {
|
|
value = typeCast2 ? this._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings) : fieldPacket.charsetNr === Charsets.BINARY ? parser.parseLengthCodedBuffer() : parser.parseLengthCodedString();
|
|
}
|
|
if (typeof nestTables === "string" && nestTables.length) {
|
|
this[fieldPacket.table + nestTables + fieldPacket.name] = value;
|
|
} else if (nestTables) {
|
|
this[fieldPacket.table] = this[fieldPacket.table] || {};
|
|
this[fieldPacket.table][fieldPacket.name] = value;
|
|
} else {
|
|
this[fieldPacket.name] = value;
|
|
}
|
|
}
|
|
}
|
|
function typeCast(field, parser, timeZone, supportBigNumbers, bigNumberStrings, dateStrings) {
|
|
var numberString;
|
|
switch (field.type) {
|
|
case Types.TIMESTAMP:
|
|
case Types.TIMESTAMP2:
|
|
case Types.DATE:
|
|
case Types.DATETIME:
|
|
case Types.DATETIME2:
|
|
case Types.NEWDATE:
|
|
var dateString = parser.parseLengthCodedString();
|
|
if (typeMatch(field.type, dateStrings)) {
|
|
return dateString;
|
|
}
|
|
if (dateString === null) {
|
|
return null;
|
|
}
|
|
var originalString = dateString;
|
|
if (field.type === Types.DATE) {
|
|
dateString += " 00:00:00";
|
|
}
|
|
if (timeZone !== "local") {
|
|
dateString += " " + timeZone;
|
|
}
|
|
var dt = new Date(dateString);
|
|
if (isNaN(dt.getTime())) {
|
|
return originalString;
|
|
}
|
|
return dt;
|
|
case Types.TINY:
|
|
case Types.SHORT:
|
|
case Types.LONG:
|
|
case Types.INT24:
|
|
case Types.YEAR:
|
|
case Types.FLOAT:
|
|
case Types.DOUBLE:
|
|
numberString = parser.parseLengthCodedString();
|
|
return numberString === null || field.zeroFill && numberString[0] === "0" ? numberString : Number(numberString);
|
|
case Types.NEWDECIMAL:
|
|
case Types.LONGLONG:
|
|
numberString = parser.parseLengthCodedString();
|
|
return numberString === null || field.zeroFill && numberString[0] === "0" ? numberString : supportBigNumbers && (bigNumberStrings || Number(numberString) >= IEEE_754_BINARY_64_PRECISION || Number(numberString) <= -IEEE_754_BINARY_64_PRECISION) ? numberString : Number(numberString);
|
|
case Types.BIT:
|
|
return parser.parseLengthCodedBuffer();
|
|
case Types.STRING:
|
|
case Types.VAR_STRING:
|
|
case Types.TINY_BLOB:
|
|
case Types.MEDIUM_BLOB:
|
|
case Types.LONG_BLOB:
|
|
case Types.BLOB:
|
|
return field.charsetNr === Charsets.BINARY ? parser.parseLengthCodedBuffer() : parser.parseLengthCodedString();
|
|
case Types.GEOMETRY:
|
|
return parser.parseGeometryValue();
|
|
default:
|
|
return parser.parseLengthCodedString();
|
|
}
|
|
}
|
|
function typeMatch(type, list) {
|
|
if (Array.isArray(list)) {
|
|
return list.indexOf(Types[type]) !== -1;
|
|
} else {
|
|
return Boolean(list);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/SSLRequestPacket.js
|
|
var require_SSLRequestPacket = __commonJS((exports, module) => {
|
|
var ClientConstants = require_client();
|
|
module.exports = SSLRequestPacket;
|
|
function SSLRequestPacket(options) {
|
|
options = options || {};
|
|
this.clientFlags = options.clientFlags | ClientConstants.CLIENT_SSL;
|
|
this.maxPacketSize = options.maxPacketSize;
|
|
this.charsetNumber = options.charsetNumber;
|
|
}
|
|
SSLRequestPacket.prototype.parse = function(parser) {
|
|
this.clientFlags = parser.parseUnsignedNumber(4);
|
|
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
|
this.charsetNumber = parser.parseUnsignedNumber(1);
|
|
};
|
|
SSLRequestPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(4, this.clientFlags);
|
|
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
|
writer.writeUnsignedNumber(1, this.charsetNumber);
|
|
writer.writeFiller(23);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/StatisticsPacket.js
|
|
var require_StatisticsPacket = __commonJS((exports, module) => {
|
|
module.exports = StatisticsPacket;
|
|
function StatisticsPacket() {
|
|
this.message = undefined;
|
|
}
|
|
StatisticsPacket.prototype.parse = function(parser) {
|
|
this.message = parser.parsePacketTerminatedString();
|
|
var items = this.message.split(/\s\s/);
|
|
for (var i = 0;i < items.length; i++) {
|
|
var m = items[i].match(/^(.+)\:\s+(.+)$/);
|
|
if (m !== null) {
|
|
this[m[1].toLowerCase().replace(/\s/g, "_")] = Number(m[2]);
|
|
}
|
|
}
|
|
};
|
|
StatisticsPacket.prototype.write = function(writer) {
|
|
writer.writeString(this.message);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/UseOldPasswordPacket.js
|
|
var require_UseOldPasswordPacket = __commonJS((exports, module) => {
|
|
module.exports = UseOldPasswordPacket;
|
|
function UseOldPasswordPacket(options) {
|
|
options = options || {};
|
|
this.firstByte = options.firstByte || 254;
|
|
}
|
|
UseOldPasswordPacket.prototype.parse = function(parser) {
|
|
this.firstByte = parser.parseUnsignedNumber(1);
|
|
};
|
|
UseOldPasswordPacket.prototype.write = function(writer) {
|
|
writer.writeUnsignedNumber(1, this.firstByte);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/packets/index.js
|
|
var require_packets = __commonJS((exports) => {
|
|
exports.AuthSwitchRequestPacket = require_AuthSwitchRequestPacket();
|
|
exports.AuthSwitchResponsePacket = require_AuthSwitchResponsePacket();
|
|
exports.ClientAuthenticationPacket = require_ClientAuthenticationPacket();
|
|
exports.ComChangeUserPacket = require_ComChangeUserPacket();
|
|
exports.ComPingPacket = require_ComPingPacket();
|
|
exports.ComQueryPacket = require_ComQueryPacket();
|
|
exports.ComQuitPacket = require_ComQuitPacket();
|
|
exports.ComStatisticsPacket = require_ComStatisticsPacket();
|
|
exports.EmptyPacket = require_EmptyPacket();
|
|
exports.EofPacket = require_EofPacket();
|
|
exports.ErrorPacket = require_ErrorPacket();
|
|
exports.Field = require_Field();
|
|
exports.FieldPacket = require_FieldPacket();
|
|
exports.HandshakeInitializationPacket = require_HandshakeInitializationPacket();
|
|
exports.LocalDataFilePacket = require_LocalDataFilePacket();
|
|
exports.LocalInfileRequestPacket = require_LocalInfileRequestPacket();
|
|
exports.OkPacket = require_OkPacket();
|
|
exports.OldPasswordPacket = require_OldPasswordPacket();
|
|
exports.ResultSetHeaderPacket = require_ResultSetHeaderPacket();
|
|
exports.RowDataPacket = require_RowDataPacket();
|
|
exports.SSLRequestPacket = require_SSLRequestPacket();
|
|
exports.StatisticsPacket = require_StatisticsPacket();
|
|
exports.UseOldPasswordPacket = require_UseOldPasswordPacket();
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/constants/errors.js
|
|
var require_errors = __commonJS((exports) => {
|
|
exports.EE_CANTCREATEFILE = 1;
|
|
exports.EE_READ = 2;
|
|
exports.EE_WRITE = 3;
|
|
exports.EE_BADCLOSE = 4;
|
|
exports.EE_OUTOFMEMORY = 5;
|
|
exports.EE_DELETE = 6;
|
|
exports.EE_LINK = 7;
|
|
exports.EE_EOFERR = 9;
|
|
exports.EE_CANTLOCK = 10;
|
|
exports.EE_CANTUNLOCK = 11;
|
|
exports.EE_DIR = 12;
|
|
exports.EE_STAT = 13;
|
|
exports.EE_CANT_CHSIZE = 14;
|
|
exports.EE_CANT_OPEN_STREAM = 15;
|
|
exports.EE_GETWD = 16;
|
|
exports.EE_SETWD = 17;
|
|
exports.EE_LINK_WARNING = 18;
|
|
exports.EE_OPEN_WARNING = 19;
|
|
exports.EE_DISK_FULL = 20;
|
|
exports.EE_CANT_MKDIR = 21;
|
|
exports.EE_UNKNOWN_CHARSET = 22;
|
|
exports.EE_OUT_OF_FILERESOURCES = 23;
|
|
exports.EE_CANT_READLINK = 24;
|
|
exports.EE_CANT_SYMLINK = 25;
|
|
exports.EE_REALPATH = 26;
|
|
exports.EE_SYNC = 27;
|
|
exports.EE_UNKNOWN_COLLATION = 28;
|
|
exports.EE_FILENOTFOUND = 29;
|
|
exports.EE_FILE_NOT_CLOSED = 30;
|
|
exports.EE_CHANGE_OWNERSHIP = 31;
|
|
exports.EE_CHANGE_PERMISSIONS = 32;
|
|
exports.EE_CANT_SEEK = 33;
|
|
exports.EE_CAPACITY_EXCEEDED = 34;
|
|
exports.HA_ERR_KEY_NOT_FOUND = 120;
|
|
exports.HA_ERR_FOUND_DUPP_KEY = 121;
|
|
exports.HA_ERR_INTERNAL_ERROR = 122;
|
|
exports.HA_ERR_RECORD_CHANGED = 123;
|
|
exports.HA_ERR_WRONG_INDEX = 124;
|
|
exports.HA_ERR_CRASHED = 126;
|
|
exports.HA_ERR_WRONG_IN_RECORD = 127;
|
|
exports.HA_ERR_OUT_OF_MEM = 128;
|
|
exports.HA_ERR_NOT_A_TABLE = 130;
|
|
exports.HA_ERR_WRONG_COMMAND = 131;
|
|
exports.HA_ERR_OLD_FILE = 132;
|
|
exports.HA_ERR_NO_ACTIVE_RECORD = 133;
|
|
exports.HA_ERR_RECORD_DELETED = 134;
|
|
exports.HA_ERR_RECORD_FILE_FULL = 135;
|
|
exports.HA_ERR_INDEX_FILE_FULL = 136;
|
|
exports.HA_ERR_END_OF_FILE = 137;
|
|
exports.HA_ERR_UNSUPPORTED = 138;
|
|
exports.HA_ERR_TOO_BIG_ROW = 139;
|
|
exports.HA_WRONG_CREATE_OPTION = 140;
|
|
exports.HA_ERR_FOUND_DUPP_UNIQUE = 141;
|
|
exports.HA_ERR_UNKNOWN_CHARSET = 142;
|
|
exports.HA_ERR_WRONG_MRG_TABLE_DEF = 143;
|
|
exports.HA_ERR_CRASHED_ON_REPAIR = 144;
|
|
exports.HA_ERR_CRASHED_ON_USAGE = 145;
|
|
exports.HA_ERR_LOCK_WAIT_TIMEOUT = 146;
|
|
exports.HA_ERR_LOCK_TABLE_FULL = 147;
|
|
exports.HA_ERR_READ_ONLY_TRANSACTION = 148;
|
|
exports.HA_ERR_LOCK_DEADLOCK = 149;
|
|
exports.HA_ERR_CANNOT_ADD_FOREIGN = 150;
|
|
exports.HA_ERR_NO_REFERENCED_ROW = 151;
|
|
exports.HA_ERR_ROW_IS_REFERENCED = 152;
|
|
exports.HA_ERR_NO_SAVEPOINT = 153;
|
|
exports.HA_ERR_NON_UNIQUE_BLOCK_SIZE = 154;
|
|
exports.HA_ERR_NO_SUCH_TABLE = 155;
|
|
exports.HA_ERR_TABLE_EXIST = 156;
|
|
exports.HA_ERR_NO_CONNECTION = 157;
|
|
exports.HA_ERR_NULL_IN_SPATIAL = 158;
|
|
exports.HA_ERR_TABLE_DEF_CHANGED = 159;
|
|
exports.HA_ERR_NO_PARTITION_FOUND = 160;
|
|
exports.HA_ERR_RBR_LOGGING_FAILED = 161;
|
|
exports.HA_ERR_DROP_INDEX_FK = 162;
|
|
exports.HA_ERR_FOREIGN_DUPLICATE_KEY = 163;
|
|
exports.HA_ERR_TABLE_NEEDS_UPGRADE = 164;
|
|
exports.HA_ERR_TABLE_READONLY = 165;
|
|
exports.HA_ERR_AUTOINC_READ_FAILED = 166;
|
|
exports.HA_ERR_AUTOINC_ERANGE = 167;
|
|
exports.HA_ERR_GENERIC = 168;
|
|
exports.HA_ERR_RECORD_IS_THE_SAME = 169;
|
|
exports.HA_ERR_LOGGING_IMPOSSIBLE = 170;
|
|
exports.HA_ERR_CORRUPT_EVENT = 171;
|
|
exports.HA_ERR_NEW_FILE = 172;
|
|
exports.HA_ERR_ROWS_EVENT_APPLY = 173;
|
|
exports.HA_ERR_INITIALIZATION = 174;
|
|
exports.HA_ERR_FILE_TOO_SHORT = 175;
|
|
exports.HA_ERR_WRONG_CRC = 176;
|
|
exports.HA_ERR_TOO_MANY_CONCURRENT_TRXS = 177;
|
|
exports.HA_ERR_NOT_IN_LOCK_PARTITIONS = 178;
|
|
exports.HA_ERR_INDEX_COL_TOO_LONG = 179;
|
|
exports.HA_ERR_INDEX_CORRUPT = 180;
|
|
exports.HA_ERR_UNDO_REC_TOO_BIG = 181;
|
|
exports.HA_FTS_INVALID_DOCID = 182;
|
|
exports.HA_ERR_TABLE_IN_FK_CHECK = 183;
|
|
exports.HA_ERR_TABLESPACE_EXISTS = 184;
|
|
exports.HA_ERR_TOO_MANY_FIELDS = 185;
|
|
exports.HA_ERR_ROW_IN_WRONG_PARTITION = 186;
|
|
exports.HA_ERR_INNODB_READ_ONLY = 187;
|
|
exports.HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT = 188;
|
|
exports.HA_ERR_TEMP_FILE_WRITE_FAILURE = 189;
|
|
exports.HA_ERR_INNODB_FORCED_RECOVERY = 190;
|
|
exports.HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE = 191;
|
|
exports.HA_ERR_FK_DEPTH_EXCEEDED = 192;
|
|
exports.HA_MISSING_CREATE_OPTION = 193;
|
|
exports.HA_ERR_SE_OUT_OF_MEMORY = 194;
|
|
exports.HA_ERR_TABLE_CORRUPT = 195;
|
|
exports.HA_ERR_QUERY_INTERRUPTED = 196;
|
|
exports.HA_ERR_TABLESPACE_MISSING = 197;
|
|
exports.HA_ERR_TABLESPACE_IS_NOT_EMPTY = 198;
|
|
exports.HA_ERR_WRONG_FILE_NAME = 199;
|
|
exports.HA_ERR_NOT_ALLOWED_COMMAND = 200;
|
|
exports.HA_ERR_COMPUTE_FAILED = 201;
|
|
exports.ER_HASHCHK = 1000;
|
|
exports.ER_NISAMCHK = 1001;
|
|
exports.ER_NO = 1002;
|
|
exports.ER_YES = 1003;
|
|
exports.ER_CANT_CREATE_FILE = 1004;
|
|
exports.ER_CANT_CREATE_TABLE = 1005;
|
|
exports.ER_CANT_CREATE_DB = 1006;
|
|
exports.ER_DB_CREATE_EXISTS = 1007;
|
|
exports.ER_DB_DROP_EXISTS = 1008;
|
|
exports.ER_DB_DROP_DELETE = 1009;
|
|
exports.ER_DB_DROP_RMDIR = 1010;
|
|
exports.ER_CANT_DELETE_FILE = 1011;
|
|
exports.ER_CANT_FIND_SYSTEM_REC = 1012;
|
|
exports.ER_CANT_GET_STAT = 1013;
|
|
exports.ER_CANT_GET_WD = 1014;
|
|
exports.ER_CANT_LOCK = 1015;
|
|
exports.ER_CANT_OPEN_FILE = 1016;
|
|
exports.ER_FILE_NOT_FOUND = 1017;
|
|
exports.ER_CANT_READ_DIR = 1018;
|
|
exports.ER_CANT_SET_WD = 1019;
|
|
exports.ER_CHECKREAD = 1020;
|
|
exports.ER_DISK_FULL = 1021;
|
|
exports.ER_DUP_KEY = 1022;
|
|
exports.ER_ERROR_ON_CLOSE = 1023;
|
|
exports.ER_ERROR_ON_READ = 1024;
|
|
exports.ER_ERROR_ON_RENAME = 1025;
|
|
exports.ER_ERROR_ON_WRITE = 1026;
|
|
exports.ER_FILE_USED = 1027;
|
|
exports.ER_FILSORT_ABORT = 1028;
|
|
exports.ER_FORM_NOT_FOUND = 1029;
|
|
exports.ER_GET_ERRNO = 1030;
|
|
exports.ER_ILLEGAL_HA = 1031;
|
|
exports.ER_KEY_NOT_FOUND = 1032;
|
|
exports.ER_NOT_FORM_FILE = 1033;
|
|
exports.ER_NOT_KEYFILE = 1034;
|
|
exports.ER_OLD_KEYFILE = 1035;
|
|
exports.ER_OPEN_AS_READONLY = 1036;
|
|
exports.ER_OUTOFMEMORY = 1037;
|
|
exports.ER_OUT_OF_SORTMEMORY = 1038;
|
|
exports.ER_UNEXPECTED_EOF = 1039;
|
|
exports.ER_CON_COUNT_ERROR = 1040;
|
|
exports.ER_OUT_OF_RESOURCES = 1041;
|
|
exports.ER_BAD_HOST_ERROR = 1042;
|
|
exports.ER_HANDSHAKE_ERROR = 1043;
|
|
exports.ER_DBACCESS_DENIED_ERROR = 1044;
|
|
exports.ER_ACCESS_DENIED_ERROR = 1045;
|
|
exports.ER_NO_DB_ERROR = 1046;
|
|
exports.ER_UNKNOWN_COM_ERROR = 1047;
|
|
exports.ER_BAD_NULL_ERROR = 1048;
|
|
exports.ER_BAD_DB_ERROR = 1049;
|
|
exports.ER_TABLE_EXISTS_ERROR = 1050;
|
|
exports.ER_BAD_TABLE_ERROR = 1051;
|
|
exports.ER_NON_UNIQ_ERROR = 1052;
|
|
exports.ER_SERVER_SHUTDOWN = 1053;
|
|
exports.ER_BAD_FIELD_ERROR = 1054;
|
|
exports.ER_WRONG_FIELD_WITH_GROUP = 1055;
|
|
exports.ER_WRONG_GROUP_FIELD = 1056;
|
|
exports.ER_WRONG_SUM_SELECT = 1057;
|
|
exports.ER_WRONG_VALUE_COUNT = 1058;
|
|
exports.ER_TOO_LONG_IDENT = 1059;
|
|
exports.ER_DUP_FIELDNAME = 1060;
|
|
exports.ER_DUP_KEYNAME = 1061;
|
|
exports.ER_DUP_ENTRY = 1062;
|
|
exports.ER_WRONG_FIELD_SPEC = 1063;
|
|
exports.ER_PARSE_ERROR = 1064;
|
|
exports.ER_EMPTY_QUERY = 1065;
|
|
exports.ER_NONUNIQ_TABLE = 1066;
|
|
exports.ER_INVALID_DEFAULT = 1067;
|
|
exports.ER_MULTIPLE_PRI_KEY = 1068;
|
|
exports.ER_TOO_MANY_KEYS = 1069;
|
|
exports.ER_TOO_MANY_KEY_PARTS = 1070;
|
|
exports.ER_TOO_LONG_KEY = 1071;
|
|
exports.ER_KEY_COLUMN_DOES_NOT_EXITS = 1072;
|
|
exports.ER_BLOB_USED_AS_KEY = 1073;
|
|
exports.ER_TOO_BIG_FIELDLENGTH = 1074;
|
|
exports.ER_WRONG_AUTO_KEY = 1075;
|
|
exports.ER_READY = 1076;
|
|
exports.ER_NORMAL_SHUTDOWN = 1077;
|
|
exports.ER_GOT_SIGNAL = 1078;
|
|
exports.ER_SHUTDOWN_COMPLETE = 1079;
|
|
exports.ER_FORCING_CLOSE = 1080;
|
|
exports.ER_IPSOCK_ERROR = 1081;
|
|
exports.ER_NO_SUCH_INDEX = 1082;
|
|
exports.ER_WRONG_FIELD_TERMINATORS = 1083;
|
|
exports.ER_BLOBS_AND_NO_TERMINATED = 1084;
|
|
exports.ER_TEXTFILE_NOT_READABLE = 1085;
|
|
exports.ER_FILE_EXISTS_ERROR = 1086;
|
|
exports.ER_LOAD_INFO = 1087;
|
|
exports.ER_ALTER_INFO = 1088;
|
|
exports.ER_WRONG_SUB_KEY = 1089;
|
|
exports.ER_CANT_REMOVE_ALL_FIELDS = 1090;
|
|
exports.ER_CANT_DROP_FIELD_OR_KEY = 1091;
|
|
exports.ER_INSERT_INFO = 1092;
|
|
exports.ER_UPDATE_TABLE_USED = 1093;
|
|
exports.ER_NO_SUCH_THREAD = 1094;
|
|
exports.ER_KILL_DENIED_ERROR = 1095;
|
|
exports.ER_NO_TABLES_USED = 1096;
|
|
exports.ER_TOO_BIG_SET = 1097;
|
|
exports.ER_NO_UNIQUE_LOGFILE = 1098;
|
|
exports.ER_TABLE_NOT_LOCKED_FOR_WRITE = 1099;
|
|
exports.ER_TABLE_NOT_LOCKED = 1100;
|
|
exports.ER_BLOB_CANT_HAVE_DEFAULT = 1101;
|
|
exports.ER_WRONG_DB_NAME = 1102;
|
|
exports.ER_WRONG_TABLE_NAME = 1103;
|
|
exports.ER_TOO_BIG_SELECT = 1104;
|
|
exports.ER_UNKNOWN_ERROR = 1105;
|
|
exports.ER_UNKNOWN_PROCEDURE = 1106;
|
|
exports.ER_WRONG_PARAMCOUNT_TO_PROCEDURE = 1107;
|
|
exports.ER_WRONG_PARAMETERS_TO_PROCEDURE = 1108;
|
|
exports.ER_UNKNOWN_TABLE = 1109;
|
|
exports.ER_FIELD_SPECIFIED_TWICE = 1110;
|
|
exports.ER_INVALID_GROUP_FUNC_USE = 1111;
|
|
exports.ER_UNSUPPORTED_EXTENSION = 1112;
|
|
exports.ER_TABLE_MUST_HAVE_COLUMNS = 1113;
|
|
exports.ER_RECORD_FILE_FULL = 1114;
|
|
exports.ER_UNKNOWN_CHARACTER_SET = 1115;
|
|
exports.ER_TOO_MANY_TABLES = 1116;
|
|
exports.ER_TOO_MANY_FIELDS = 1117;
|
|
exports.ER_TOO_BIG_ROWSIZE = 1118;
|
|
exports.ER_STACK_OVERRUN = 1119;
|
|
exports.ER_WRONG_OUTER_JOIN = 1120;
|
|
exports.ER_NULL_COLUMN_IN_INDEX = 1121;
|
|
exports.ER_CANT_FIND_UDF = 1122;
|
|
exports.ER_CANT_INITIALIZE_UDF = 1123;
|
|
exports.ER_UDF_NO_PATHS = 1124;
|
|
exports.ER_UDF_EXISTS = 1125;
|
|
exports.ER_CANT_OPEN_LIBRARY = 1126;
|
|
exports.ER_CANT_FIND_DL_ENTRY = 1127;
|
|
exports.ER_FUNCTION_NOT_DEFINED = 1128;
|
|
exports.ER_HOST_IS_BLOCKED = 1129;
|
|
exports.ER_HOST_NOT_PRIVILEGED = 1130;
|
|
exports.ER_PASSWORD_ANONYMOUS_USER = 1131;
|
|
exports.ER_PASSWORD_NOT_ALLOWED = 1132;
|
|
exports.ER_PASSWORD_NO_MATCH = 1133;
|
|
exports.ER_UPDATE_INFO = 1134;
|
|
exports.ER_CANT_CREATE_THREAD = 1135;
|
|
exports.ER_WRONG_VALUE_COUNT_ON_ROW = 1136;
|
|
exports.ER_CANT_REOPEN_TABLE = 1137;
|
|
exports.ER_INVALID_USE_OF_NULL = 1138;
|
|
exports.ER_REGEXP_ERROR = 1139;
|
|
exports.ER_MIX_OF_GROUP_FUNC_AND_FIELDS = 1140;
|
|
exports.ER_NONEXISTING_GRANT = 1141;
|
|
exports.ER_TABLEACCESS_DENIED_ERROR = 1142;
|
|
exports.ER_COLUMNACCESS_DENIED_ERROR = 1143;
|
|
exports.ER_ILLEGAL_GRANT_FOR_TABLE = 1144;
|
|
exports.ER_GRANT_WRONG_HOST_OR_USER = 1145;
|
|
exports.ER_NO_SUCH_TABLE = 1146;
|
|
exports.ER_NONEXISTING_TABLE_GRANT = 1147;
|
|
exports.ER_NOT_ALLOWED_COMMAND = 1148;
|
|
exports.ER_SYNTAX_ERROR = 1149;
|
|
exports.ER_DELAYED_CANT_CHANGE_LOCK = 1150;
|
|
exports.ER_TOO_MANY_DELAYED_THREADS = 1151;
|
|
exports.ER_ABORTING_CONNECTION = 1152;
|
|
exports.ER_NET_PACKET_TOO_LARGE = 1153;
|
|
exports.ER_NET_READ_ERROR_FROM_PIPE = 1154;
|
|
exports.ER_NET_FCNTL_ERROR = 1155;
|
|
exports.ER_NET_PACKETS_OUT_OF_ORDER = 1156;
|
|
exports.ER_NET_UNCOMPRESS_ERROR = 1157;
|
|
exports.ER_NET_READ_ERROR = 1158;
|
|
exports.ER_NET_READ_INTERRUPTED = 1159;
|
|
exports.ER_NET_ERROR_ON_WRITE = 1160;
|
|
exports.ER_NET_WRITE_INTERRUPTED = 1161;
|
|
exports.ER_TOO_LONG_STRING = 1162;
|
|
exports.ER_TABLE_CANT_HANDLE_BLOB = 1163;
|
|
exports.ER_TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164;
|
|
exports.ER_DELAYED_INSERT_TABLE_LOCKED = 1165;
|
|
exports.ER_WRONG_COLUMN_NAME = 1166;
|
|
exports.ER_WRONG_KEY_COLUMN = 1167;
|
|
exports.ER_WRONG_MRG_TABLE = 1168;
|
|
exports.ER_DUP_UNIQUE = 1169;
|
|
exports.ER_BLOB_KEY_WITHOUT_LENGTH = 1170;
|
|
exports.ER_PRIMARY_CANT_HAVE_NULL = 1171;
|
|
exports.ER_TOO_MANY_ROWS = 1172;
|
|
exports.ER_REQUIRES_PRIMARY_KEY = 1173;
|
|
exports.ER_NO_RAID_COMPILED = 1174;
|
|
exports.ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175;
|
|
exports.ER_KEY_DOES_NOT_EXITS = 1176;
|
|
exports.ER_CHECK_NO_SUCH_TABLE = 1177;
|
|
exports.ER_CHECK_NOT_IMPLEMENTED = 1178;
|
|
exports.ER_CANT_DO_THIS_DURING_AN_TRANSACTION = 1179;
|
|
exports.ER_ERROR_DURING_COMMIT = 1180;
|
|
exports.ER_ERROR_DURING_ROLLBACK = 1181;
|
|
exports.ER_ERROR_DURING_FLUSH_LOGS = 1182;
|
|
exports.ER_ERROR_DURING_CHECKPOINT = 1183;
|
|
exports.ER_NEW_ABORTING_CONNECTION = 1184;
|
|
exports.ER_DUMP_NOT_IMPLEMENTED = 1185;
|
|
exports.ER_FLUSH_MASTER_BINLOG_CLOSED = 1186;
|
|
exports.ER_INDEX_REBUILD = 1187;
|
|
exports.ER_MASTER = 1188;
|
|
exports.ER_MASTER_NET_READ = 1189;
|
|
exports.ER_MASTER_NET_WRITE = 1190;
|
|
exports.ER_FT_MATCHING_KEY_NOT_FOUND = 1191;
|
|
exports.ER_LOCK_OR_ACTIVE_TRANSACTION = 1192;
|
|
exports.ER_UNKNOWN_SYSTEM_VARIABLE = 1193;
|
|
exports.ER_CRASHED_ON_USAGE = 1194;
|
|
exports.ER_CRASHED_ON_REPAIR = 1195;
|
|
exports.ER_WARNING_NOT_COMPLETE_ROLLBACK = 1196;
|
|
exports.ER_TRANS_CACHE_FULL = 1197;
|
|
exports.ER_SLAVE_MUST_STOP = 1198;
|
|
exports.ER_SLAVE_NOT_RUNNING = 1199;
|
|
exports.ER_BAD_SLAVE = 1200;
|
|
exports.ER_MASTER_INFO = 1201;
|
|
exports.ER_SLAVE_THREAD = 1202;
|
|
exports.ER_TOO_MANY_USER_CONNECTIONS = 1203;
|
|
exports.ER_SET_CONSTANTS_ONLY = 1204;
|
|
exports.ER_LOCK_WAIT_TIMEOUT = 1205;
|
|
exports.ER_LOCK_TABLE_FULL = 1206;
|
|
exports.ER_READ_ONLY_TRANSACTION = 1207;
|
|
exports.ER_DROP_DB_WITH_READ_LOCK = 1208;
|
|
exports.ER_CREATE_DB_WITH_READ_LOCK = 1209;
|
|
exports.ER_WRONG_ARGUMENTS = 1210;
|
|
exports.ER_NO_PERMISSION_TO_CREATE_USER = 1211;
|
|
exports.ER_UNION_TABLES_IN_DIFFERENT_DIR = 1212;
|
|
exports.ER_LOCK_DEADLOCK = 1213;
|
|
exports.ER_TABLE_CANT_HANDLE_FT = 1214;
|
|
exports.ER_CANNOT_ADD_FOREIGN = 1215;
|
|
exports.ER_NO_REFERENCED_ROW = 1216;
|
|
exports.ER_ROW_IS_REFERENCED = 1217;
|
|
exports.ER_CONNECT_TO_MASTER = 1218;
|
|
exports.ER_QUERY_ON_MASTER = 1219;
|
|
exports.ER_ERROR_WHEN_EXECUTING_COMMAND = 1220;
|
|
exports.ER_WRONG_USAGE = 1221;
|
|
exports.ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222;
|
|
exports.ER_CANT_UPDATE_WITH_READLOCK = 1223;
|
|
exports.ER_MIXING_NOT_ALLOWED = 1224;
|
|
exports.ER_DUP_ARGUMENT = 1225;
|
|
exports.ER_USER_LIMIT_REACHED = 1226;
|
|
exports.ER_SPECIFIC_ACCESS_DENIED_ERROR = 1227;
|
|
exports.ER_LOCAL_VARIABLE = 1228;
|
|
exports.ER_GLOBAL_VARIABLE = 1229;
|
|
exports.ER_NO_DEFAULT = 1230;
|
|
exports.ER_WRONG_VALUE_FOR_VAR = 1231;
|
|
exports.ER_WRONG_TYPE_FOR_VAR = 1232;
|
|
exports.ER_VAR_CANT_BE_READ = 1233;
|
|
exports.ER_CANT_USE_OPTION_HERE = 1234;
|
|
exports.ER_NOT_SUPPORTED_YET = 1235;
|
|
exports.ER_MASTER_FATAL_ERROR_READING_BINLOG = 1236;
|
|
exports.ER_SLAVE_IGNORED_TABLE = 1237;
|
|
exports.ER_INCORRECT_GLOBAL_LOCAL_VAR = 1238;
|
|
exports.ER_WRONG_FK_DEF = 1239;
|
|
exports.ER_KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240;
|
|
exports.ER_OPERAND_COLUMNS = 1241;
|
|
exports.ER_SUBQUERY_NO_1_ROW = 1242;
|
|
exports.ER_UNKNOWN_STMT_HANDLER = 1243;
|
|
exports.ER_CORRUPT_HELP_DB = 1244;
|
|
exports.ER_CYCLIC_REFERENCE = 1245;
|
|
exports.ER_AUTO_CONVERT = 1246;
|
|
exports.ER_ILLEGAL_REFERENCE = 1247;
|
|
exports.ER_DERIVED_MUST_HAVE_ALIAS = 1248;
|
|
exports.ER_SELECT_REDUCED = 1249;
|
|
exports.ER_TABLENAME_NOT_ALLOWED_HERE = 1250;
|
|
exports.ER_NOT_SUPPORTED_AUTH_MODE = 1251;
|
|
exports.ER_SPATIAL_CANT_HAVE_NULL = 1252;
|
|
exports.ER_COLLATION_CHARSET_MISMATCH = 1253;
|
|
exports.ER_SLAVE_WAS_RUNNING = 1254;
|
|
exports.ER_SLAVE_WAS_NOT_RUNNING = 1255;
|
|
exports.ER_TOO_BIG_FOR_UNCOMPRESS = 1256;
|
|
exports.ER_ZLIB_Z_MEM_ERROR = 1257;
|
|
exports.ER_ZLIB_Z_BUF_ERROR = 1258;
|
|
exports.ER_ZLIB_Z_DATA_ERROR = 1259;
|
|
exports.ER_CUT_VALUE_GROUP_CONCAT = 1260;
|
|
exports.ER_WARN_TOO_FEW_RECORDS = 1261;
|
|
exports.ER_WARN_TOO_MANY_RECORDS = 1262;
|
|
exports.ER_WARN_NULL_TO_NOTNULL = 1263;
|
|
exports.ER_WARN_DATA_OUT_OF_RANGE = 1264;
|
|
exports.WARN_DATA_TRUNCATED = 1265;
|
|
exports.ER_WARN_USING_OTHER_HANDLER = 1266;
|
|
exports.ER_CANT_AGGREGATE_2COLLATIONS = 1267;
|
|
exports.ER_DROP_USER = 1268;
|
|
exports.ER_REVOKE_GRANTS = 1269;
|
|
exports.ER_CANT_AGGREGATE_3COLLATIONS = 1270;
|
|
exports.ER_CANT_AGGREGATE_NCOLLATIONS = 1271;
|
|
exports.ER_VARIABLE_IS_NOT_STRUCT = 1272;
|
|
exports.ER_UNKNOWN_COLLATION = 1273;
|
|
exports.ER_SLAVE_IGNORED_SSL_PARAMS = 1274;
|
|
exports.ER_SERVER_IS_IN_SECURE_AUTH_MODE = 1275;
|
|
exports.ER_WARN_FIELD_RESOLVED = 1276;
|
|
exports.ER_BAD_SLAVE_UNTIL_COND = 1277;
|
|
exports.ER_MISSING_SKIP_SLAVE = 1278;
|
|
exports.ER_UNTIL_COND_IGNORED = 1279;
|
|
exports.ER_WRONG_NAME_FOR_INDEX = 1280;
|
|
exports.ER_WRONG_NAME_FOR_CATALOG = 1281;
|
|
exports.ER_WARN_QC_RESIZE = 1282;
|
|
exports.ER_BAD_FT_COLUMN = 1283;
|
|
exports.ER_UNKNOWN_KEY_CACHE = 1284;
|
|
exports.ER_WARN_HOSTNAME_WONT_WORK = 1285;
|
|
exports.ER_UNKNOWN_STORAGE_ENGINE = 1286;
|
|
exports.ER_WARN_DEPRECATED_SYNTAX = 1287;
|
|
exports.ER_NON_UPDATABLE_TABLE = 1288;
|
|
exports.ER_FEATURE_DISABLED = 1289;
|
|
exports.ER_OPTION_PREVENTS_STATEMENT = 1290;
|
|
exports.ER_DUPLICATED_VALUE_IN_TYPE = 1291;
|
|
exports.ER_TRUNCATED_WRONG_VALUE = 1292;
|
|
exports.ER_TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293;
|
|
exports.ER_INVALID_ON_UPDATE = 1294;
|
|
exports.ER_UNSUPPORTED_PS = 1295;
|
|
exports.ER_GET_ERRMSG = 1296;
|
|
exports.ER_GET_TEMPORARY_ERRMSG = 1297;
|
|
exports.ER_UNKNOWN_TIME_ZONE = 1298;
|
|
exports.ER_WARN_INVALID_TIMESTAMP = 1299;
|
|
exports.ER_INVALID_CHARACTER_STRING = 1300;
|
|
exports.ER_WARN_ALLOWED_PACKET_OVERFLOWED = 1301;
|
|
exports.ER_CONFLICTING_DECLARATIONS = 1302;
|
|
exports.ER_SP_NO_RECURSIVE_CREATE = 1303;
|
|
exports.ER_SP_ALREADY_EXISTS = 1304;
|
|
exports.ER_SP_DOES_NOT_EXIST = 1305;
|
|
exports.ER_SP_DROP_FAILED = 1306;
|
|
exports.ER_SP_STORE_FAILED = 1307;
|
|
exports.ER_SP_LILABEL_MISMATCH = 1308;
|
|
exports.ER_SP_LABEL_REDEFINE = 1309;
|
|
exports.ER_SP_LABEL_MISMATCH = 1310;
|
|
exports.ER_SP_UNINIT_VAR = 1311;
|
|
exports.ER_SP_BADSELECT = 1312;
|
|
exports.ER_SP_BADRETURN = 1313;
|
|
exports.ER_SP_BADSTATEMENT = 1314;
|
|
exports.ER_UPDATE_LOG_DEPRECATED_IGNORED = 1315;
|
|
exports.ER_UPDATE_LOG_DEPRECATED_TRANSLATED = 1316;
|
|
exports.ER_QUERY_INTERRUPTED = 1317;
|
|
exports.ER_SP_WRONG_NO_OF_ARGS = 1318;
|
|
exports.ER_SP_COND_MISMATCH = 1319;
|
|
exports.ER_SP_NORETURN = 1320;
|
|
exports.ER_SP_NORETURNEND = 1321;
|
|
exports.ER_SP_BAD_CURSOR_QUERY = 1322;
|
|
exports.ER_SP_BAD_CURSOR_SELECT = 1323;
|
|
exports.ER_SP_CURSOR_MISMATCH = 1324;
|
|
exports.ER_SP_CURSOR_ALREADY_OPEN = 1325;
|
|
exports.ER_SP_CURSOR_NOT_OPEN = 1326;
|
|
exports.ER_SP_UNDECLARED_VAR = 1327;
|
|
exports.ER_SP_WRONG_NO_OF_FETCH_ARGS = 1328;
|
|
exports.ER_SP_FETCH_NO_DATA = 1329;
|
|
exports.ER_SP_DUP_PARAM = 1330;
|
|
exports.ER_SP_DUP_VAR = 1331;
|
|
exports.ER_SP_DUP_COND = 1332;
|
|
exports.ER_SP_DUP_CURS = 1333;
|
|
exports.ER_SP_CANT_ALTER = 1334;
|
|
exports.ER_SP_SUBSELECT_NYI = 1335;
|
|
exports.ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336;
|
|
exports.ER_SP_VARCOND_AFTER_CURSHNDLR = 1337;
|
|
exports.ER_SP_CURSOR_AFTER_HANDLER = 1338;
|
|
exports.ER_SP_CASE_NOT_FOUND = 1339;
|
|
exports.ER_FPARSER_TOO_BIG_FILE = 1340;
|
|
exports.ER_FPARSER_BAD_HEADER = 1341;
|
|
exports.ER_FPARSER_EOF_IN_COMMENT = 1342;
|
|
exports.ER_FPARSER_ERROR_IN_PARAMETER = 1343;
|
|
exports.ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344;
|
|
exports.ER_VIEW_NO_EXPLAIN = 1345;
|
|
exports.ER_FRM_UNKNOWN_TYPE = 1346;
|
|
exports.ER_WRONG_OBJECT = 1347;
|
|
exports.ER_NONUPDATEABLE_COLUMN = 1348;
|
|
exports.ER_VIEW_SELECT_DERIVED = 1349;
|
|
exports.ER_VIEW_SELECT_CLAUSE = 1350;
|
|
exports.ER_VIEW_SELECT_VARIABLE = 1351;
|
|
exports.ER_VIEW_SELECT_TMPTABLE = 1352;
|
|
exports.ER_VIEW_WRONG_LIST = 1353;
|
|
exports.ER_WARN_VIEW_MERGE = 1354;
|
|
exports.ER_WARN_VIEW_WITHOUT_KEY = 1355;
|
|
exports.ER_VIEW_INVALID = 1356;
|
|
exports.ER_SP_NO_DROP_SP = 1357;
|
|
exports.ER_SP_GOTO_IN_HNDLR = 1358;
|
|
exports.ER_TRG_ALREADY_EXISTS = 1359;
|
|
exports.ER_TRG_DOES_NOT_EXIST = 1360;
|
|
exports.ER_TRG_ON_VIEW_OR_TEMP_TABLE = 1361;
|
|
exports.ER_TRG_CANT_CHANGE_ROW = 1362;
|
|
exports.ER_TRG_NO_SUCH_ROW_IN_TRG = 1363;
|
|
exports.ER_NO_DEFAULT_FOR_FIELD = 1364;
|
|
exports.ER_DIVISION_BY_ZERO = 1365;
|
|
exports.ER_TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366;
|
|
exports.ER_ILLEGAL_VALUE_FOR_TYPE = 1367;
|
|
exports.ER_VIEW_NONUPD_CHECK = 1368;
|
|
exports.ER_VIEW_CHECK_FAILED = 1369;
|
|
exports.ER_PROCACCESS_DENIED_ERROR = 1370;
|
|
exports.ER_RELAY_LOG_FAIL = 1371;
|
|
exports.ER_PASSWD_LENGTH = 1372;
|
|
exports.ER_UNKNOWN_TARGET_BINLOG = 1373;
|
|
exports.ER_IO_ERR_LOG_INDEX_READ = 1374;
|
|
exports.ER_BINLOG_PURGE_PROHIBITED = 1375;
|
|
exports.ER_FSEEK_FAIL = 1376;
|
|
exports.ER_BINLOG_PURGE_FATAL_ERR = 1377;
|
|
exports.ER_LOG_IN_USE = 1378;
|
|
exports.ER_LOG_PURGE_UNKNOWN_ERR = 1379;
|
|
exports.ER_RELAY_LOG_INIT = 1380;
|
|
exports.ER_NO_BINARY_LOGGING = 1381;
|
|
exports.ER_RESERVED_SYNTAX = 1382;
|
|
exports.ER_WSAS_FAILED = 1383;
|
|
exports.ER_DIFF_GROUPS_PROC = 1384;
|
|
exports.ER_NO_GROUP_FOR_PROC = 1385;
|
|
exports.ER_ORDER_WITH_PROC = 1386;
|
|
exports.ER_LOGGING_PROHIBIT_CHANGING_OF = 1387;
|
|
exports.ER_NO_FILE_MAPPING = 1388;
|
|
exports.ER_WRONG_MAGIC = 1389;
|
|
exports.ER_PS_MANY_PARAM = 1390;
|
|
exports.ER_KEY_PART_0 = 1391;
|
|
exports.ER_VIEW_CHECKSUM = 1392;
|
|
exports.ER_VIEW_MULTIUPDATE = 1393;
|
|
exports.ER_VIEW_NO_INSERT_FIELD_LIST = 1394;
|
|
exports.ER_VIEW_DELETE_MERGE_VIEW = 1395;
|
|
exports.ER_CANNOT_USER = 1396;
|
|
exports.ER_XAER_NOTA = 1397;
|
|
exports.ER_XAER_INVAL = 1398;
|
|
exports.ER_XAER_RMFAIL = 1399;
|
|
exports.ER_XAER_OUTSIDE = 1400;
|
|
exports.ER_XAER_RMERR = 1401;
|
|
exports.ER_XA_RBROLLBACK = 1402;
|
|
exports.ER_NONEXISTING_PROC_GRANT = 1403;
|
|
exports.ER_PROC_AUTO_GRANT_FAIL = 1404;
|
|
exports.ER_PROC_AUTO_REVOKE_FAIL = 1405;
|
|
exports.ER_DATA_TOO_LONG = 1406;
|
|
exports.ER_SP_BAD_SQLSTATE = 1407;
|
|
exports.ER_STARTUP = 1408;
|
|
exports.ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409;
|
|
exports.ER_CANT_CREATE_USER_WITH_GRANT = 1410;
|
|
exports.ER_WRONG_VALUE_FOR_TYPE = 1411;
|
|
exports.ER_TABLE_DEF_CHANGED = 1412;
|
|
exports.ER_SP_DUP_HANDLER = 1413;
|
|
exports.ER_SP_NOT_VAR_ARG = 1414;
|
|
exports.ER_SP_NO_RETSET = 1415;
|
|
exports.ER_CANT_CREATE_GEOMETRY_OBJECT = 1416;
|
|
exports.ER_FAILED_ROUTINE_BREAK_BINLOG = 1417;
|
|
exports.ER_BINLOG_UNSAFE_ROUTINE = 1418;
|
|
exports.ER_BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419;
|
|
exports.ER_EXEC_STMT_WITH_OPEN_CURSOR = 1420;
|
|
exports.ER_STMT_HAS_NO_OPEN_CURSOR = 1421;
|
|
exports.ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422;
|
|
exports.ER_NO_DEFAULT_FOR_VIEW_FIELD = 1423;
|
|
exports.ER_SP_NO_RECURSION = 1424;
|
|
exports.ER_TOO_BIG_SCALE = 1425;
|
|
exports.ER_TOO_BIG_PRECISION = 1426;
|
|
exports.ER_M_BIGGER_THAN_D = 1427;
|
|
exports.ER_WRONG_LOCK_OF_SYSTEM_TABLE = 1428;
|
|
exports.ER_CONNECT_TO_FOREIGN_DATA_SOURCE = 1429;
|
|
exports.ER_QUERY_ON_FOREIGN_DATA_SOURCE = 1430;
|
|
exports.ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431;
|
|
exports.ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432;
|
|
exports.ER_FOREIGN_DATA_STRING_INVALID = 1433;
|
|
exports.ER_CANT_CREATE_FEDERATED_TABLE = 1434;
|
|
exports.ER_TRG_IN_WRONG_SCHEMA = 1435;
|
|
exports.ER_STACK_OVERRUN_NEED_MORE = 1436;
|
|
exports.ER_TOO_LONG_BODY = 1437;
|
|
exports.ER_WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438;
|
|
exports.ER_TOO_BIG_DISPLAYWIDTH = 1439;
|
|
exports.ER_XAER_DUPID = 1440;
|
|
exports.ER_DATETIME_FUNCTION_OVERFLOW = 1441;
|
|
exports.ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442;
|
|
exports.ER_VIEW_PREVENT_UPDATE = 1443;
|
|
exports.ER_PS_NO_RECURSION = 1444;
|
|
exports.ER_SP_CANT_SET_AUTOCOMMIT = 1445;
|
|
exports.ER_MALFORMED_DEFINER = 1446;
|
|
exports.ER_VIEW_FRM_NO_USER = 1447;
|
|
exports.ER_VIEW_OTHER_USER = 1448;
|
|
exports.ER_NO_SUCH_USER = 1449;
|
|
exports.ER_FORBID_SCHEMA_CHANGE = 1450;
|
|
exports.ER_ROW_IS_REFERENCED_2 = 1451;
|
|
exports.ER_NO_REFERENCED_ROW_2 = 1452;
|
|
exports.ER_SP_BAD_VAR_SHADOW = 1453;
|
|
exports.ER_TRG_NO_DEFINER = 1454;
|
|
exports.ER_OLD_FILE_FORMAT = 1455;
|
|
exports.ER_SP_RECURSION_LIMIT = 1456;
|
|
exports.ER_SP_PROC_TABLE_CORRUPT = 1457;
|
|
exports.ER_SP_WRONG_NAME = 1458;
|
|
exports.ER_TABLE_NEEDS_UPGRADE = 1459;
|
|
exports.ER_SP_NO_AGGREGATE = 1460;
|
|
exports.ER_MAX_PREPARED_STMT_COUNT_REACHED = 1461;
|
|
exports.ER_VIEW_RECURSIVE = 1462;
|
|
exports.ER_NON_GROUPING_FIELD_USED = 1463;
|
|
exports.ER_TABLE_CANT_HANDLE_SPKEYS = 1464;
|
|
exports.ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465;
|
|
exports.ER_REMOVED_SPACES = 1466;
|
|
exports.ER_AUTOINC_READ_FAILED = 1467;
|
|
exports.ER_USERNAME = 1468;
|
|
exports.ER_HOSTNAME = 1469;
|
|
exports.ER_WRONG_STRING_LENGTH = 1470;
|
|
exports.ER_NON_INSERTABLE_TABLE = 1471;
|
|
exports.ER_ADMIN_WRONG_MRG_TABLE = 1472;
|
|
exports.ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT = 1473;
|
|
exports.ER_NAME_BECOMES_EMPTY = 1474;
|
|
exports.ER_AMBIGUOUS_FIELD_TERM = 1475;
|
|
exports.ER_FOREIGN_SERVER_EXISTS = 1476;
|
|
exports.ER_FOREIGN_SERVER_DOESNT_EXIST = 1477;
|
|
exports.ER_ILLEGAL_HA_CREATE_OPTION = 1478;
|
|
exports.ER_PARTITION_REQUIRES_VALUES_ERROR = 1479;
|
|
exports.ER_PARTITION_WRONG_VALUES_ERROR = 1480;
|
|
exports.ER_PARTITION_MAXVALUE_ERROR = 1481;
|
|
exports.ER_PARTITION_SUBPARTITION_ERROR = 1482;
|
|
exports.ER_PARTITION_SUBPART_MIX_ERROR = 1483;
|
|
exports.ER_PARTITION_WRONG_NO_PART_ERROR = 1484;
|
|
exports.ER_PARTITION_WRONG_NO_SUBPART_ERROR = 1485;
|
|
exports.ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR = 1486;
|
|
exports.ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR = 1487;
|
|
exports.ER_FIELD_NOT_FOUND_PART_ERROR = 1488;
|
|
exports.ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR = 1489;
|
|
exports.ER_INCONSISTENT_PARTITION_INFO_ERROR = 1490;
|
|
exports.ER_PARTITION_FUNC_NOT_ALLOWED_ERROR = 1491;
|
|
exports.ER_PARTITIONS_MUST_BE_DEFINED_ERROR = 1492;
|
|
exports.ER_RANGE_NOT_INCREASING_ERROR = 1493;
|
|
exports.ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR = 1494;
|
|
exports.ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR = 1495;
|
|
exports.ER_PARTITION_ENTRY_ERROR = 1496;
|
|
exports.ER_MIX_HANDLER_ERROR = 1497;
|
|
exports.ER_PARTITION_NOT_DEFINED_ERROR = 1498;
|
|
exports.ER_TOO_MANY_PARTITIONS_ERROR = 1499;
|
|
exports.ER_SUBPARTITION_ERROR = 1500;
|
|
exports.ER_CANT_CREATE_HANDLER_FILE = 1501;
|
|
exports.ER_BLOB_FIELD_IN_PART_FUNC_ERROR = 1502;
|
|
exports.ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF = 1503;
|
|
exports.ER_NO_PARTS_ERROR = 1504;
|
|
exports.ER_PARTITION_MGMT_ON_NONPARTITIONED = 1505;
|
|
exports.ER_FOREIGN_KEY_ON_PARTITIONED = 1506;
|
|
exports.ER_DROP_PARTITION_NON_EXISTENT = 1507;
|
|
exports.ER_DROP_LAST_PARTITION = 1508;
|
|
exports.ER_COALESCE_ONLY_ON_HASH_PARTITION = 1509;
|
|
exports.ER_REORG_HASH_ONLY_ON_SAME_NO = 1510;
|
|
exports.ER_REORG_NO_PARAM_ERROR = 1511;
|
|
exports.ER_ONLY_ON_RANGE_LIST_PARTITION = 1512;
|
|
exports.ER_ADD_PARTITION_SUBPART_ERROR = 1513;
|
|
exports.ER_ADD_PARTITION_NO_NEW_PARTITION = 1514;
|
|
exports.ER_COALESCE_PARTITION_NO_PARTITION = 1515;
|
|
exports.ER_REORG_PARTITION_NOT_EXIST = 1516;
|
|
exports.ER_SAME_NAME_PARTITION = 1517;
|
|
exports.ER_NO_BINLOG_ERROR = 1518;
|
|
exports.ER_CONSECUTIVE_REORG_PARTITIONS = 1519;
|
|
exports.ER_REORG_OUTSIDE_RANGE = 1520;
|
|
exports.ER_PARTITION_FUNCTION_FAILURE = 1521;
|
|
exports.ER_PART_STATE_ERROR = 1522;
|
|
exports.ER_LIMITED_PART_RANGE = 1523;
|
|
exports.ER_PLUGIN_IS_NOT_LOADED = 1524;
|
|
exports.ER_WRONG_VALUE = 1525;
|
|
exports.ER_NO_PARTITION_FOR_GIVEN_VALUE = 1526;
|
|
exports.ER_FILEGROUP_OPTION_ONLY_ONCE = 1527;
|
|
exports.ER_CREATE_FILEGROUP_FAILED = 1528;
|
|
exports.ER_DROP_FILEGROUP_FAILED = 1529;
|
|
exports.ER_TABLESPACE_AUTO_EXTEND_ERROR = 1530;
|
|
exports.ER_WRONG_SIZE_NUMBER = 1531;
|
|
exports.ER_SIZE_OVERFLOW_ERROR = 1532;
|
|
exports.ER_ALTER_FILEGROUP_FAILED = 1533;
|
|
exports.ER_BINLOG_ROW_LOGGING_FAILED = 1534;
|
|
exports.ER_BINLOG_ROW_WRONG_TABLE_DEF = 1535;
|
|
exports.ER_BINLOG_ROW_RBR_TO_SBR = 1536;
|
|
exports.ER_EVENT_ALREADY_EXISTS = 1537;
|
|
exports.ER_EVENT_STORE_FAILED = 1538;
|
|
exports.ER_EVENT_DOES_NOT_EXIST = 1539;
|
|
exports.ER_EVENT_CANT_ALTER = 1540;
|
|
exports.ER_EVENT_DROP_FAILED = 1541;
|
|
exports.ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG = 1542;
|
|
exports.ER_EVENT_ENDS_BEFORE_STARTS = 1543;
|
|
exports.ER_EVENT_EXEC_TIME_IN_THE_PAST = 1544;
|
|
exports.ER_EVENT_OPEN_TABLE_FAILED = 1545;
|
|
exports.ER_EVENT_NEITHER_M_EXPR_NOR_M_AT = 1546;
|
|
exports.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED = 1547;
|
|
exports.ER_CANNOT_LOAD_FROM_TABLE = 1548;
|
|
exports.ER_EVENT_CANNOT_DELETE = 1549;
|
|
exports.ER_EVENT_COMPILE_ERROR = 1550;
|
|
exports.ER_EVENT_SAME_NAME = 1551;
|
|
exports.ER_EVENT_DATA_TOO_LONG = 1552;
|
|
exports.ER_DROP_INDEX_FK = 1553;
|
|
exports.ER_WARN_DEPRECATED_SYNTAX_WITH_VER = 1554;
|
|
exports.ER_CANT_WRITE_LOCK_LOG_TABLE = 1555;
|
|
exports.ER_CANT_LOCK_LOG_TABLE = 1556;
|
|
exports.ER_FOREIGN_DUPLICATE_KEY = 1557;
|
|
exports.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE = 1558;
|
|
exports.ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR = 1559;
|
|
exports.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1560;
|
|
exports.ER_NDB_CANT_SWITCH_BINLOG_FORMAT = 1561;
|
|
exports.ER_PARTITION_NO_TEMPORARY = 1562;
|
|
exports.ER_PARTITION_CONST_DOMAIN_ERROR = 1563;
|
|
exports.ER_PARTITION_FUNCTION_IS_NOT_ALLOWED = 1564;
|
|
exports.ER_DDL_LOG_ERROR = 1565;
|
|
exports.ER_NULL_IN_VALUES_LESS_THAN = 1566;
|
|
exports.ER_WRONG_PARTITION_NAME = 1567;
|
|
exports.ER_CANT_CHANGE_TX_CHARACTERISTICS = 1568;
|
|
exports.ER_DUP_ENTRY_AUTOINCREMENT_CASE = 1569;
|
|
exports.ER_EVENT_MODIFY_QUEUE_ERROR = 1570;
|
|
exports.ER_EVENT_SET_VAR_ERROR = 1571;
|
|
exports.ER_PARTITION_MERGE_ERROR = 1572;
|
|
exports.ER_CANT_ACTIVATE_LOG = 1573;
|
|
exports.ER_RBR_NOT_AVAILABLE = 1574;
|
|
exports.ER_BASE64_DECODE_ERROR = 1575;
|
|
exports.ER_EVENT_RECURSION_FORBIDDEN = 1576;
|
|
exports.ER_EVENTS_DB_ERROR = 1577;
|
|
exports.ER_ONLY_INTEGERS_ALLOWED = 1578;
|
|
exports.ER_UNSUPORTED_LOG_ENGINE = 1579;
|
|
exports.ER_BAD_LOG_STATEMENT = 1580;
|
|
exports.ER_CANT_RENAME_LOG_TABLE = 1581;
|
|
exports.ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT = 1582;
|
|
exports.ER_WRONG_PARAMETERS_TO_NATIVE_FCT = 1583;
|
|
exports.ER_WRONG_PARAMETERS_TO_STORED_FCT = 1584;
|
|
exports.ER_NATIVE_FCT_NAME_COLLISION = 1585;
|
|
exports.ER_DUP_ENTRY_WITH_KEY_NAME = 1586;
|
|
exports.ER_BINLOG_PURGE_EMFILE = 1587;
|
|
exports.ER_EVENT_CANNOT_CREATE_IN_THE_PAST = 1588;
|
|
exports.ER_EVENT_CANNOT_ALTER_IN_THE_PAST = 1589;
|
|
exports.ER_SLAVE_INCIDENT = 1590;
|
|
exports.ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT = 1591;
|
|
exports.ER_BINLOG_UNSAFE_STATEMENT = 1592;
|
|
exports.ER_SLAVE_FATAL_ERROR = 1593;
|
|
exports.ER_SLAVE_RELAY_LOG_READ_FAILURE = 1594;
|
|
exports.ER_SLAVE_RELAY_LOG_WRITE_FAILURE = 1595;
|
|
exports.ER_SLAVE_CREATE_EVENT_FAILURE = 1596;
|
|
exports.ER_SLAVE_MASTER_COM_FAILURE = 1597;
|
|
exports.ER_BINLOG_LOGGING_IMPOSSIBLE = 1598;
|
|
exports.ER_VIEW_NO_CREATION_CTX = 1599;
|
|
exports.ER_VIEW_INVALID_CREATION_CTX = 1600;
|
|
exports.ER_SR_INVALID_CREATION_CTX = 1601;
|
|
exports.ER_TRG_CORRUPTED_FILE = 1602;
|
|
exports.ER_TRG_NO_CREATION_CTX = 1603;
|
|
exports.ER_TRG_INVALID_CREATION_CTX = 1604;
|
|
exports.ER_EVENT_INVALID_CREATION_CTX = 1605;
|
|
exports.ER_TRG_CANT_OPEN_TABLE = 1606;
|
|
exports.ER_CANT_CREATE_SROUTINE = 1607;
|
|
exports.ER_NEVER_USED = 1608;
|
|
exports.ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT = 1609;
|
|
exports.ER_SLAVE_CORRUPT_EVENT = 1610;
|
|
exports.ER_LOAD_DATA_INVALID_COLUMN = 1611;
|
|
exports.ER_LOG_PURGE_NO_FILE = 1612;
|
|
exports.ER_XA_RBTIMEOUT = 1613;
|
|
exports.ER_XA_RBDEADLOCK = 1614;
|
|
exports.ER_NEED_REPREPARE = 1615;
|
|
exports.ER_DELAYED_NOT_SUPPORTED = 1616;
|
|
exports.WARN_NO_MASTER_INFO = 1617;
|
|
exports.WARN_OPTION_IGNORED = 1618;
|
|
exports.ER_PLUGIN_DELETE_BUILTIN = 1619;
|
|
exports.WARN_PLUGIN_BUSY = 1620;
|
|
exports.ER_VARIABLE_IS_READONLY = 1621;
|
|
exports.ER_WARN_ENGINE_TRANSACTION_ROLLBACK = 1622;
|
|
exports.ER_SLAVE_HEARTBEAT_FAILURE = 1623;
|
|
exports.ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624;
|
|
exports.ER_NDB_REPLICATION_SCHEMA_ERROR = 1625;
|
|
exports.ER_CONFLICT_FN_PARSE_ERROR = 1626;
|
|
exports.ER_EXCEPTIONS_WRITE_ERROR = 1627;
|
|
exports.ER_TOO_LONG_TABLE_COMMENT = 1628;
|
|
exports.ER_TOO_LONG_FIELD_COMMENT = 1629;
|
|
exports.ER_FUNC_INEXISTENT_NAME_COLLISION = 1630;
|
|
exports.ER_DATABASE_NAME = 1631;
|
|
exports.ER_TABLE_NAME = 1632;
|
|
exports.ER_PARTITION_NAME = 1633;
|
|
exports.ER_SUBPARTITION_NAME = 1634;
|
|
exports.ER_TEMPORARY_NAME = 1635;
|
|
exports.ER_RENAMED_NAME = 1636;
|
|
exports.ER_TOO_MANY_CONCURRENT_TRXS = 1637;
|
|
exports.WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED = 1638;
|
|
exports.ER_DEBUG_SYNC_TIMEOUT = 1639;
|
|
exports.ER_DEBUG_SYNC_HIT_LIMIT = 1640;
|
|
exports.ER_DUP_SIGNAL_SET = 1641;
|
|
exports.ER_SIGNAL_WARN = 1642;
|
|
exports.ER_SIGNAL_NOT_FOUND = 1643;
|
|
exports.ER_SIGNAL_EXCEPTION = 1644;
|
|
exports.ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER = 1645;
|
|
exports.ER_SIGNAL_BAD_CONDITION_TYPE = 1646;
|
|
exports.WARN_COND_ITEM_TRUNCATED = 1647;
|
|
exports.ER_COND_ITEM_TOO_LONG = 1648;
|
|
exports.ER_UNKNOWN_LOCALE = 1649;
|
|
exports.ER_SLAVE_IGNORE_SERVER_IDS = 1650;
|
|
exports.ER_QUERY_CACHE_DISABLED = 1651;
|
|
exports.ER_SAME_NAME_PARTITION_FIELD = 1652;
|
|
exports.ER_PARTITION_COLUMN_LIST_ERROR = 1653;
|
|
exports.ER_WRONG_TYPE_COLUMN_VALUE_ERROR = 1654;
|
|
exports.ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR = 1655;
|
|
exports.ER_MAXVALUE_IN_VALUES_IN = 1656;
|
|
exports.ER_TOO_MANY_VALUES_ERROR = 1657;
|
|
exports.ER_ROW_SINGLE_PARTITION_FIELD_ERROR = 1658;
|
|
exports.ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD = 1659;
|
|
exports.ER_PARTITION_FIELDS_TOO_LONG = 1660;
|
|
exports.ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE = 1661;
|
|
exports.ER_BINLOG_ROW_MODE_AND_STMT_ENGINE = 1662;
|
|
exports.ER_BINLOG_UNSAFE_AND_STMT_ENGINE = 1663;
|
|
exports.ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE = 1664;
|
|
exports.ER_BINLOG_STMT_MODE_AND_ROW_ENGINE = 1665;
|
|
exports.ER_BINLOG_ROW_INJECTION_AND_STMT_MODE = 1666;
|
|
exports.ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1667;
|
|
exports.ER_BINLOG_UNSAFE_LIMIT = 1668;
|
|
exports.ER_BINLOG_UNSAFE_INSERT_DELAYED = 1669;
|
|
exports.ER_BINLOG_UNSAFE_SYSTEM_TABLE = 1670;
|
|
exports.ER_BINLOG_UNSAFE_AUTOINC_COLUMNS = 1671;
|
|
exports.ER_BINLOG_UNSAFE_UDF = 1672;
|
|
exports.ER_BINLOG_UNSAFE_SYSTEM_VARIABLE = 1673;
|
|
exports.ER_BINLOG_UNSAFE_SYSTEM_FUNCTION = 1674;
|
|
exports.ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS = 1675;
|
|
exports.ER_MESSAGE_AND_STATEMENT = 1676;
|
|
exports.ER_SLAVE_CONVERSION_FAILED = 1677;
|
|
exports.ER_SLAVE_CANT_CREATE_CONVERSION = 1678;
|
|
exports.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1679;
|
|
exports.ER_PATH_LENGTH = 1680;
|
|
exports.ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT = 1681;
|
|
exports.ER_WRONG_NATIVE_TABLE_STRUCTURE = 1682;
|
|
exports.ER_WRONG_PERFSCHEMA_USAGE = 1683;
|
|
exports.ER_WARN_I_S_SKIPPED_TABLE = 1684;
|
|
exports.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1685;
|
|
exports.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1686;
|
|
exports.ER_SPATIAL_MUST_HAVE_GEOM_COL = 1687;
|
|
exports.ER_TOO_LONG_INDEX_COMMENT = 1688;
|
|
exports.ER_LOCK_ABORTED = 1689;
|
|
exports.ER_DATA_OUT_OF_RANGE = 1690;
|
|
exports.ER_WRONG_SPVAR_TYPE_IN_LIMIT = 1691;
|
|
exports.ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1692;
|
|
exports.ER_BINLOG_UNSAFE_MIXED_STATEMENT = 1693;
|
|
exports.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1694;
|
|
exports.ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1695;
|
|
exports.ER_FAILED_READ_FROM_PAR_FILE = 1696;
|
|
exports.ER_VALUES_IS_NOT_INT_TYPE_ERROR = 1697;
|
|
exports.ER_ACCESS_DENIED_NO_PASSWORD_ERROR = 1698;
|
|
exports.ER_SET_PASSWORD_AUTH_PLUGIN = 1699;
|
|
exports.ER_GRANT_PLUGIN_USER_EXISTS = 1700;
|
|
exports.ER_TRUNCATE_ILLEGAL_FK = 1701;
|
|
exports.ER_PLUGIN_IS_PERMANENT = 1702;
|
|
exports.ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703;
|
|
exports.ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704;
|
|
exports.ER_STMT_CACHE_FULL = 1705;
|
|
exports.ER_MULTI_UPDATE_KEY_CONFLICT = 1706;
|
|
exports.ER_TABLE_NEEDS_REBUILD = 1707;
|
|
exports.WARN_OPTION_BELOW_LIMIT = 1708;
|
|
exports.ER_INDEX_COLUMN_TOO_LONG = 1709;
|
|
exports.ER_ERROR_IN_TRIGGER_BODY = 1710;
|
|
exports.ER_ERROR_IN_UNKNOWN_TRIGGER_BODY = 1711;
|
|
exports.ER_INDEX_CORRUPT = 1712;
|
|
exports.ER_UNDO_RECORD_TOO_BIG = 1713;
|
|
exports.ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT = 1714;
|
|
exports.ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE = 1715;
|
|
exports.ER_BINLOG_UNSAFE_REPLACE_SELECT = 1716;
|
|
exports.ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT = 1717;
|
|
exports.ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT = 1718;
|
|
exports.ER_BINLOG_UNSAFE_UPDATE_IGNORE = 1719;
|
|
exports.ER_PLUGIN_NO_UNINSTALL = 1720;
|
|
exports.ER_PLUGIN_NO_INSTALL = 1721;
|
|
exports.ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT = 1722;
|
|
exports.ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC = 1723;
|
|
exports.ER_BINLOG_UNSAFE_INSERT_TWO_KEYS = 1724;
|
|
exports.ER_TABLE_IN_FK_CHECK = 1725;
|
|
exports.ER_UNSUPPORTED_ENGINE = 1726;
|
|
exports.ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST = 1727;
|
|
exports.ER_CANNOT_LOAD_FROM_TABLE_V2 = 1728;
|
|
exports.ER_MASTER_DELAY_VALUE_OUT_OF_RANGE = 1729;
|
|
exports.ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT = 1730;
|
|
exports.ER_PARTITION_EXCHANGE_DIFFERENT_OPTION = 1731;
|
|
exports.ER_PARTITION_EXCHANGE_PART_TABLE = 1732;
|
|
exports.ER_PARTITION_EXCHANGE_TEMP_TABLE = 1733;
|
|
exports.ER_PARTITION_INSTEAD_OF_SUBPARTITION = 1734;
|
|
exports.ER_UNKNOWN_PARTITION = 1735;
|
|
exports.ER_TABLES_DIFFERENT_METADATA = 1736;
|
|
exports.ER_ROW_DOES_NOT_MATCH_PARTITION = 1737;
|
|
exports.ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX = 1738;
|
|
exports.ER_WARN_INDEX_NOT_APPLICABLE = 1739;
|
|
exports.ER_PARTITION_EXCHANGE_FOREIGN_KEY = 1740;
|
|
exports.ER_NO_SUCH_KEY_VALUE = 1741;
|
|
exports.ER_RPL_INFO_DATA_TOO_LONG = 1742;
|
|
exports.ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE = 1743;
|
|
exports.ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE = 1744;
|
|
exports.ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX = 1745;
|
|
exports.ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT = 1746;
|
|
exports.ER_PARTITION_CLAUSE_ON_NONPARTITIONED = 1747;
|
|
exports.ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET = 1748;
|
|
exports.ER_NO_SUCH_PARTITION = 1749;
|
|
exports.ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE = 1750;
|
|
exports.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE = 1751;
|
|
exports.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE = 1752;
|
|
exports.ER_MTS_FEATURE_IS_NOT_SUPPORTED = 1753;
|
|
exports.ER_MTS_UPDATED_DBS_GREATER_MAX = 1754;
|
|
exports.ER_MTS_CANT_PARALLEL = 1755;
|
|
exports.ER_MTS_INCONSISTENT_DATA = 1756;
|
|
exports.ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING = 1757;
|
|
exports.ER_DA_INVALID_CONDITION_NUMBER = 1758;
|
|
exports.ER_INSECURE_PLAIN_TEXT = 1759;
|
|
exports.ER_INSECURE_CHANGE_MASTER = 1760;
|
|
exports.ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO = 1761;
|
|
exports.ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO = 1762;
|
|
exports.ER_SQLTHREAD_WITH_SECURE_SLAVE = 1763;
|
|
exports.ER_TABLE_HAS_NO_FT = 1764;
|
|
exports.ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER = 1765;
|
|
exports.ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION = 1766;
|
|
exports.ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST = 1767;
|
|
exports.ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION = 1768;
|
|
exports.ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION = 1769;
|
|
exports.ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL = 1770;
|
|
exports.ER_SKIPPING_LOGGED_TRANSACTION = 1771;
|
|
exports.ER_MALFORMED_GTID_SET_SPECIFICATION = 1772;
|
|
exports.ER_MALFORMED_GTID_SET_ENCODING = 1773;
|
|
exports.ER_MALFORMED_GTID_SPECIFICATION = 1774;
|
|
exports.ER_GNO_EXHAUSTED = 1775;
|
|
exports.ER_BAD_SLAVE_AUTO_POSITION = 1776;
|
|
exports.ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF = 1777;
|
|
exports.ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET = 1778;
|
|
exports.ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON = 1779;
|
|
exports.ER_GTID_MODE_REQUIRES_BINLOG = 1780;
|
|
exports.ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF = 1781;
|
|
exports.ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON = 1782;
|
|
exports.ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF = 1783;
|
|
exports.ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF = 1784;
|
|
exports.ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE = 1785;
|
|
exports.ER_GTID_UNSAFE_CREATE_SELECT = 1786;
|
|
exports.ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION = 1787;
|
|
exports.ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME = 1788;
|
|
exports.ER_MASTER_HAS_PURGED_REQUIRED_GTIDS = 1789;
|
|
exports.ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID = 1790;
|
|
exports.ER_UNKNOWN_EXPLAIN_FORMAT = 1791;
|
|
exports.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION = 1792;
|
|
exports.ER_TOO_LONG_TABLE_PARTITION_COMMENT = 1793;
|
|
exports.ER_SLAVE_CONFIGURATION = 1794;
|
|
exports.ER_INNODB_FT_LIMIT = 1795;
|
|
exports.ER_INNODB_NO_FT_TEMP_TABLE = 1796;
|
|
exports.ER_INNODB_FT_WRONG_DOCID_COLUMN = 1797;
|
|
exports.ER_INNODB_FT_WRONG_DOCID_INDEX = 1798;
|
|
exports.ER_INNODB_ONLINE_LOG_TOO_BIG = 1799;
|
|
exports.ER_UNKNOWN_ALTER_ALGORITHM = 1800;
|
|
exports.ER_UNKNOWN_ALTER_LOCK = 1801;
|
|
exports.ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS = 1802;
|
|
exports.ER_MTS_RECOVERY_FAILURE = 1803;
|
|
exports.ER_MTS_RESET_WORKERS = 1804;
|
|
exports.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 = 1805;
|
|
exports.ER_SLAVE_SILENT_RETRY_TRANSACTION = 1806;
|
|
exports.ER_DISCARD_FK_CHECKS_RUNNING = 1807;
|
|
exports.ER_TABLE_SCHEMA_MISMATCH = 1808;
|
|
exports.ER_TABLE_IN_SYSTEM_TABLESPACE = 1809;
|
|
exports.ER_IO_READ_ERROR = 1810;
|
|
exports.ER_IO_WRITE_ERROR = 1811;
|
|
exports.ER_TABLESPACE_MISSING = 1812;
|
|
exports.ER_TABLESPACE_EXISTS = 1813;
|
|
exports.ER_TABLESPACE_DISCARDED = 1814;
|
|
exports.ER_INTERNAL_ERROR = 1815;
|
|
exports.ER_INNODB_IMPORT_ERROR = 1816;
|
|
exports.ER_INNODB_INDEX_CORRUPT = 1817;
|
|
exports.ER_INVALID_YEAR_COLUMN_LENGTH = 1818;
|
|
exports.ER_NOT_VALID_PASSWORD = 1819;
|
|
exports.ER_MUST_CHANGE_PASSWORD = 1820;
|
|
exports.ER_FK_NO_INDEX_CHILD = 1821;
|
|
exports.ER_FK_NO_INDEX_PARENT = 1822;
|
|
exports.ER_FK_FAIL_ADD_SYSTEM = 1823;
|
|
exports.ER_FK_CANNOT_OPEN_PARENT = 1824;
|
|
exports.ER_FK_INCORRECT_OPTION = 1825;
|
|
exports.ER_FK_DUP_NAME = 1826;
|
|
exports.ER_PASSWORD_FORMAT = 1827;
|
|
exports.ER_FK_COLUMN_CANNOT_DROP = 1828;
|
|
exports.ER_FK_COLUMN_CANNOT_DROP_CHILD = 1829;
|
|
exports.ER_FK_COLUMN_NOT_NULL = 1830;
|
|
exports.ER_DUP_INDEX = 1831;
|
|
exports.ER_FK_COLUMN_CANNOT_CHANGE = 1832;
|
|
exports.ER_FK_COLUMN_CANNOT_CHANGE_CHILD = 1833;
|
|
exports.ER_FK_CANNOT_DELETE_PARENT = 1834;
|
|
exports.ER_MALFORMED_PACKET = 1835;
|
|
exports.ER_READ_ONLY_MODE = 1836;
|
|
exports.ER_GTID_NEXT_TYPE_UNDEFINED_GROUP = 1837;
|
|
exports.ER_VARIABLE_NOT_SETTABLE_IN_SP = 1838;
|
|
exports.ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF = 1839;
|
|
exports.ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY = 1840;
|
|
exports.ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY = 1841;
|
|
exports.ER_GTID_PURGED_WAS_CHANGED = 1842;
|
|
exports.ER_GTID_EXECUTED_WAS_CHANGED = 1843;
|
|
exports.ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES = 1844;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED = 1845;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON = 1846;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY = 1847;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION = 1848;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME = 1849;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE = 1850;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK = 1851;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_IGNORE = 1852;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK = 1853;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC = 1854;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS = 1855;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS = 1856;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS = 1857;
|
|
exports.ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858;
|
|
exports.ER_DUP_UNKNOWN_IN_INDEX = 1859;
|
|
exports.ER_IDENT_CAUSES_TOO_LONG_PATH = 1860;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL = 1861;
|
|
exports.ER_MUST_CHANGE_PASSWORD_LOGIN = 1862;
|
|
exports.ER_ROW_IN_WRONG_PARTITION = 1863;
|
|
exports.ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX = 1864;
|
|
exports.ER_INNODB_NO_FT_USES_PARSER = 1865;
|
|
exports.ER_BINLOG_LOGICAL_CORRUPTION = 1866;
|
|
exports.ER_WARN_PURGE_LOG_IN_USE = 1867;
|
|
exports.ER_WARN_PURGE_LOG_IS_ACTIVE = 1868;
|
|
exports.ER_AUTO_INCREMENT_CONFLICT = 1869;
|
|
exports.WARN_ON_BLOCKHOLE_IN_RBR = 1870;
|
|
exports.ER_SLAVE_MI_INIT_REPOSITORY = 1871;
|
|
exports.ER_SLAVE_RLI_INIT_REPOSITORY = 1872;
|
|
exports.ER_ACCESS_DENIED_CHANGE_USER_ERROR = 1873;
|
|
exports.ER_INNODB_READ_ONLY = 1874;
|
|
exports.ER_STOP_SLAVE_SQL_THREAD_TIMEOUT = 1875;
|
|
exports.ER_STOP_SLAVE_IO_THREAD_TIMEOUT = 1876;
|
|
exports.ER_TABLE_CORRUPT = 1877;
|
|
exports.ER_TEMP_FILE_WRITE_FAILURE = 1878;
|
|
exports.ER_INNODB_FT_AUX_NOT_HEX_ID = 1879;
|
|
exports.ER_OLD_TEMPORALS_UPGRADED = 1880;
|
|
exports.ER_INNODB_FORCED_RECOVERY = 1881;
|
|
exports.ER_AES_INVALID_IV = 1882;
|
|
exports.ER_PLUGIN_CANNOT_BE_UNINSTALLED = 1883;
|
|
exports.ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_GTID_GROUP = 1884;
|
|
exports.ER_SLAVE_HAS_MORE_GTIDS_THAN_MASTER = 1885;
|
|
exports.ER_MISSING_KEY = 1886;
|
|
exports.WARN_NAMED_PIPE_ACCESS_EVERYONE = 1887;
|
|
exports.ER_FOUND_MISSING_GTIDS = 1888;
|
|
exports.ER_FILE_CORRUPT = 3000;
|
|
exports.ER_ERROR_ON_MASTER = 3001;
|
|
exports.ER_INCONSISTENT_ERROR = 3002;
|
|
exports.ER_STORAGE_ENGINE_NOT_LOADED = 3003;
|
|
exports.ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER = 3004;
|
|
exports.ER_WARN_LEGACY_SYNTAX_CONVERTED = 3005;
|
|
exports.ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN = 3006;
|
|
exports.ER_CANNOT_DISCARD_TEMPORARY_TABLE = 3007;
|
|
exports.ER_FK_DEPTH_EXCEEDED = 3008;
|
|
exports.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2 = 3009;
|
|
exports.ER_WARN_TRIGGER_DOESNT_HAVE_CREATED = 3010;
|
|
exports.ER_REFERENCED_TRG_DOES_NOT_EXIST = 3011;
|
|
exports.ER_EXPLAIN_NOT_SUPPORTED = 3012;
|
|
exports.ER_INVALID_FIELD_SIZE = 3013;
|
|
exports.ER_MISSING_HA_CREATE_OPTION = 3014;
|
|
exports.ER_ENGINE_OUT_OF_MEMORY = 3015;
|
|
exports.ER_PASSWORD_EXPIRE_ANONYMOUS_USER = 3016;
|
|
exports.ER_SLAVE_SQL_THREAD_MUST_STOP = 3017;
|
|
exports.ER_NO_FT_MATERIALIZED_SUBQUERY = 3018;
|
|
exports.ER_INNODB_UNDO_LOG_FULL = 3019;
|
|
exports.ER_INVALID_ARGUMENT_FOR_LOGARITHM = 3020;
|
|
exports.ER_SLAVE_CHANNEL_IO_THREAD_MUST_STOP = 3021;
|
|
exports.ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO = 3022;
|
|
exports.ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS = 3023;
|
|
exports.ER_QUERY_TIMEOUT = 3024;
|
|
exports.ER_NON_RO_SELECT_DISABLE_TIMER = 3025;
|
|
exports.ER_DUP_LIST_ENTRY = 3026;
|
|
exports.ER_SQL_MODE_NO_EFFECT = 3027;
|
|
exports.ER_AGGREGATE_ORDER_FOR_UNION = 3028;
|
|
exports.ER_AGGREGATE_ORDER_NON_AGG_QUERY = 3029;
|
|
exports.ER_SLAVE_WORKER_STOPPED_PREVIOUS_THD_ERROR = 3030;
|
|
exports.ER_DONT_SUPPORT_SLAVE_PRESERVE_COMMIT_ORDER = 3031;
|
|
exports.ER_SERVER_OFFLINE_MODE = 3032;
|
|
exports.ER_GIS_DIFFERENT_SRIDS = 3033;
|
|
exports.ER_GIS_UNSUPPORTED_ARGUMENT = 3034;
|
|
exports.ER_GIS_UNKNOWN_ERROR = 3035;
|
|
exports.ER_GIS_UNKNOWN_EXCEPTION = 3036;
|
|
exports.ER_GIS_INVALID_DATA = 3037;
|
|
exports.ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION = 3038;
|
|
exports.ER_BOOST_GEOMETRY_CENTROID_EXCEPTION = 3039;
|
|
exports.ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION = 3040;
|
|
exports.ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION = 3041;
|
|
exports.ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION = 3042;
|
|
exports.ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION = 3043;
|
|
exports.ER_STD_BAD_ALLOC_ERROR = 3044;
|
|
exports.ER_STD_DOMAIN_ERROR = 3045;
|
|
exports.ER_STD_LENGTH_ERROR = 3046;
|
|
exports.ER_STD_INVALID_ARGUMENT = 3047;
|
|
exports.ER_STD_OUT_OF_RANGE_ERROR = 3048;
|
|
exports.ER_STD_OVERFLOW_ERROR = 3049;
|
|
exports.ER_STD_RANGE_ERROR = 3050;
|
|
exports.ER_STD_UNDERFLOW_ERROR = 3051;
|
|
exports.ER_STD_LOGIC_ERROR = 3052;
|
|
exports.ER_STD_RUNTIME_ERROR = 3053;
|
|
exports.ER_STD_UNKNOWN_EXCEPTION = 3054;
|
|
exports.ER_GIS_DATA_WRONG_ENDIANESS = 3055;
|
|
exports.ER_CHANGE_MASTER_PASSWORD_LENGTH = 3056;
|
|
exports.ER_USER_LOCK_WRONG_NAME = 3057;
|
|
exports.ER_USER_LOCK_DEADLOCK = 3058;
|
|
exports.ER_REPLACE_INACCESSIBLE_ROWS = 3059;
|
|
exports.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS = 3060;
|
|
exports.ER_ILLEGAL_USER_VAR = 3061;
|
|
exports.ER_GTID_MODE_OFF = 3062;
|
|
exports.ER_UNSUPPORTED_BY_REPLICATION_THREAD = 3063;
|
|
exports.ER_INCORRECT_TYPE = 3064;
|
|
exports.ER_FIELD_IN_ORDER_NOT_SELECT = 3065;
|
|
exports.ER_AGGREGATE_IN_ORDER_NOT_SELECT = 3066;
|
|
exports.ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN = 3067;
|
|
exports.ER_NET_OK_PACKET_TOO_LARGE = 3068;
|
|
exports.ER_INVALID_JSON_DATA = 3069;
|
|
exports.ER_INVALID_GEOJSON_MISSING_MEMBER = 3070;
|
|
exports.ER_INVALID_GEOJSON_WRONG_TYPE = 3071;
|
|
exports.ER_INVALID_GEOJSON_UNSPECIFIED = 3072;
|
|
exports.ER_DIMENSION_UNSUPPORTED = 3073;
|
|
exports.ER_SLAVE_CHANNEL_DOES_NOT_EXIST = 3074;
|
|
exports.ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT = 3075;
|
|
exports.ER_SLAVE_CHANNEL_NAME_INVALID_OR_TOO_LONG = 3076;
|
|
exports.ER_SLAVE_NEW_CHANNEL_WRONG_REPOSITORY = 3077;
|
|
exports.ER_SLAVE_CHANNEL_DELETE = 3078;
|
|
exports.ER_SLAVE_MULTIPLE_CHANNELS_CMD = 3079;
|
|
exports.ER_SLAVE_MAX_CHANNELS_EXCEEDED = 3080;
|
|
exports.ER_SLAVE_CHANNEL_MUST_STOP = 3081;
|
|
exports.ER_SLAVE_CHANNEL_NOT_RUNNING = 3082;
|
|
exports.ER_SLAVE_CHANNEL_WAS_RUNNING = 3083;
|
|
exports.ER_SLAVE_CHANNEL_WAS_NOT_RUNNING = 3084;
|
|
exports.ER_SLAVE_CHANNEL_SQL_THREAD_MUST_STOP = 3085;
|
|
exports.ER_SLAVE_CHANNEL_SQL_SKIP_COUNTER = 3086;
|
|
exports.ER_WRONG_FIELD_WITH_GROUP_V2 = 3087;
|
|
exports.ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2 = 3088;
|
|
exports.ER_WARN_DEPRECATED_SYSVAR_UPDATE = 3089;
|
|
exports.ER_WARN_DEPRECATED_SQLMODE = 3090;
|
|
exports.ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID = 3091;
|
|
exports.ER_GROUP_REPLICATION_CONFIGURATION = 3092;
|
|
exports.ER_GROUP_REPLICATION_RUNNING = 3093;
|
|
exports.ER_GROUP_REPLICATION_APPLIER_INIT_ERROR = 3094;
|
|
exports.ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT = 3095;
|
|
exports.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR = 3096;
|
|
exports.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR = 3097;
|
|
exports.ER_BEFORE_DML_VALIDATION_ERROR = 3098;
|
|
exports.ER_PREVENTS_VARIABLE_WITHOUT_RBR = 3099;
|
|
exports.ER_RUN_HOOK_ERROR = 3100;
|
|
exports.ER_TRANSACTION_ROLLBACK_DURING_COMMIT = 3101;
|
|
exports.ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED = 3102;
|
|
exports.ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN = 3103;
|
|
exports.ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN = 3104;
|
|
exports.ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN = 3105;
|
|
exports.ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN = 3106;
|
|
exports.ER_GENERATED_COLUMN_NON_PRIOR = 3107;
|
|
exports.ER_DEPENDENT_BY_GENERATED_COLUMN = 3108;
|
|
exports.ER_GENERATED_COLUMN_REF_AUTO_INC = 3109;
|
|
exports.ER_FEATURE_NOT_AVAILABLE = 3110;
|
|
exports.ER_CANT_SET_GTID_MODE = 3111;
|
|
exports.ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF = 3112;
|
|
exports.ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION = 3113;
|
|
exports.ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON = 3114;
|
|
exports.ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF = 3115;
|
|
exports.ER_CANT_SET_ENFORCE_GTID_CONSISTENCY_ON_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS = 3116;
|
|
exports.ER_SET_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS = 3117;
|
|
exports.ER_ACCOUNT_HAS_BEEN_LOCKED = 3118;
|
|
exports.ER_WRONG_TABLESPACE_NAME = 3119;
|
|
exports.ER_TABLESPACE_IS_NOT_EMPTY = 3120;
|
|
exports.ER_WRONG_FILE_NAME = 3121;
|
|
exports.ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION = 3122;
|
|
exports.ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR = 3123;
|
|
exports.ER_WARN_BAD_MAX_EXECUTION_TIME = 3124;
|
|
exports.ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME = 3125;
|
|
exports.ER_WARN_CONFLICTING_HINT = 3126;
|
|
exports.ER_WARN_UNKNOWN_QB_NAME = 3127;
|
|
exports.ER_UNRESOLVED_HINT_NAME = 3128;
|
|
exports.ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE = 3129;
|
|
exports.ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED = 3130;
|
|
exports.ER_LOCKING_SERVICE_WRONG_NAME = 3131;
|
|
exports.ER_LOCKING_SERVICE_DEADLOCK = 3132;
|
|
exports.ER_LOCKING_SERVICE_TIMEOUT = 3133;
|
|
exports.ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED = 3134;
|
|
exports.ER_SQL_MODE_MERGED = 3135;
|
|
exports.ER_VTOKEN_PLUGIN_TOKEN_MISMATCH = 3136;
|
|
exports.ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND = 3137;
|
|
exports.ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID = 3138;
|
|
exports.ER_SLAVE_CHANNEL_OPERATION_NOT_ALLOWED = 3139;
|
|
exports.ER_INVALID_JSON_TEXT = 3140;
|
|
exports.ER_INVALID_JSON_TEXT_IN_PARAM = 3141;
|
|
exports.ER_INVALID_JSON_BINARY_DATA = 3142;
|
|
exports.ER_INVALID_JSON_PATH = 3143;
|
|
exports.ER_INVALID_JSON_CHARSET = 3144;
|
|
exports.ER_INVALID_JSON_CHARSET_IN_FUNCTION = 3145;
|
|
exports.ER_INVALID_TYPE_FOR_JSON = 3146;
|
|
exports.ER_INVALID_CAST_TO_JSON = 3147;
|
|
exports.ER_INVALID_JSON_PATH_CHARSET = 3148;
|
|
exports.ER_INVALID_JSON_PATH_WILDCARD = 3149;
|
|
exports.ER_JSON_VALUE_TOO_BIG = 3150;
|
|
exports.ER_JSON_KEY_TOO_BIG = 3151;
|
|
exports.ER_JSON_USED_AS_KEY = 3152;
|
|
exports.ER_JSON_VACUOUS_PATH = 3153;
|
|
exports.ER_JSON_BAD_ONE_OR_ALL_ARG = 3154;
|
|
exports.ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE = 3155;
|
|
exports.ER_INVALID_JSON_VALUE_FOR_CAST = 3156;
|
|
exports.ER_JSON_DOCUMENT_TOO_DEEP = 3157;
|
|
exports.ER_JSON_DOCUMENT_NULL_KEY = 3158;
|
|
exports.ER_SECURE_TRANSPORT_REQUIRED = 3159;
|
|
exports.ER_NO_SECURE_TRANSPORTS_CONFIGURED = 3160;
|
|
exports.ER_DISABLED_STORAGE_ENGINE = 3161;
|
|
exports.ER_USER_DOES_NOT_EXIST = 3162;
|
|
exports.ER_USER_ALREADY_EXISTS = 3163;
|
|
exports.ER_AUDIT_API_ABORT = 3164;
|
|
exports.ER_INVALID_JSON_PATH_ARRAY_CELL = 3165;
|
|
exports.ER_BUFPOOL_RESIZE_INPROGRESS = 3166;
|
|
exports.ER_FEATURE_DISABLED_SEE_DOC = 3167;
|
|
exports.ER_SERVER_ISNT_AVAILABLE = 3168;
|
|
exports.ER_SESSION_WAS_KILLED = 3169;
|
|
exports.ER_CAPACITY_EXCEEDED = 3170;
|
|
exports.ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER = 3171;
|
|
exports.ER_TABLE_NEEDS_UPG_PART = 3172;
|
|
exports.ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID = 3173;
|
|
exports.ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL = 3174;
|
|
exports.ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT = 3175;
|
|
exports.ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE = 3176;
|
|
exports.ER_LOCK_REFUSED_BY_ENGINE = 3177;
|
|
exports.ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN = 3178;
|
|
exports.ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE = 3179;
|
|
exports.ER_MASTER_KEY_ROTATION_ERROR_BY_SE = 3180;
|
|
exports.ER_MASTER_KEY_ROTATION_BINLOG_FAILED = 3181;
|
|
exports.ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE = 3182;
|
|
exports.ER_TABLESPACE_CANNOT_ENCRYPT = 3183;
|
|
exports.ER_INVALID_ENCRYPTION_OPTION = 3184;
|
|
exports.ER_CANNOT_FIND_KEY_IN_KEYRING = 3185;
|
|
exports.ER_CAPACITY_EXCEEDED_IN_PARSER = 3186;
|
|
exports.ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE = 3187;
|
|
exports.ER_KEYRING_UDF_KEYRING_SERVICE_ERROR = 3188;
|
|
exports.ER_USER_COLUMN_OLD_LENGTH = 3189;
|
|
exports.ER_CANT_RESET_MASTER = 3190;
|
|
exports.ER_GROUP_REPLICATION_MAX_GROUP_SIZE = 3191;
|
|
exports.ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED = 3192;
|
|
exports.ER_TABLE_REFERENCED = 3193;
|
|
exports.ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE = 3194;
|
|
exports.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO = 3195;
|
|
exports.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID = 3196;
|
|
exports.ER_XA_RETRY = 3197;
|
|
exports.ER_KEYRING_AWS_UDF_AWS_KMS_ERROR = 3198;
|
|
exports.ER_BINLOG_UNSAFE_XA = 3199;
|
|
exports.ER_UDF_ERROR = 3200;
|
|
exports.ER_KEYRING_MIGRATION_FAILURE = 3201;
|
|
exports.ER_KEYRING_ACCESS_DENIED_ERROR = 3202;
|
|
exports.ER_KEYRING_MIGRATION_STATUS = 3203;
|
|
exports.ER_PLUGIN_FAILED_TO_OPEN_TABLES = 3204;
|
|
exports.ER_PLUGIN_FAILED_TO_OPEN_TABLE = 3205;
|
|
exports.ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED = 3206;
|
|
exports.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET = 3207;
|
|
exports.ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY = 3208;
|
|
exports.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED = 3209;
|
|
exports.ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED = 3210;
|
|
exports.ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE = 3211;
|
|
exports.ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED = 3212;
|
|
exports.ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS = 3213;
|
|
exports.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE = 3214;
|
|
exports.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT = 3215;
|
|
exports.ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED = 3216;
|
|
exports.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE = 3217;
|
|
exports.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE = 3218;
|
|
exports.ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR = 3219;
|
|
exports.ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY = 3220;
|
|
exports.ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY = 3221;
|
|
exports.ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS = 3222;
|
|
exports.ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC = 3223;
|
|
exports.ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER = 3224;
|
|
exports.ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER = 3225;
|
|
exports.WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP = 3226;
|
|
exports.ER_XA_REPLICATION_FILTERS = 3227;
|
|
exports.ER_CANT_OPEN_ERROR_LOG = 3228;
|
|
exports.ER_GROUPING_ON_TIMESTAMP_IN_DST = 3229;
|
|
exports.ER_CANT_START_SERVER_NAMED_PIPE = 3230;
|
|
exports[1] = "EE_CANTCREATEFILE";
|
|
exports[2] = "EE_READ";
|
|
exports[3] = "EE_WRITE";
|
|
exports[4] = "EE_BADCLOSE";
|
|
exports[5] = "EE_OUTOFMEMORY";
|
|
exports[6] = "EE_DELETE";
|
|
exports[7] = "EE_LINK";
|
|
exports[9] = "EE_EOFERR";
|
|
exports[10] = "EE_CANTLOCK";
|
|
exports[11] = "EE_CANTUNLOCK";
|
|
exports[12] = "EE_DIR";
|
|
exports[13] = "EE_STAT";
|
|
exports[14] = "EE_CANT_CHSIZE";
|
|
exports[15] = "EE_CANT_OPEN_STREAM";
|
|
exports[16] = "EE_GETWD";
|
|
exports[17] = "EE_SETWD";
|
|
exports[18] = "EE_LINK_WARNING";
|
|
exports[19] = "EE_OPEN_WARNING";
|
|
exports[20] = "EE_DISK_FULL";
|
|
exports[21] = "EE_CANT_MKDIR";
|
|
exports[22] = "EE_UNKNOWN_CHARSET";
|
|
exports[23] = "EE_OUT_OF_FILERESOURCES";
|
|
exports[24] = "EE_CANT_READLINK";
|
|
exports[25] = "EE_CANT_SYMLINK";
|
|
exports[26] = "EE_REALPATH";
|
|
exports[27] = "EE_SYNC";
|
|
exports[28] = "EE_UNKNOWN_COLLATION";
|
|
exports[29] = "EE_FILENOTFOUND";
|
|
exports[30] = "EE_FILE_NOT_CLOSED";
|
|
exports[31] = "EE_CHANGE_OWNERSHIP";
|
|
exports[32] = "EE_CHANGE_PERMISSIONS";
|
|
exports[33] = "EE_CANT_SEEK";
|
|
exports[34] = "EE_CAPACITY_EXCEEDED";
|
|
exports[120] = "HA_ERR_KEY_NOT_FOUND";
|
|
exports[121] = "HA_ERR_FOUND_DUPP_KEY";
|
|
exports[122] = "HA_ERR_INTERNAL_ERROR";
|
|
exports[123] = "HA_ERR_RECORD_CHANGED";
|
|
exports[124] = "HA_ERR_WRONG_INDEX";
|
|
exports[126] = "HA_ERR_CRASHED";
|
|
exports[127] = "HA_ERR_WRONG_IN_RECORD";
|
|
exports[128] = "HA_ERR_OUT_OF_MEM";
|
|
exports[130] = "HA_ERR_NOT_A_TABLE";
|
|
exports[131] = "HA_ERR_WRONG_COMMAND";
|
|
exports[132] = "HA_ERR_OLD_FILE";
|
|
exports[133] = "HA_ERR_NO_ACTIVE_RECORD";
|
|
exports[134] = "HA_ERR_RECORD_DELETED";
|
|
exports[135] = "HA_ERR_RECORD_FILE_FULL";
|
|
exports[136] = "HA_ERR_INDEX_FILE_FULL";
|
|
exports[137] = "HA_ERR_END_OF_FILE";
|
|
exports[138] = "HA_ERR_UNSUPPORTED";
|
|
exports[139] = "HA_ERR_TOO_BIG_ROW";
|
|
exports[140] = "HA_WRONG_CREATE_OPTION";
|
|
exports[141] = "HA_ERR_FOUND_DUPP_UNIQUE";
|
|
exports[142] = "HA_ERR_UNKNOWN_CHARSET";
|
|
exports[143] = "HA_ERR_WRONG_MRG_TABLE_DEF";
|
|
exports[144] = "HA_ERR_CRASHED_ON_REPAIR";
|
|
exports[145] = "HA_ERR_CRASHED_ON_USAGE";
|
|
exports[146] = "HA_ERR_LOCK_WAIT_TIMEOUT";
|
|
exports[147] = "HA_ERR_LOCK_TABLE_FULL";
|
|
exports[148] = "HA_ERR_READ_ONLY_TRANSACTION";
|
|
exports[149] = "HA_ERR_LOCK_DEADLOCK";
|
|
exports[150] = "HA_ERR_CANNOT_ADD_FOREIGN";
|
|
exports[151] = "HA_ERR_NO_REFERENCED_ROW";
|
|
exports[152] = "HA_ERR_ROW_IS_REFERENCED";
|
|
exports[153] = "HA_ERR_NO_SAVEPOINT";
|
|
exports[154] = "HA_ERR_NON_UNIQUE_BLOCK_SIZE";
|
|
exports[155] = "HA_ERR_NO_SUCH_TABLE";
|
|
exports[156] = "HA_ERR_TABLE_EXIST";
|
|
exports[157] = "HA_ERR_NO_CONNECTION";
|
|
exports[158] = "HA_ERR_NULL_IN_SPATIAL";
|
|
exports[159] = "HA_ERR_TABLE_DEF_CHANGED";
|
|
exports[160] = "HA_ERR_NO_PARTITION_FOUND";
|
|
exports[161] = "HA_ERR_RBR_LOGGING_FAILED";
|
|
exports[162] = "HA_ERR_DROP_INDEX_FK";
|
|
exports[163] = "HA_ERR_FOREIGN_DUPLICATE_KEY";
|
|
exports[164] = "HA_ERR_TABLE_NEEDS_UPGRADE";
|
|
exports[165] = "HA_ERR_TABLE_READONLY";
|
|
exports[166] = "HA_ERR_AUTOINC_READ_FAILED";
|
|
exports[167] = "HA_ERR_AUTOINC_ERANGE";
|
|
exports[168] = "HA_ERR_GENERIC";
|
|
exports[169] = "HA_ERR_RECORD_IS_THE_SAME";
|
|
exports[170] = "HA_ERR_LOGGING_IMPOSSIBLE";
|
|
exports[171] = "HA_ERR_CORRUPT_EVENT";
|
|
exports[172] = "HA_ERR_NEW_FILE";
|
|
exports[173] = "HA_ERR_ROWS_EVENT_APPLY";
|
|
exports[174] = "HA_ERR_INITIALIZATION";
|
|
exports[175] = "HA_ERR_FILE_TOO_SHORT";
|
|
exports[176] = "HA_ERR_WRONG_CRC";
|
|
exports[177] = "HA_ERR_TOO_MANY_CONCURRENT_TRXS";
|
|
exports[178] = "HA_ERR_NOT_IN_LOCK_PARTITIONS";
|
|
exports[179] = "HA_ERR_INDEX_COL_TOO_LONG";
|
|
exports[180] = "HA_ERR_INDEX_CORRUPT";
|
|
exports[181] = "HA_ERR_UNDO_REC_TOO_BIG";
|
|
exports[182] = "HA_FTS_INVALID_DOCID";
|
|
exports[183] = "HA_ERR_TABLE_IN_FK_CHECK";
|
|
exports[184] = "HA_ERR_TABLESPACE_EXISTS";
|
|
exports[185] = "HA_ERR_TOO_MANY_FIELDS";
|
|
exports[186] = "HA_ERR_ROW_IN_WRONG_PARTITION";
|
|
exports[187] = "HA_ERR_INNODB_READ_ONLY";
|
|
exports[188] = "HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT";
|
|
exports[189] = "HA_ERR_TEMP_FILE_WRITE_FAILURE";
|
|
exports[190] = "HA_ERR_INNODB_FORCED_RECOVERY";
|
|
exports[191] = "HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE";
|
|
exports[192] = "HA_ERR_FK_DEPTH_EXCEEDED";
|
|
exports[193] = "HA_MISSING_CREATE_OPTION";
|
|
exports[194] = "HA_ERR_SE_OUT_OF_MEMORY";
|
|
exports[195] = "HA_ERR_TABLE_CORRUPT";
|
|
exports[196] = "HA_ERR_QUERY_INTERRUPTED";
|
|
exports[197] = "HA_ERR_TABLESPACE_MISSING";
|
|
exports[198] = "HA_ERR_TABLESPACE_IS_NOT_EMPTY";
|
|
exports[199] = "HA_ERR_WRONG_FILE_NAME";
|
|
exports[200] = "HA_ERR_NOT_ALLOWED_COMMAND";
|
|
exports[201] = "HA_ERR_COMPUTE_FAILED";
|
|
exports[1000] = "ER_HASHCHK";
|
|
exports[1001] = "ER_NISAMCHK";
|
|
exports[1002] = "ER_NO";
|
|
exports[1003] = "ER_YES";
|
|
exports[1004] = "ER_CANT_CREATE_FILE";
|
|
exports[1005] = "ER_CANT_CREATE_TABLE";
|
|
exports[1006] = "ER_CANT_CREATE_DB";
|
|
exports[1007] = "ER_DB_CREATE_EXISTS";
|
|
exports[1008] = "ER_DB_DROP_EXISTS";
|
|
exports[1009] = "ER_DB_DROP_DELETE";
|
|
exports[1010] = "ER_DB_DROP_RMDIR";
|
|
exports[1011] = "ER_CANT_DELETE_FILE";
|
|
exports[1012] = "ER_CANT_FIND_SYSTEM_REC";
|
|
exports[1013] = "ER_CANT_GET_STAT";
|
|
exports[1014] = "ER_CANT_GET_WD";
|
|
exports[1015] = "ER_CANT_LOCK";
|
|
exports[1016] = "ER_CANT_OPEN_FILE";
|
|
exports[1017] = "ER_FILE_NOT_FOUND";
|
|
exports[1018] = "ER_CANT_READ_DIR";
|
|
exports[1019] = "ER_CANT_SET_WD";
|
|
exports[1020] = "ER_CHECKREAD";
|
|
exports[1021] = "ER_DISK_FULL";
|
|
exports[1022] = "ER_DUP_KEY";
|
|
exports[1023] = "ER_ERROR_ON_CLOSE";
|
|
exports[1024] = "ER_ERROR_ON_READ";
|
|
exports[1025] = "ER_ERROR_ON_RENAME";
|
|
exports[1026] = "ER_ERROR_ON_WRITE";
|
|
exports[1027] = "ER_FILE_USED";
|
|
exports[1028] = "ER_FILSORT_ABORT";
|
|
exports[1029] = "ER_FORM_NOT_FOUND";
|
|
exports[1030] = "ER_GET_ERRNO";
|
|
exports[1031] = "ER_ILLEGAL_HA";
|
|
exports[1032] = "ER_KEY_NOT_FOUND";
|
|
exports[1033] = "ER_NOT_FORM_FILE";
|
|
exports[1034] = "ER_NOT_KEYFILE";
|
|
exports[1035] = "ER_OLD_KEYFILE";
|
|
exports[1036] = "ER_OPEN_AS_READONLY";
|
|
exports[1037] = "ER_OUTOFMEMORY";
|
|
exports[1038] = "ER_OUT_OF_SORTMEMORY";
|
|
exports[1039] = "ER_UNEXPECTED_EOF";
|
|
exports[1040] = "ER_CON_COUNT_ERROR";
|
|
exports[1041] = "ER_OUT_OF_RESOURCES";
|
|
exports[1042] = "ER_BAD_HOST_ERROR";
|
|
exports[1043] = "ER_HANDSHAKE_ERROR";
|
|
exports[1044] = "ER_DBACCESS_DENIED_ERROR";
|
|
exports[1045] = "ER_ACCESS_DENIED_ERROR";
|
|
exports[1046] = "ER_NO_DB_ERROR";
|
|
exports[1047] = "ER_UNKNOWN_COM_ERROR";
|
|
exports[1048] = "ER_BAD_NULL_ERROR";
|
|
exports[1049] = "ER_BAD_DB_ERROR";
|
|
exports[1050] = "ER_TABLE_EXISTS_ERROR";
|
|
exports[1051] = "ER_BAD_TABLE_ERROR";
|
|
exports[1052] = "ER_NON_UNIQ_ERROR";
|
|
exports[1053] = "ER_SERVER_SHUTDOWN";
|
|
exports[1054] = "ER_BAD_FIELD_ERROR";
|
|
exports[1055] = "ER_WRONG_FIELD_WITH_GROUP";
|
|
exports[1056] = "ER_WRONG_GROUP_FIELD";
|
|
exports[1057] = "ER_WRONG_SUM_SELECT";
|
|
exports[1058] = "ER_WRONG_VALUE_COUNT";
|
|
exports[1059] = "ER_TOO_LONG_IDENT";
|
|
exports[1060] = "ER_DUP_FIELDNAME";
|
|
exports[1061] = "ER_DUP_KEYNAME";
|
|
exports[1062] = "ER_DUP_ENTRY";
|
|
exports[1063] = "ER_WRONG_FIELD_SPEC";
|
|
exports[1064] = "ER_PARSE_ERROR";
|
|
exports[1065] = "ER_EMPTY_QUERY";
|
|
exports[1066] = "ER_NONUNIQ_TABLE";
|
|
exports[1067] = "ER_INVALID_DEFAULT";
|
|
exports[1068] = "ER_MULTIPLE_PRI_KEY";
|
|
exports[1069] = "ER_TOO_MANY_KEYS";
|
|
exports[1070] = "ER_TOO_MANY_KEY_PARTS";
|
|
exports[1071] = "ER_TOO_LONG_KEY";
|
|
exports[1072] = "ER_KEY_COLUMN_DOES_NOT_EXITS";
|
|
exports[1073] = "ER_BLOB_USED_AS_KEY";
|
|
exports[1074] = "ER_TOO_BIG_FIELDLENGTH";
|
|
exports[1075] = "ER_WRONG_AUTO_KEY";
|
|
exports[1076] = "ER_READY";
|
|
exports[1077] = "ER_NORMAL_SHUTDOWN";
|
|
exports[1078] = "ER_GOT_SIGNAL";
|
|
exports[1079] = "ER_SHUTDOWN_COMPLETE";
|
|
exports[1080] = "ER_FORCING_CLOSE";
|
|
exports[1081] = "ER_IPSOCK_ERROR";
|
|
exports[1082] = "ER_NO_SUCH_INDEX";
|
|
exports[1083] = "ER_WRONG_FIELD_TERMINATORS";
|
|
exports[1084] = "ER_BLOBS_AND_NO_TERMINATED";
|
|
exports[1085] = "ER_TEXTFILE_NOT_READABLE";
|
|
exports[1086] = "ER_FILE_EXISTS_ERROR";
|
|
exports[1087] = "ER_LOAD_INFO";
|
|
exports[1088] = "ER_ALTER_INFO";
|
|
exports[1089] = "ER_WRONG_SUB_KEY";
|
|
exports[1090] = "ER_CANT_REMOVE_ALL_FIELDS";
|
|
exports[1091] = "ER_CANT_DROP_FIELD_OR_KEY";
|
|
exports[1092] = "ER_INSERT_INFO";
|
|
exports[1093] = "ER_UPDATE_TABLE_USED";
|
|
exports[1094] = "ER_NO_SUCH_THREAD";
|
|
exports[1095] = "ER_KILL_DENIED_ERROR";
|
|
exports[1096] = "ER_NO_TABLES_USED";
|
|
exports[1097] = "ER_TOO_BIG_SET";
|
|
exports[1098] = "ER_NO_UNIQUE_LOGFILE";
|
|
exports[1099] = "ER_TABLE_NOT_LOCKED_FOR_WRITE";
|
|
exports[1100] = "ER_TABLE_NOT_LOCKED";
|
|
exports[1101] = "ER_BLOB_CANT_HAVE_DEFAULT";
|
|
exports[1102] = "ER_WRONG_DB_NAME";
|
|
exports[1103] = "ER_WRONG_TABLE_NAME";
|
|
exports[1104] = "ER_TOO_BIG_SELECT";
|
|
exports[1105] = "ER_UNKNOWN_ERROR";
|
|
exports[1106] = "ER_UNKNOWN_PROCEDURE";
|
|
exports[1107] = "ER_WRONG_PARAMCOUNT_TO_PROCEDURE";
|
|
exports[1108] = "ER_WRONG_PARAMETERS_TO_PROCEDURE";
|
|
exports[1109] = "ER_UNKNOWN_TABLE";
|
|
exports[1110] = "ER_FIELD_SPECIFIED_TWICE";
|
|
exports[1111] = "ER_INVALID_GROUP_FUNC_USE";
|
|
exports[1112] = "ER_UNSUPPORTED_EXTENSION";
|
|
exports[1113] = "ER_TABLE_MUST_HAVE_COLUMNS";
|
|
exports[1114] = "ER_RECORD_FILE_FULL";
|
|
exports[1115] = "ER_UNKNOWN_CHARACTER_SET";
|
|
exports[1116] = "ER_TOO_MANY_TABLES";
|
|
exports[1117] = "ER_TOO_MANY_FIELDS";
|
|
exports[1118] = "ER_TOO_BIG_ROWSIZE";
|
|
exports[1119] = "ER_STACK_OVERRUN";
|
|
exports[1120] = "ER_WRONG_OUTER_JOIN";
|
|
exports[1121] = "ER_NULL_COLUMN_IN_INDEX";
|
|
exports[1122] = "ER_CANT_FIND_UDF";
|
|
exports[1123] = "ER_CANT_INITIALIZE_UDF";
|
|
exports[1124] = "ER_UDF_NO_PATHS";
|
|
exports[1125] = "ER_UDF_EXISTS";
|
|
exports[1126] = "ER_CANT_OPEN_LIBRARY";
|
|
exports[1127] = "ER_CANT_FIND_DL_ENTRY";
|
|
exports[1128] = "ER_FUNCTION_NOT_DEFINED";
|
|
exports[1129] = "ER_HOST_IS_BLOCKED";
|
|
exports[1130] = "ER_HOST_NOT_PRIVILEGED";
|
|
exports[1131] = "ER_PASSWORD_ANONYMOUS_USER";
|
|
exports[1132] = "ER_PASSWORD_NOT_ALLOWED";
|
|
exports[1133] = "ER_PASSWORD_NO_MATCH";
|
|
exports[1134] = "ER_UPDATE_INFO";
|
|
exports[1135] = "ER_CANT_CREATE_THREAD";
|
|
exports[1136] = "ER_WRONG_VALUE_COUNT_ON_ROW";
|
|
exports[1137] = "ER_CANT_REOPEN_TABLE";
|
|
exports[1138] = "ER_INVALID_USE_OF_NULL";
|
|
exports[1139] = "ER_REGEXP_ERROR";
|
|
exports[1140] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS";
|
|
exports[1141] = "ER_NONEXISTING_GRANT";
|
|
exports[1142] = "ER_TABLEACCESS_DENIED_ERROR";
|
|
exports[1143] = "ER_COLUMNACCESS_DENIED_ERROR";
|
|
exports[1144] = "ER_ILLEGAL_GRANT_FOR_TABLE";
|
|
exports[1145] = "ER_GRANT_WRONG_HOST_OR_USER";
|
|
exports[1146] = "ER_NO_SUCH_TABLE";
|
|
exports[1147] = "ER_NONEXISTING_TABLE_GRANT";
|
|
exports[1148] = "ER_NOT_ALLOWED_COMMAND";
|
|
exports[1149] = "ER_SYNTAX_ERROR";
|
|
exports[1150] = "ER_DELAYED_CANT_CHANGE_LOCK";
|
|
exports[1151] = "ER_TOO_MANY_DELAYED_THREADS";
|
|
exports[1152] = "ER_ABORTING_CONNECTION";
|
|
exports[1153] = "ER_NET_PACKET_TOO_LARGE";
|
|
exports[1154] = "ER_NET_READ_ERROR_FROM_PIPE";
|
|
exports[1155] = "ER_NET_FCNTL_ERROR";
|
|
exports[1156] = "ER_NET_PACKETS_OUT_OF_ORDER";
|
|
exports[1157] = "ER_NET_UNCOMPRESS_ERROR";
|
|
exports[1158] = "ER_NET_READ_ERROR";
|
|
exports[1159] = "ER_NET_READ_INTERRUPTED";
|
|
exports[1160] = "ER_NET_ERROR_ON_WRITE";
|
|
exports[1161] = "ER_NET_WRITE_INTERRUPTED";
|
|
exports[1162] = "ER_TOO_LONG_STRING";
|
|
exports[1163] = "ER_TABLE_CANT_HANDLE_BLOB";
|
|
exports[1164] = "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT";
|
|
exports[1165] = "ER_DELAYED_INSERT_TABLE_LOCKED";
|
|
exports[1166] = "ER_WRONG_COLUMN_NAME";
|
|
exports[1167] = "ER_WRONG_KEY_COLUMN";
|
|
exports[1168] = "ER_WRONG_MRG_TABLE";
|
|
exports[1169] = "ER_DUP_UNIQUE";
|
|
exports[1170] = "ER_BLOB_KEY_WITHOUT_LENGTH";
|
|
exports[1171] = "ER_PRIMARY_CANT_HAVE_NULL";
|
|
exports[1172] = "ER_TOO_MANY_ROWS";
|
|
exports[1173] = "ER_REQUIRES_PRIMARY_KEY";
|
|
exports[1174] = "ER_NO_RAID_COMPILED";
|
|
exports[1175] = "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE";
|
|
exports[1176] = "ER_KEY_DOES_NOT_EXITS";
|
|
exports[1177] = "ER_CHECK_NO_SUCH_TABLE";
|
|
exports[1178] = "ER_CHECK_NOT_IMPLEMENTED";
|
|
exports[1179] = "ER_CANT_DO_THIS_DURING_AN_TRANSACTION";
|
|
exports[1180] = "ER_ERROR_DURING_COMMIT";
|
|
exports[1181] = "ER_ERROR_DURING_ROLLBACK";
|
|
exports[1182] = "ER_ERROR_DURING_FLUSH_LOGS";
|
|
exports[1183] = "ER_ERROR_DURING_CHECKPOINT";
|
|
exports[1184] = "ER_NEW_ABORTING_CONNECTION";
|
|
exports[1185] = "ER_DUMP_NOT_IMPLEMENTED";
|
|
exports[1186] = "ER_FLUSH_MASTER_BINLOG_CLOSED";
|
|
exports[1187] = "ER_INDEX_REBUILD";
|
|
exports[1188] = "ER_MASTER";
|
|
exports[1189] = "ER_MASTER_NET_READ";
|
|
exports[1190] = "ER_MASTER_NET_WRITE";
|
|
exports[1191] = "ER_FT_MATCHING_KEY_NOT_FOUND";
|
|
exports[1192] = "ER_LOCK_OR_ACTIVE_TRANSACTION";
|
|
exports[1193] = "ER_UNKNOWN_SYSTEM_VARIABLE";
|
|
exports[1194] = "ER_CRASHED_ON_USAGE";
|
|
exports[1195] = "ER_CRASHED_ON_REPAIR";
|
|
exports[1196] = "ER_WARNING_NOT_COMPLETE_ROLLBACK";
|
|
exports[1197] = "ER_TRANS_CACHE_FULL";
|
|
exports[1198] = "ER_SLAVE_MUST_STOP";
|
|
exports[1199] = "ER_SLAVE_NOT_RUNNING";
|
|
exports[1200] = "ER_BAD_SLAVE";
|
|
exports[1201] = "ER_MASTER_INFO";
|
|
exports[1202] = "ER_SLAVE_THREAD";
|
|
exports[1203] = "ER_TOO_MANY_USER_CONNECTIONS";
|
|
exports[1204] = "ER_SET_CONSTANTS_ONLY";
|
|
exports[1205] = "ER_LOCK_WAIT_TIMEOUT";
|
|
exports[1206] = "ER_LOCK_TABLE_FULL";
|
|
exports[1207] = "ER_READ_ONLY_TRANSACTION";
|
|
exports[1208] = "ER_DROP_DB_WITH_READ_LOCK";
|
|
exports[1209] = "ER_CREATE_DB_WITH_READ_LOCK";
|
|
exports[1210] = "ER_WRONG_ARGUMENTS";
|
|
exports[1211] = "ER_NO_PERMISSION_TO_CREATE_USER";
|
|
exports[1212] = "ER_UNION_TABLES_IN_DIFFERENT_DIR";
|
|
exports[1213] = "ER_LOCK_DEADLOCK";
|
|
exports[1214] = "ER_TABLE_CANT_HANDLE_FT";
|
|
exports[1215] = "ER_CANNOT_ADD_FOREIGN";
|
|
exports[1216] = "ER_NO_REFERENCED_ROW";
|
|
exports[1217] = "ER_ROW_IS_REFERENCED";
|
|
exports[1218] = "ER_CONNECT_TO_MASTER";
|
|
exports[1219] = "ER_QUERY_ON_MASTER";
|
|
exports[1220] = "ER_ERROR_WHEN_EXECUTING_COMMAND";
|
|
exports[1221] = "ER_WRONG_USAGE";
|
|
exports[1222] = "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT";
|
|
exports[1223] = "ER_CANT_UPDATE_WITH_READLOCK";
|
|
exports[1224] = "ER_MIXING_NOT_ALLOWED";
|
|
exports[1225] = "ER_DUP_ARGUMENT";
|
|
exports[1226] = "ER_USER_LIMIT_REACHED";
|
|
exports[1227] = "ER_SPECIFIC_ACCESS_DENIED_ERROR";
|
|
exports[1228] = "ER_LOCAL_VARIABLE";
|
|
exports[1229] = "ER_GLOBAL_VARIABLE";
|
|
exports[1230] = "ER_NO_DEFAULT";
|
|
exports[1231] = "ER_WRONG_VALUE_FOR_VAR";
|
|
exports[1232] = "ER_WRONG_TYPE_FOR_VAR";
|
|
exports[1233] = "ER_VAR_CANT_BE_READ";
|
|
exports[1234] = "ER_CANT_USE_OPTION_HERE";
|
|
exports[1235] = "ER_NOT_SUPPORTED_YET";
|
|
exports[1236] = "ER_MASTER_FATAL_ERROR_READING_BINLOG";
|
|
exports[1237] = "ER_SLAVE_IGNORED_TABLE";
|
|
exports[1238] = "ER_INCORRECT_GLOBAL_LOCAL_VAR";
|
|
exports[1239] = "ER_WRONG_FK_DEF";
|
|
exports[1240] = "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF";
|
|
exports[1241] = "ER_OPERAND_COLUMNS";
|
|
exports[1242] = "ER_SUBQUERY_NO_1_ROW";
|
|
exports[1243] = "ER_UNKNOWN_STMT_HANDLER";
|
|
exports[1244] = "ER_CORRUPT_HELP_DB";
|
|
exports[1245] = "ER_CYCLIC_REFERENCE";
|
|
exports[1246] = "ER_AUTO_CONVERT";
|
|
exports[1247] = "ER_ILLEGAL_REFERENCE";
|
|
exports[1248] = "ER_DERIVED_MUST_HAVE_ALIAS";
|
|
exports[1249] = "ER_SELECT_REDUCED";
|
|
exports[1250] = "ER_TABLENAME_NOT_ALLOWED_HERE";
|
|
exports[1251] = "ER_NOT_SUPPORTED_AUTH_MODE";
|
|
exports[1252] = "ER_SPATIAL_CANT_HAVE_NULL";
|
|
exports[1253] = "ER_COLLATION_CHARSET_MISMATCH";
|
|
exports[1254] = "ER_SLAVE_WAS_RUNNING";
|
|
exports[1255] = "ER_SLAVE_WAS_NOT_RUNNING";
|
|
exports[1256] = "ER_TOO_BIG_FOR_UNCOMPRESS";
|
|
exports[1257] = "ER_ZLIB_Z_MEM_ERROR";
|
|
exports[1258] = "ER_ZLIB_Z_BUF_ERROR";
|
|
exports[1259] = "ER_ZLIB_Z_DATA_ERROR";
|
|
exports[1260] = "ER_CUT_VALUE_GROUP_CONCAT";
|
|
exports[1261] = "ER_WARN_TOO_FEW_RECORDS";
|
|
exports[1262] = "ER_WARN_TOO_MANY_RECORDS";
|
|
exports[1263] = "ER_WARN_NULL_TO_NOTNULL";
|
|
exports[1264] = "ER_WARN_DATA_OUT_OF_RANGE";
|
|
exports[1265] = "WARN_DATA_TRUNCATED";
|
|
exports[1266] = "ER_WARN_USING_OTHER_HANDLER";
|
|
exports[1267] = "ER_CANT_AGGREGATE_2COLLATIONS";
|
|
exports[1268] = "ER_DROP_USER";
|
|
exports[1269] = "ER_REVOKE_GRANTS";
|
|
exports[1270] = "ER_CANT_AGGREGATE_3COLLATIONS";
|
|
exports[1271] = "ER_CANT_AGGREGATE_NCOLLATIONS";
|
|
exports[1272] = "ER_VARIABLE_IS_NOT_STRUCT";
|
|
exports[1273] = "ER_UNKNOWN_COLLATION";
|
|
exports[1274] = "ER_SLAVE_IGNORED_SSL_PARAMS";
|
|
exports[1275] = "ER_SERVER_IS_IN_SECURE_AUTH_MODE";
|
|
exports[1276] = "ER_WARN_FIELD_RESOLVED";
|
|
exports[1277] = "ER_BAD_SLAVE_UNTIL_COND";
|
|
exports[1278] = "ER_MISSING_SKIP_SLAVE";
|
|
exports[1279] = "ER_UNTIL_COND_IGNORED";
|
|
exports[1280] = "ER_WRONG_NAME_FOR_INDEX";
|
|
exports[1281] = "ER_WRONG_NAME_FOR_CATALOG";
|
|
exports[1282] = "ER_WARN_QC_RESIZE";
|
|
exports[1283] = "ER_BAD_FT_COLUMN";
|
|
exports[1284] = "ER_UNKNOWN_KEY_CACHE";
|
|
exports[1285] = "ER_WARN_HOSTNAME_WONT_WORK";
|
|
exports[1286] = "ER_UNKNOWN_STORAGE_ENGINE";
|
|
exports[1287] = "ER_WARN_DEPRECATED_SYNTAX";
|
|
exports[1288] = "ER_NON_UPDATABLE_TABLE";
|
|
exports[1289] = "ER_FEATURE_DISABLED";
|
|
exports[1290] = "ER_OPTION_PREVENTS_STATEMENT";
|
|
exports[1291] = "ER_DUPLICATED_VALUE_IN_TYPE";
|
|
exports[1292] = "ER_TRUNCATED_WRONG_VALUE";
|
|
exports[1293] = "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS";
|
|
exports[1294] = "ER_INVALID_ON_UPDATE";
|
|
exports[1295] = "ER_UNSUPPORTED_PS";
|
|
exports[1296] = "ER_GET_ERRMSG";
|
|
exports[1297] = "ER_GET_TEMPORARY_ERRMSG";
|
|
exports[1298] = "ER_UNKNOWN_TIME_ZONE";
|
|
exports[1299] = "ER_WARN_INVALID_TIMESTAMP";
|
|
exports[1300] = "ER_INVALID_CHARACTER_STRING";
|
|
exports[1301] = "ER_WARN_ALLOWED_PACKET_OVERFLOWED";
|
|
exports[1302] = "ER_CONFLICTING_DECLARATIONS";
|
|
exports[1303] = "ER_SP_NO_RECURSIVE_CREATE";
|
|
exports[1304] = "ER_SP_ALREADY_EXISTS";
|
|
exports[1305] = "ER_SP_DOES_NOT_EXIST";
|
|
exports[1306] = "ER_SP_DROP_FAILED";
|
|
exports[1307] = "ER_SP_STORE_FAILED";
|
|
exports[1308] = "ER_SP_LILABEL_MISMATCH";
|
|
exports[1309] = "ER_SP_LABEL_REDEFINE";
|
|
exports[1310] = "ER_SP_LABEL_MISMATCH";
|
|
exports[1311] = "ER_SP_UNINIT_VAR";
|
|
exports[1312] = "ER_SP_BADSELECT";
|
|
exports[1313] = "ER_SP_BADRETURN";
|
|
exports[1314] = "ER_SP_BADSTATEMENT";
|
|
exports[1315] = "ER_UPDATE_LOG_DEPRECATED_IGNORED";
|
|
exports[1316] = "ER_UPDATE_LOG_DEPRECATED_TRANSLATED";
|
|
exports[1317] = "ER_QUERY_INTERRUPTED";
|
|
exports[1318] = "ER_SP_WRONG_NO_OF_ARGS";
|
|
exports[1319] = "ER_SP_COND_MISMATCH";
|
|
exports[1320] = "ER_SP_NORETURN";
|
|
exports[1321] = "ER_SP_NORETURNEND";
|
|
exports[1322] = "ER_SP_BAD_CURSOR_QUERY";
|
|
exports[1323] = "ER_SP_BAD_CURSOR_SELECT";
|
|
exports[1324] = "ER_SP_CURSOR_MISMATCH";
|
|
exports[1325] = "ER_SP_CURSOR_ALREADY_OPEN";
|
|
exports[1326] = "ER_SP_CURSOR_NOT_OPEN";
|
|
exports[1327] = "ER_SP_UNDECLARED_VAR";
|
|
exports[1328] = "ER_SP_WRONG_NO_OF_FETCH_ARGS";
|
|
exports[1329] = "ER_SP_FETCH_NO_DATA";
|
|
exports[1330] = "ER_SP_DUP_PARAM";
|
|
exports[1331] = "ER_SP_DUP_VAR";
|
|
exports[1332] = "ER_SP_DUP_COND";
|
|
exports[1333] = "ER_SP_DUP_CURS";
|
|
exports[1334] = "ER_SP_CANT_ALTER";
|
|
exports[1335] = "ER_SP_SUBSELECT_NYI";
|
|
exports[1336] = "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG";
|
|
exports[1337] = "ER_SP_VARCOND_AFTER_CURSHNDLR";
|
|
exports[1338] = "ER_SP_CURSOR_AFTER_HANDLER";
|
|
exports[1339] = "ER_SP_CASE_NOT_FOUND";
|
|
exports[1340] = "ER_FPARSER_TOO_BIG_FILE";
|
|
exports[1341] = "ER_FPARSER_BAD_HEADER";
|
|
exports[1342] = "ER_FPARSER_EOF_IN_COMMENT";
|
|
exports[1343] = "ER_FPARSER_ERROR_IN_PARAMETER";
|
|
exports[1344] = "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER";
|
|
exports[1345] = "ER_VIEW_NO_EXPLAIN";
|
|
exports[1346] = "ER_FRM_UNKNOWN_TYPE";
|
|
exports[1347] = "ER_WRONG_OBJECT";
|
|
exports[1348] = "ER_NONUPDATEABLE_COLUMN";
|
|
exports[1349] = "ER_VIEW_SELECT_DERIVED";
|
|
exports[1350] = "ER_VIEW_SELECT_CLAUSE";
|
|
exports[1351] = "ER_VIEW_SELECT_VARIABLE";
|
|
exports[1352] = "ER_VIEW_SELECT_TMPTABLE";
|
|
exports[1353] = "ER_VIEW_WRONG_LIST";
|
|
exports[1354] = "ER_WARN_VIEW_MERGE";
|
|
exports[1355] = "ER_WARN_VIEW_WITHOUT_KEY";
|
|
exports[1356] = "ER_VIEW_INVALID";
|
|
exports[1357] = "ER_SP_NO_DROP_SP";
|
|
exports[1358] = "ER_SP_GOTO_IN_HNDLR";
|
|
exports[1359] = "ER_TRG_ALREADY_EXISTS";
|
|
exports[1360] = "ER_TRG_DOES_NOT_EXIST";
|
|
exports[1361] = "ER_TRG_ON_VIEW_OR_TEMP_TABLE";
|
|
exports[1362] = "ER_TRG_CANT_CHANGE_ROW";
|
|
exports[1363] = "ER_TRG_NO_SUCH_ROW_IN_TRG";
|
|
exports[1364] = "ER_NO_DEFAULT_FOR_FIELD";
|
|
exports[1365] = "ER_DIVISION_BY_ZERO";
|
|
exports[1366] = "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD";
|
|
exports[1367] = "ER_ILLEGAL_VALUE_FOR_TYPE";
|
|
exports[1368] = "ER_VIEW_NONUPD_CHECK";
|
|
exports[1369] = "ER_VIEW_CHECK_FAILED";
|
|
exports[1370] = "ER_PROCACCESS_DENIED_ERROR";
|
|
exports[1371] = "ER_RELAY_LOG_FAIL";
|
|
exports[1372] = "ER_PASSWD_LENGTH";
|
|
exports[1373] = "ER_UNKNOWN_TARGET_BINLOG";
|
|
exports[1374] = "ER_IO_ERR_LOG_INDEX_READ";
|
|
exports[1375] = "ER_BINLOG_PURGE_PROHIBITED";
|
|
exports[1376] = "ER_FSEEK_FAIL";
|
|
exports[1377] = "ER_BINLOG_PURGE_FATAL_ERR";
|
|
exports[1378] = "ER_LOG_IN_USE";
|
|
exports[1379] = "ER_LOG_PURGE_UNKNOWN_ERR";
|
|
exports[1380] = "ER_RELAY_LOG_INIT";
|
|
exports[1381] = "ER_NO_BINARY_LOGGING";
|
|
exports[1382] = "ER_RESERVED_SYNTAX";
|
|
exports[1383] = "ER_WSAS_FAILED";
|
|
exports[1384] = "ER_DIFF_GROUPS_PROC";
|
|
exports[1385] = "ER_NO_GROUP_FOR_PROC";
|
|
exports[1386] = "ER_ORDER_WITH_PROC";
|
|
exports[1387] = "ER_LOGGING_PROHIBIT_CHANGING_OF";
|
|
exports[1388] = "ER_NO_FILE_MAPPING";
|
|
exports[1389] = "ER_WRONG_MAGIC";
|
|
exports[1390] = "ER_PS_MANY_PARAM";
|
|
exports[1391] = "ER_KEY_PART_0";
|
|
exports[1392] = "ER_VIEW_CHECKSUM";
|
|
exports[1393] = "ER_VIEW_MULTIUPDATE";
|
|
exports[1394] = "ER_VIEW_NO_INSERT_FIELD_LIST";
|
|
exports[1395] = "ER_VIEW_DELETE_MERGE_VIEW";
|
|
exports[1396] = "ER_CANNOT_USER";
|
|
exports[1397] = "ER_XAER_NOTA";
|
|
exports[1398] = "ER_XAER_INVAL";
|
|
exports[1399] = "ER_XAER_RMFAIL";
|
|
exports[1400] = "ER_XAER_OUTSIDE";
|
|
exports[1401] = "ER_XAER_RMERR";
|
|
exports[1402] = "ER_XA_RBROLLBACK";
|
|
exports[1403] = "ER_NONEXISTING_PROC_GRANT";
|
|
exports[1404] = "ER_PROC_AUTO_GRANT_FAIL";
|
|
exports[1405] = "ER_PROC_AUTO_REVOKE_FAIL";
|
|
exports[1406] = "ER_DATA_TOO_LONG";
|
|
exports[1407] = "ER_SP_BAD_SQLSTATE";
|
|
exports[1408] = "ER_STARTUP";
|
|
exports[1409] = "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR";
|
|
exports[1410] = "ER_CANT_CREATE_USER_WITH_GRANT";
|
|
exports[1411] = "ER_WRONG_VALUE_FOR_TYPE";
|
|
exports[1412] = "ER_TABLE_DEF_CHANGED";
|
|
exports[1413] = "ER_SP_DUP_HANDLER";
|
|
exports[1414] = "ER_SP_NOT_VAR_ARG";
|
|
exports[1415] = "ER_SP_NO_RETSET";
|
|
exports[1416] = "ER_CANT_CREATE_GEOMETRY_OBJECT";
|
|
exports[1417] = "ER_FAILED_ROUTINE_BREAK_BINLOG";
|
|
exports[1418] = "ER_BINLOG_UNSAFE_ROUTINE";
|
|
exports[1419] = "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER";
|
|
exports[1420] = "ER_EXEC_STMT_WITH_OPEN_CURSOR";
|
|
exports[1421] = "ER_STMT_HAS_NO_OPEN_CURSOR";
|
|
exports[1422] = "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG";
|
|
exports[1423] = "ER_NO_DEFAULT_FOR_VIEW_FIELD";
|
|
exports[1424] = "ER_SP_NO_RECURSION";
|
|
exports[1425] = "ER_TOO_BIG_SCALE";
|
|
exports[1426] = "ER_TOO_BIG_PRECISION";
|
|
exports[1427] = "ER_M_BIGGER_THAN_D";
|
|
exports[1428] = "ER_WRONG_LOCK_OF_SYSTEM_TABLE";
|
|
exports[1429] = "ER_CONNECT_TO_FOREIGN_DATA_SOURCE";
|
|
exports[1430] = "ER_QUERY_ON_FOREIGN_DATA_SOURCE";
|
|
exports[1431] = "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST";
|
|
exports[1432] = "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE";
|
|
exports[1433] = "ER_FOREIGN_DATA_STRING_INVALID";
|
|
exports[1434] = "ER_CANT_CREATE_FEDERATED_TABLE";
|
|
exports[1435] = "ER_TRG_IN_WRONG_SCHEMA";
|
|
exports[1436] = "ER_STACK_OVERRUN_NEED_MORE";
|
|
exports[1437] = "ER_TOO_LONG_BODY";
|
|
exports[1438] = "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE";
|
|
exports[1439] = "ER_TOO_BIG_DISPLAYWIDTH";
|
|
exports[1440] = "ER_XAER_DUPID";
|
|
exports[1441] = "ER_DATETIME_FUNCTION_OVERFLOW";
|
|
exports[1442] = "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG";
|
|
exports[1443] = "ER_VIEW_PREVENT_UPDATE";
|
|
exports[1444] = "ER_PS_NO_RECURSION";
|
|
exports[1445] = "ER_SP_CANT_SET_AUTOCOMMIT";
|
|
exports[1446] = "ER_MALFORMED_DEFINER";
|
|
exports[1447] = "ER_VIEW_FRM_NO_USER";
|
|
exports[1448] = "ER_VIEW_OTHER_USER";
|
|
exports[1449] = "ER_NO_SUCH_USER";
|
|
exports[1450] = "ER_FORBID_SCHEMA_CHANGE";
|
|
exports[1451] = "ER_ROW_IS_REFERENCED_2";
|
|
exports[1452] = "ER_NO_REFERENCED_ROW_2";
|
|
exports[1453] = "ER_SP_BAD_VAR_SHADOW";
|
|
exports[1454] = "ER_TRG_NO_DEFINER";
|
|
exports[1455] = "ER_OLD_FILE_FORMAT";
|
|
exports[1456] = "ER_SP_RECURSION_LIMIT";
|
|
exports[1457] = "ER_SP_PROC_TABLE_CORRUPT";
|
|
exports[1458] = "ER_SP_WRONG_NAME";
|
|
exports[1459] = "ER_TABLE_NEEDS_UPGRADE";
|
|
exports[1460] = "ER_SP_NO_AGGREGATE";
|
|
exports[1461] = "ER_MAX_PREPARED_STMT_COUNT_REACHED";
|
|
exports[1462] = "ER_VIEW_RECURSIVE";
|
|
exports[1463] = "ER_NON_GROUPING_FIELD_USED";
|
|
exports[1464] = "ER_TABLE_CANT_HANDLE_SPKEYS";
|
|
exports[1465] = "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA";
|
|
exports[1466] = "ER_REMOVED_SPACES";
|
|
exports[1467] = "ER_AUTOINC_READ_FAILED";
|
|
exports[1468] = "ER_USERNAME";
|
|
exports[1469] = "ER_HOSTNAME";
|
|
exports[1470] = "ER_WRONG_STRING_LENGTH";
|
|
exports[1471] = "ER_NON_INSERTABLE_TABLE";
|
|
exports[1472] = "ER_ADMIN_WRONG_MRG_TABLE";
|
|
exports[1473] = "ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT";
|
|
exports[1474] = "ER_NAME_BECOMES_EMPTY";
|
|
exports[1475] = "ER_AMBIGUOUS_FIELD_TERM";
|
|
exports[1476] = "ER_FOREIGN_SERVER_EXISTS";
|
|
exports[1477] = "ER_FOREIGN_SERVER_DOESNT_EXIST";
|
|
exports[1478] = "ER_ILLEGAL_HA_CREATE_OPTION";
|
|
exports[1479] = "ER_PARTITION_REQUIRES_VALUES_ERROR";
|
|
exports[1480] = "ER_PARTITION_WRONG_VALUES_ERROR";
|
|
exports[1481] = "ER_PARTITION_MAXVALUE_ERROR";
|
|
exports[1482] = "ER_PARTITION_SUBPARTITION_ERROR";
|
|
exports[1483] = "ER_PARTITION_SUBPART_MIX_ERROR";
|
|
exports[1484] = "ER_PARTITION_WRONG_NO_PART_ERROR";
|
|
exports[1485] = "ER_PARTITION_WRONG_NO_SUBPART_ERROR";
|
|
exports[1486] = "ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR";
|
|
exports[1487] = "ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR";
|
|
exports[1488] = "ER_FIELD_NOT_FOUND_PART_ERROR";
|
|
exports[1489] = "ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR";
|
|
exports[1490] = "ER_INCONSISTENT_PARTITION_INFO_ERROR";
|
|
exports[1491] = "ER_PARTITION_FUNC_NOT_ALLOWED_ERROR";
|
|
exports[1492] = "ER_PARTITIONS_MUST_BE_DEFINED_ERROR";
|
|
exports[1493] = "ER_RANGE_NOT_INCREASING_ERROR";
|
|
exports[1494] = "ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR";
|
|
exports[1495] = "ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR";
|
|
exports[1496] = "ER_PARTITION_ENTRY_ERROR";
|
|
exports[1497] = "ER_MIX_HANDLER_ERROR";
|
|
exports[1498] = "ER_PARTITION_NOT_DEFINED_ERROR";
|
|
exports[1499] = "ER_TOO_MANY_PARTITIONS_ERROR";
|
|
exports[1500] = "ER_SUBPARTITION_ERROR";
|
|
exports[1501] = "ER_CANT_CREATE_HANDLER_FILE";
|
|
exports[1502] = "ER_BLOB_FIELD_IN_PART_FUNC_ERROR";
|
|
exports[1503] = "ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF";
|
|
exports[1504] = "ER_NO_PARTS_ERROR";
|
|
exports[1505] = "ER_PARTITION_MGMT_ON_NONPARTITIONED";
|
|
exports[1506] = "ER_FOREIGN_KEY_ON_PARTITIONED";
|
|
exports[1507] = "ER_DROP_PARTITION_NON_EXISTENT";
|
|
exports[1508] = "ER_DROP_LAST_PARTITION";
|
|
exports[1509] = "ER_COALESCE_ONLY_ON_HASH_PARTITION";
|
|
exports[1510] = "ER_REORG_HASH_ONLY_ON_SAME_NO";
|
|
exports[1511] = "ER_REORG_NO_PARAM_ERROR";
|
|
exports[1512] = "ER_ONLY_ON_RANGE_LIST_PARTITION";
|
|
exports[1513] = "ER_ADD_PARTITION_SUBPART_ERROR";
|
|
exports[1514] = "ER_ADD_PARTITION_NO_NEW_PARTITION";
|
|
exports[1515] = "ER_COALESCE_PARTITION_NO_PARTITION";
|
|
exports[1516] = "ER_REORG_PARTITION_NOT_EXIST";
|
|
exports[1517] = "ER_SAME_NAME_PARTITION";
|
|
exports[1518] = "ER_NO_BINLOG_ERROR";
|
|
exports[1519] = "ER_CONSECUTIVE_REORG_PARTITIONS";
|
|
exports[1520] = "ER_REORG_OUTSIDE_RANGE";
|
|
exports[1521] = "ER_PARTITION_FUNCTION_FAILURE";
|
|
exports[1522] = "ER_PART_STATE_ERROR";
|
|
exports[1523] = "ER_LIMITED_PART_RANGE";
|
|
exports[1524] = "ER_PLUGIN_IS_NOT_LOADED";
|
|
exports[1525] = "ER_WRONG_VALUE";
|
|
exports[1526] = "ER_NO_PARTITION_FOR_GIVEN_VALUE";
|
|
exports[1527] = "ER_FILEGROUP_OPTION_ONLY_ONCE";
|
|
exports[1528] = "ER_CREATE_FILEGROUP_FAILED";
|
|
exports[1529] = "ER_DROP_FILEGROUP_FAILED";
|
|
exports[1530] = "ER_TABLESPACE_AUTO_EXTEND_ERROR";
|
|
exports[1531] = "ER_WRONG_SIZE_NUMBER";
|
|
exports[1532] = "ER_SIZE_OVERFLOW_ERROR";
|
|
exports[1533] = "ER_ALTER_FILEGROUP_FAILED";
|
|
exports[1534] = "ER_BINLOG_ROW_LOGGING_FAILED";
|
|
exports[1535] = "ER_BINLOG_ROW_WRONG_TABLE_DEF";
|
|
exports[1536] = "ER_BINLOG_ROW_RBR_TO_SBR";
|
|
exports[1537] = "ER_EVENT_ALREADY_EXISTS";
|
|
exports[1538] = "ER_EVENT_STORE_FAILED";
|
|
exports[1539] = "ER_EVENT_DOES_NOT_EXIST";
|
|
exports[1540] = "ER_EVENT_CANT_ALTER";
|
|
exports[1541] = "ER_EVENT_DROP_FAILED";
|
|
exports[1542] = "ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG";
|
|
exports[1543] = "ER_EVENT_ENDS_BEFORE_STARTS";
|
|
exports[1544] = "ER_EVENT_EXEC_TIME_IN_THE_PAST";
|
|
exports[1545] = "ER_EVENT_OPEN_TABLE_FAILED";
|
|
exports[1546] = "ER_EVENT_NEITHER_M_EXPR_NOR_M_AT";
|
|
exports[1547] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED";
|
|
exports[1548] = "ER_CANNOT_LOAD_FROM_TABLE";
|
|
exports[1549] = "ER_EVENT_CANNOT_DELETE";
|
|
exports[1550] = "ER_EVENT_COMPILE_ERROR";
|
|
exports[1551] = "ER_EVENT_SAME_NAME";
|
|
exports[1552] = "ER_EVENT_DATA_TOO_LONG";
|
|
exports[1553] = "ER_DROP_INDEX_FK";
|
|
exports[1554] = "ER_WARN_DEPRECATED_SYNTAX_WITH_VER";
|
|
exports[1555] = "ER_CANT_WRITE_LOCK_LOG_TABLE";
|
|
exports[1556] = "ER_CANT_LOCK_LOG_TABLE";
|
|
exports[1557] = "ER_FOREIGN_DUPLICATE_KEY";
|
|
exports[1558] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE";
|
|
exports[1559] = "ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR";
|
|
exports[1560] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT";
|
|
exports[1561] = "ER_NDB_CANT_SWITCH_BINLOG_FORMAT";
|
|
exports[1562] = "ER_PARTITION_NO_TEMPORARY";
|
|
exports[1563] = "ER_PARTITION_CONST_DOMAIN_ERROR";
|
|
exports[1564] = "ER_PARTITION_FUNCTION_IS_NOT_ALLOWED";
|
|
exports[1565] = "ER_DDL_LOG_ERROR";
|
|
exports[1566] = "ER_NULL_IN_VALUES_LESS_THAN";
|
|
exports[1567] = "ER_WRONG_PARTITION_NAME";
|
|
exports[1568] = "ER_CANT_CHANGE_TX_CHARACTERISTICS";
|
|
exports[1569] = "ER_DUP_ENTRY_AUTOINCREMENT_CASE";
|
|
exports[1570] = "ER_EVENT_MODIFY_QUEUE_ERROR";
|
|
exports[1571] = "ER_EVENT_SET_VAR_ERROR";
|
|
exports[1572] = "ER_PARTITION_MERGE_ERROR";
|
|
exports[1573] = "ER_CANT_ACTIVATE_LOG";
|
|
exports[1574] = "ER_RBR_NOT_AVAILABLE";
|
|
exports[1575] = "ER_BASE64_DECODE_ERROR";
|
|
exports[1576] = "ER_EVENT_RECURSION_FORBIDDEN";
|
|
exports[1577] = "ER_EVENTS_DB_ERROR";
|
|
exports[1578] = "ER_ONLY_INTEGERS_ALLOWED";
|
|
exports[1579] = "ER_UNSUPORTED_LOG_ENGINE";
|
|
exports[1580] = "ER_BAD_LOG_STATEMENT";
|
|
exports[1581] = "ER_CANT_RENAME_LOG_TABLE";
|
|
exports[1582] = "ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT";
|
|
exports[1583] = "ER_WRONG_PARAMETERS_TO_NATIVE_FCT";
|
|
exports[1584] = "ER_WRONG_PARAMETERS_TO_STORED_FCT";
|
|
exports[1585] = "ER_NATIVE_FCT_NAME_COLLISION";
|
|
exports[1586] = "ER_DUP_ENTRY_WITH_KEY_NAME";
|
|
exports[1587] = "ER_BINLOG_PURGE_EMFILE";
|
|
exports[1588] = "ER_EVENT_CANNOT_CREATE_IN_THE_PAST";
|
|
exports[1589] = "ER_EVENT_CANNOT_ALTER_IN_THE_PAST";
|
|
exports[1590] = "ER_SLAVE_INCIDENT";
|
|
exports[1591] = "ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT";
|
|
exports[1592] = "ER_BINLOG_UNSAFE_STATEMENT";
|
|
exports[1593] = "ER_SLAVE_FATAL_ERROR";
|
|
exports[1594] = "ER_SLAVE_RELAY_LOG_READ_FAILURE";
|
|
exports[1595] = "ER_SLAVE_RELAY_LOG_WRITE_FAILURE";
|
|
exports[1596] = "ER_SLAVE_CREATE_EVENT_FAILURE";
|
|
exports[1597] = "ER_SLAVE_MASTER_COM_FAILURE";
|
|
exports[1598] = "ER_BINLOG_LOGGING_IMPOSSIBLE";
|
|
exports[1599] = "ER_VIEW_NO_CREATION_CTX";
|
|
exports[1600] = "ER_VIEW_INVALID_CREATION_CTX";
|
|
exports[1601] = "ER_SR_INVALID_CREATION_CTX";
|
|
exports[1602] = "ER_TRG_CORRUPTED_FILE";
|
|
exports[1603] = "ER_TRG_NO_CREATION_CTX";
|
|
exports[1604] = "ER_TRG_INVALID_CREATION_CTX";
|
|
exports[1605] = "ER_EVENT_INVALID_CREATION_CTX";
|
|
exports[1606] = "ER_TRG_CANT_OPEN_TABLE";
|
|
exports[1607] = "ER_CANT_CREATE_SROUTINE";
|
|
exports[1608] = "ER_NEVER_USED";
|
|
exports[1609] = "ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT";
|
|
exports[1610] = "ER_SLAVE_CORRUPT_EVENT";
|
|
exports[1611] = "ER_LOAD_DATA_INVALID_COLUMN";
|
|
exports[1612] = "ER_LOG_PURGE_NO_FILE";
|
|
exports[1613] = "ER_XA_RBTIMEOUT";
|
|
exports[1614] = "ER_XA_RBDEADLOCK";
|
|
exports[1615] = "ER_NEED_REPREPARE";
|
|
exports[1616] = "ER_DELAYED_NOT_SUPPORTED";
|
|
exports[1617] = "WARN_NO_MASTER_INFO";
|
|
exports[1618] = "WARN_OPTION_IGNORED";
|
|
exports[1619] = "ER_PLUGIN_DELETE_BUILTIN";
|
|
exports[1620] = "WARN_PLUGIN_BUSY";
|
|
exports[1621] = "ER_VARIABLE_IS_READONLY";
|
|
exports[1622] = "ER_WARN_ENGINE_TRANSACTION_ROLLBACK";
|
|
exports[1623] = "ER_SLAVE_HEARTBEAT_FAILURE";
|
|
exports[1624] = "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE";
|
|
exports[1625] = "ER_NDB_REPLICATION_SCHEMA_ERROR";
|
|
exports[1626] = "ER_CONFLICT_FN_PARSE_ERROR";
|
|
exports[1627] = "ER_EXCEPTIONS_WRITE_ERROR";
|
|
exports[1628] = "ER_TOO_LONG_TABLE_COMMENT";
|
|
exports[1629] = "ER_TOO_LONG_FIELD_COMMENT";
|
|
exports[1630] = "ER_FUNC_INEXISTENT_NAME_COLLISION";
|
|
exports[1631] = "ER_DATABASE_NAME";
|
|
exports[1632] = "ER_TABLE_NAME";
|
|
exports[1633] = "ER_PARTITION_NAME";
|
|
exports[1634] = "ER_SUBPARTITION_NAME";
|
|
exports[1635] = "ER_TEMPORARY_NAME";
|
|
exports[1636] = "ER_RENAMED_NAME";
|
|
exports[1637] = "ER_TOO_MANY_CONCURRENT_TRXS";
|
|
exports[1638] = "WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED";
|
|
exports[1639] = "ER_DEBUG_SYNC_TIMEOUT";
|
|
exports[1640] = "ER_DEBUG_SYNC_HIT_LIMIT";
|
|
exports[1641] = "ER_DUP_SIGNAL_SET";
|
|
exports[1642] = "ER_SIGNAL_WARN";
|
|
exports[1643] = "ER_SIGNAL_NOT_FOUND";
|
|
exports[1644] = "ER_SIGNAL_EXCEPTION";
|
|
exports[1645] = "ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER";
|
|
exports[1646] = "ER_SIGNAL_BAD_CONDITION_TYPE";
|
|
exports[1647] = "WARN_COND_ITEM_TRUNCATED";
|
|
exports[1648] = "ER_COND_ITEM_TOO_LONG";
|
|
exports[1649] = "ER_UNKNOWN_LOCALE";
|
|
exports[1650] = "ER_SLAVE_IGNORE_SERVER_IDS";
|
|
exports[1651] = "ER_QUERY_CACHE_DISABLED";
|
|
exports[1652] = "ER_SAME_NAME_PARTITION_FIELD";
|
|
exports[1653] = "ER_PARTITION_COLUMN_LIST_ERROR";
|
|
exports[1654] = "ER_WRONG_TYPE_COLUMN_VALUE_ERROR";
|
|
exports[1655] = "ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR";
|
|
exports[1656] = "ER_MAXVALUE_IN_VALUES_IN";
|
|
exports[1657] = "ER_TOO_MANY_VALUES_ERROR";
|
|
exports[1658] = "ER_ROW_SINGLE_PARTITION_FIELD_ERROR";
|
|
exports[1659] = "ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD";
|
|
exports[1660] = "ER_PARTITION_FIELDS_TOO_LONG";
|
|
exports[1661] = "ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE";
|
|
exports[1662] = "ER_BINLOG_ROW_MODE_AND_STMT_ENGINE";
|
|
exports[1663] = "ER_BINLOG_UNSAFE_AND_STMT_ENGINE";
|
|
exports[1664] = "ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE";
|
|
exports[1665] = "ER_BINLOG_STMT_MODE_AND_ROW_ENGINE";
|
|
exports[1666] = "ER_BINLOG_ROW_INJECTION_AND_STMT_MODE";
|
|
exports[1667] = "ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE";
|
|
exports[1668] = "ER_BINLOG_UNSAFE_LIMIT";
|
|
exports[1669] = "ER_BINLOG_UNSAFE_INSERT_DELAYED";
|
|
exports[1670] = "ER_BINLOG_UNSAFE_SYSTEM_TABLE";
|
|
exports[1671] = "ER_BINLOG_UNSAFE_AUTOINC_COLUMNS";
|
|
exports[1672] = "ER_BINLOG_UNSAFE_UDF";
|
|
exports[1673] = "ER_BINLOG_UNSAFE_SYSTEM_VARIABLE";
|
|
exports[1674] = "ER_BINLOG_UNSAFE_SYSTEM_FUNCTION";
|
|
exports[1675] = "ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS";
|
|
exports[1676] = "ER_MESSAGE_AND_STATEMENT";
|
|
exports[1677] = "ER_SLAVE_CONVERSION_FAILED";
|
|
exports[1678] = "ER_SLAVE_CANT_CREATE_CONVERSION";
|
|
exports[1679] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT";
|
|
exports[1680] = "ER_PATH_LENGTH";
|
|
exports[1681] = "ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT";
|
|
exports[1682] = "ER_WRONG_NATIVE_TABLE_STRUCTURE";
|
|
exports[1683] = "ER_WRONG_PERFSCHEMA_USAGE";
|
|
exports[1684] = "ER_WARN_I_S_SKIPPED_TABLE";
|
|
exports[1685] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT";
|
|
exports[1686] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT";
|
|
exports[1687] = "ER_SPATIAL_MUST_HAVE_GEOM_COL";
|
|
exports[1688] = "ER_TOO_LONG_INDEX_COMMENT";
|
|
exports[1689] = "ER_LOCK_ABORTED";
|
|
exports[1690] = "ER_DATA_OUT_OF_RANGE";
|
|
exports[1691] = "ER_WRONG_SPVAR_TYPE_IN_LIMIT";
|
|
exports[1692] = "ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE";
|
|
exports[1693] = "ER_BINLOG_UNSAFE_MIXED_STATEMENT";
|
|
exports[1694] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN";
|
|
exports[1695] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN";
|
|
exports[1696] = "ER_FAILED_READ_FROM_PAR_FILE";
|
|
exports[1697] = "ER_VALUES_IS_NOT_INT_TYPE_ERROR";
|
|
exports[1698] = "ER_ACCESS_DENIED_NO_PASSWORD_ERROR";
|
|
exports[1699] = "ER_SET_PASSWORD_AUTH_PLUGIN";
|
|
exports[1700] = "ER_GRANT_PLUGIN_USER_EXISTS";
|
|
exports[1701] = "ER_TRUNCATE_ILLEGAL_FK";
|
|
exports[1702] = "ER_PLUGIN_IS_PERMANENT";
|
|
exports[1703] = "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN";
|
|
exports[1704] = "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX";
|
|
exports[1705] = "ER_STMT_CACHE_FULL";
|
|
exports[1706] = "ER_MULTI_UPDATE_KEY_CONFLICT";
|
|
exports[1707] = "ER_TABLE_NEEDS_REBUILD";
|
|
exports[1708] = "WARN_OPTION_BELOW_LIMIT";
|
|
exports[1709] = "ER_INDEX_COLUMN_TOO_LONG";
|
|
exports[1710] = "ER_ERROR_IN_TRIGGER_BODY";
|
|
exports[1711] = "ER_ERROR_IN_UNKNOWN_TRIGGER_BODY";
|
|
exports[1712] = "ER_INDEX_CORRUPT";
|
|
exports[1713] = "ER_UNDO_RECORD_TOO_BIG";
|
|
exports[1714] = "ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT";
|
|
exports[1715] = "ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE";
|
|
exports[1716] = "ER_BINLOG_UNSAFE_REPLACE_SELECT";
|
|
exports[1717] = "ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT";
|
|
exports[1718] = "ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT";
|
|
exports[1719] = "ER_BINLOG_UNSAFE_UPDATE_IGNORE";
|
|
exports[1720] = "ER_PLUGIN_NO_UNINSTALL";
|
|
exports[1721] = "ER_PLUGIN_NO_INSTALL";
|
|
exports[1722] = "ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT";
|
|
exports[1723] = "ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC";
|
|
exports[1724] = "ER_BINLOG_UNSAFE_INSERT_TWO_KEYS";
|
|
exports[1725] = "ER_TABLE_IN_FK_CHECK";
|
|
exports[1726] = "ER_UNSUPPORTED_ENGINE";
|
|
exports[1727] = "ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST";
|
|
exports[1728] = "ER_CANNOT_LOAD_FROM_TABLE_V2";
|
|
exports[1729] = "ER_MASTER_DELAY_VALUE_OUT_OF_RANGE";
|
|
exports[1730] = "ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT";
|
|
exports[1731] = "ER_PARTITION_EXCHANGE_DIFFERENT_OPTION";
|
|
exports[1732] = "ER_PARTITION_EXCHANGE_PART_TABLE";
|
|
exports[1733] = "ER_PARTITION_EXCHANGE_TEMP_TABLE";
|
|
exports[1734] = "ER_PARTITION_INSTEAD_OF_SUBPARTITION";
|
|
exports[1735] = "ER_UNKNOWN_PARTITION";
|
|
exports[1736] = "ER_TABLES_DIFFERENT_METADATA";
|
|
exports[1737] = "ER_ROW_DOES_NOT_MATCH_PARTITION";
|
|
exports[1738] = "ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX";
|
|
exports[1739] = "ER_WARN_INDEX_NOT_APPLICABLE";
|
|
exports[1740] = "ER_PARTITION_EXCHANGE_FOREIGN_KEY";
|
|
exports[1741] = "ER_NO_SUCH_KEY_VALUE";
|
|
exports[1742] = "ER_RPL_INFO_DATA_TOO_LONG";
|
|
exports[1743] = "ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE";
|
|
exports[1744] = "ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE";
|
|
exports[1745] = "ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX";
|
|
exports[1746] = "ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT";
|
|
exports[1747] = "ER_PARTITION_CLAUSE_ON_NONPARTITIONED";
|
|
exports[1748] = "ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET";
|
|
exports[1749] = "ER_NO_SUCH_PARTITION";
|
|
exports[1750] = "ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE";
|
|
exports[1751] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE";
|
|
exports[1752] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE";
|
|
exports[1753] = "ER_MTS_FEATURE_IS_NOT_SUPPORTED";
|
|
exports[1754] = "ER_MTS_UPDATED_DBS_GREATER_MAX";
|
|
exports[1755] = "ER_MTS_CANT_PARALLEL";
|
|
exports[1756] = "ER_MTS_INCONSISTENT_DATA";
|
|
exports[1757] = "ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING";
|
|
exports[1758] = "ER_DA_INVALID_CONDITION_NUMBER";
|
|
exports[1759] = "ER_INSECURE_PLAIN_TEXT";
|
|
exports[1760] = "ER_INSECURE_CHANGE_MASTER";
|
|
exports[1761] = "ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO";
|
|
exports[1762] = "ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO";
|
|
exports[1763] = "ER_SQLTHREAD_WITH_SECURE_SLAVE";
|
|
exports[1764] = "ER_TABLE_HAS_NO_FT";
|
|
exports[1765] = "ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER";
|
|
exports[1766] = "ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION";
|
|
exports[1767] = "ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST";
|
|
exports[1768] = "ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION";
|
|
exports[1769] = "ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION";
|
|
exports[1770] = "ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL";
|
|
exports[1771] = "ER_SKIPPING_LOGGED_TRANSACTION";
|
|
exports[1772] = "ER_MALFORMED_GTID_SET_SPECIFICATION";
|
|
exports[1773] = "ER_MALFORMED_GTID_SET_ENCODING";
|
|
exports[1774] = "ER_MALFORMED_GTID_SPECIFICATION";
|
|
exports[1775] = "ER_GNO_EXHAUSTED";
|
|
exports[1776] = "ER_BAD_SLAVE_AUTO_POSITION";
|
|
exports[1777] = "ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF";
|
|
exports[1778] = "ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET";
|
|
exports[1779] = "ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON";
|
|
exports[1780] = "ER_GTID_MODE_REQUIRES_BINLOG";
|
|
exports[1781] = "ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF";
|
|
exports[1782] = "ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON";
|
|
exports[1783] = "ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF";
|
|
exports[1784] = "ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF";
|
|
exports[1785] = "ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE";
|
|
exports[1786] = "ER_GTID_UNSAFE_CREATE_SELECT";
|
|
exports[1787] = "ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION";
|
|
exports[1788] = "ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME";
|
|
exports[1789] = "ER_MASTER_HAS_PURGED_REQUIRED_GTIDS";
|
|
exports[1790] = "ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID";
|
|
exports[1791] = "ER_UNKNOWN_EXPLAIN_FORMAT";
|
|
exports[1792] = "ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION";
|
|
exports[1793] = "ER_TOO_LONG_TABLE_PARTITION_COMMENT";
|
|
exports[1794] = "ER_SLAVE_CONFIGURATION";
|
|
exports[1795] = "ER_INNODB_FT_LIMIT";
|
|
exports[1796] = "ER_INNODB_NO_FT_TEMP_TABLE";
|
|
exports[1797] = "ER_INNODB_FT_WRONG_DOCID_COLUMN";
|
|
exports[1798] = "ER_INNODB_FT_WRONG_DOCID_INDEX";
|
|
exports[1799] = "ER_INNODB_ONLINE_LOG_TOO_BIG";
|
|
exports[1800] = "ER_UNKNOWN_ALTER_ALGORITHM";
|
|
exports[1801] = "ER_UNKNOWN_ALTER_LOCK";
|
|
exports[1802] = "ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS";
|
|
exports[1803] = "ER_MTS_RECOVERY_FAILURE";
|
|
exports[1804] = "ER_MTS_RESET_WORKERS";
|
|
exports[1805] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2";
|
|
exports[1806] = "ER_SLAVE_SILENT_RETRY_TRANSACTION";
|
|
exports[1807] = "ER_DISCARD_FK_CHECKS_RUNNING";
|
|
exports[1808] = "ER_TABLE_SCHEMA_MISMATCH";
|
|
exports[1809] = "ER_TABLE_IN_SYSTEM_TABLESPACE";
|
|
exports[1810] = "ER_IO_READ_ERROR";
|
|
exports[1811] = "ER_IO_WRITE_ERROR";
|
|
exports[1812] = "ER_TABLESPACE_MISSING";
|
|
exports[1813] = "ER_TABLESPACE_EXISTS";
|
|
exports[1814] = "ER_TABLESPACE_DISCARDED";
|
|
exports[1815] = "ER_INTERNAL_ERROR";
|
|
exports[1816] = "ER_INNODB_IMPORT_ERROR";
|
|
exports[1817] = "ER_INNODB_INDEX_CORRUPT";
|
|
exports[1818] = "ER_INVALID_YEAR_COLUMN_LENGTH";
|
|
exports[1819] = "ER_NOT_VALID_PASSWORD";
|
|
exports[1820] = "ER_MUST_CHANGE_PASSWORD";
|
|
exports[1821] = "ER_FK_NO_INDEX_CHILD";
|
|
exports[1822] = "ER_FK_NO_INDEX_PARENT";
|
|
exports[1823] = "ER_FK_FAIL_ADD_SYSTEM";
|
|
exports[1824] = "ER_FK_CANNOT_OPEN_PARENT";
|
|
exports[1825] = "ER_FK_INCORRECT_OPTION";
|
|
exports[1826] = "ER_FK_DUP_NAME";
|
|
exports[1827] = "ER_PASSWORD_FORMAT";
|
|
exports[1828] = "ER_FK_COLUMN_CANNOT_DROP";
|
|
exports[1829] = "ER_FK_COLUMN_CANNOT_DROP_CHILD";
|
|
exports[1830] = "ER_FK_COLUMN_NOT_NULL";
|
|
exports[1831] = "ER_DUP_INDEX";
|
|
exports[1832] = "ER_FK_COLUMN_CANNOT_CHANGE";
|
|
exports[1833] = "ER_FK_COLUMN_CANNOT_CHANGE_CHILD";
|
|
exports[1834] = "ER_FK_CANNOT_DELETE_PARENT";
|
|
exports[1835] = "ER_MALFORMED_PACKET";
|
|
exports[1836] = "ER_READ_ONLY_MODE";
|
|
exports[1837] = "ER_GTID_NEXT_TYPE_UNDEFINED_GROUP";
|
|
exports[1838] = "ER_VARIABLE_NOT_SETTABLE_IN_SP";
|
|
exports[1839] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF";
|
|
exports[1840] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY";
|
|
exports[1841] = "ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY";
|
|
exports[1842] = "ER_GTID_PURGED_WAS_CHANGED";
|
|
exports[1843] = "ER_GTID_EXECUTED_WAS_CHANGED";
|
|
exports[1844] = "ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES";
|
|
exports[1845] = "ER_ALTER_OPERATION_NOT_SUPPORTED";
|
|
exports[1846] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON";
|
|
exports[1847] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY";
|
|
exports[1848] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION";
|
|
exports[1849] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME";
|
|
exports[1850] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE";
|
|
exports[1851] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK";
|
|
exports[1852] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_IGNORE";
|
|
exports[1853] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK";
|
|
exports[1854] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC";
|
|
exports[1855] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS";
|
|
exports[1856] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS";
|
|
exports[1857] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS";
|
|
exports[1858] = "ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE";
|
|
exports[1859] = "ER_DUP_UNKNOWN_IN_INDEX";
|
|
exports[1860] = "ER_IDENT_CAUSES_TOO_LONG_PATH";
|
|
exports[1861] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL";
|
|
exports[1862] = "ER_MUST_CHANGE_PASSWORD_LOGIN";
|
|
exports[1863] = "ER_ROW_IN_WRONG_PARTITION";
|
|
exports[1864] = "ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX";
|
|
exports[1865] = "ER_INNODB_NO_FT_USES_PARSER";
|
|
exports[1866] = "ER_BINLOG_LOGICAL_CORRUPTION";
|
|
exports[1867] = "ER_WARN_PURGE_LOG_IN_USE";
|
|
exports[1868] = "ER_WARN_PURGE_LOG_IS_ACTIVE";
|
|
exports[1869] = "ER_AUTO_INCREMENT_CONFLICT";
|
|
exports[1870] = "WARN_ON_BLOCKHOLE_IN_RBR";
|
|
exports[1871] = "ER_SLAVE_MI_INIT_REPOSITORY";
|
|
exports[1872] = "ER_SLAVE_RLI_INIT_REPOSITORY";
|
|
exports[1873] = "ER_ACCESS_DENIED_CHANGE_USER_ERROR";
|
|
exports[1874] = "ER_INNODB_READ_ONLY";
|
|
exports[1875] = "ER_STOP_SLAVE_SQL_THREAD_TIMEOUT";
|
|
exports[1876] = "ER_STOP_SLAVE_IO_THREAD_TIMEOUT";
|
|
exports[1877] = "ER_TABLE_CORRUPT";
|
|
exports[1878] = "ER_TEMP_FILE_WRITE_FAILURE";
|
|
exports[1879] = "ER_INNODB_FT_AUX_NOT_HEX_ID";
|
|
exports[1880] = "ER_OLD_TEMPORALS_UPGRADED";
|
|
exports[1881] = "ER_INNODB_FORCED_RECOVERY";
|
|
exports[1882] = "ER_AES_INVALID_IV";
|
|
exports[1883] = "ER_PLUGIN_CANNOT_BE_UNINSTALLED";
|
|
exports[1884] = "ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_GTID_GROUP";
|
|
exports[1885] = "ER_SLAVE_HAS_MORE_GTIDS_THAN_MASTER";
|
|
exports[1886] = "ER_MISSING_KEY";
|
|
exports[1887] = "WARN_NAMED_PIPE_ACCESS_EVERYONE";
|
|
exports[1888] = "ER_FOUND_MISSING_GTIDS";
|
|
exports[3000] = "ER_FILE_CORRUPT";
|
|
exports[3001] = "ER_ERROR_ON_MASTER";
|
|
exports[3002] = "ER_INCONSISTENT_ERROR";
|
|
exports[3003] = "ER_STORAGE_ENGINE_NOT_LOADED";
|
|
exports[3004] = "ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER";
|
|
exports[3005] = "ER_WARN_LEGACY_SYNTAX_CONVERTED";
|
|
exports[3006] = "ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN";
|
|
exports[3007] = "ER_CANNOT_DISCARD_TEMPORARY_TABLE";
|
|
exports[3008] = "ER_FK_DEPTH_EXCEEDED";
|
|
exports[3009] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2";
|
|
exports[3010] = "ER_WARN_TRIGGER_DOESNT_HAVE_CREATED";
|
|
exports[3011] = "ER_REFERENCED_TRG_DOES_NOT_EXIST";
|
|
exports[3012] = "ER_EXPLAIN_NOT_SUPPORTED";
|
|
exports[3013] = "ER_INVALID_FIELD_SIZE";
|
|
exports[3014] = "ER_MISSING_HA_CREATE_OPTION";
|
|
exports[3015] = "ER_ENGINE_OUT_OF_MEMORY";
|
|
exports[3016] = "ER_PASSWORD_EXPIRE_ANONYMOUS_USER";
|
|
exports[3017] = "ER_SLAVE_SQL_THREAD_MUST_STOP";
|
|
exports[3018] = "ER_NO_FT_MATERIALIZED_SUBQUERY";
|
|
exports[3019] = "ER_INNODB_UNDO_LOG_FULL";
|
|
exports[3020] = "ER_INVALID_ARGUMENT_FOR_LOGARITHM";
|
|
exports[3021] = "ER_SLAVE_CHANNEL_IO_THREAD_MUST_STOP";
|
|
exports[3022] = "ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO";
|
|
exports[3023] = "ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS";
|
|
exports[3024] = "ER_QUERY_TIMEOUT";
|
|
exports[3025] = "ER_NON_RO_SELECT_DISABLE_TIMER";
|
|
exports[3026] = "ER_DUP_LIST_ENTRY";
|
|
exports[3027] = "ER_SQL_MODE_NO_EFFECT";
|
|
exports[3028] = "ER_AGGREGATE_ORDER_FOR_UNION";
|
|
exports[3029] = "ER_AGGREGATE_ORDER_NON_AGG_QUERY";
|
|
exports[3030] = "ER_SLAVE_WORKER_STOPPED_PREVIOUS_THD_ERROR";
|
|
exports[3031] = "ER_DONT_SUPPORT_SLAVE_PRESERVE_COMMIT_ORDER";
|
|
exports[3032] = "ER_SERVER_OFFLINE_MODE";
|
|
exports[3033] = "ER_GIS_DIFFERENT_SRIDS";
|
|
exports[3034] = "ER_GIS_UNSUPPORTED_ARGUMENT";
|
|
exports[3035] = "ER_GIS_UNKNOWN_ERROR";
|
|
exports[3036] = "ER_GIS_UNKNOWN_EXCEPTION";
|
|
exports[3037] = "ER_GIS_INVALID_DATA";
|
|
exports[3038] = "ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION";
|
|
exports[3039] = "ER_BOOST_GEOMETRY_CENTROID_EXCEPTION";
|
|
exports[3040] = "ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION";
|
|
exports[3041] = "ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION";
|
|
exports[3042] = "ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION";
|
|
exports[3043] = "ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION";
|
|
exports[3044] = "ER_STD_BAD_ALLOC_ERROR";
|
|
exports[3045] = "ER_STD_DOMAIN_ERROR";
|
|
exports[3046] = "ER_STD_LENGTH_ERROR";
|
|
exports[3047] = "ER_STD_INVALID_ARGUMENT";
|
|
exports[3048] = "ER_STD_OUT_OF_RANGE_ERROR";
|
|
exports[3049] = "ER_STD_OVERFLOW_ERROR";
|
|
exports[3050] = "ER_STD_RANGE_ERROR";
|
|
exports[3051] = "ER_STD_UNDERFLOW_ERROR";
|
|
exports[3052] = "ER_STD_LOGIC_ERROR";
|
|
exports[3053] = "ER_STD_RUNTIME_ERROR";
|
|
exports[3054] = "ER_STD_UNKNOWN_EXCEPTION";
|
|
exports[3055] = "ER_GIS_DATA_WRONG_ENDIANESS";
|
|
exports[3056] = "ER_CHANGE_MASTER_PASSWORD_LENGTH";
|
|
exports[3057] = "ER_USER_LOCK_WRONG_NAME";
|
|
exports[3058] = "ER_USER_LOCK_DEADLOCK";
|
|
exports[3059] = "ER_REPLACE_INACCESSIBLE_ROWS";
|
|
exports[3060] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS";
|
|
exports[3061] = "ER_ILLEGAL_USER_VAR";
|
|
exports[3062] = "ER_GTID_MODE_OFF";
|
|
exports[3063] = "ER_UNSUPPORTED_BY_REPLICATION_THREAD";
|
|
exports[3064] = "ER_INCORRECT_TYPE";
|
|
exports[3065] = "ER_FIELD_IN_ORDER_NOT_SELECT";
|
|
exports[3066] = "ER_AGGREGATE_IN_ORDER_NOT_SELECT";
|
|
exports[3067] = "ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN";
|
|
exports[3068] = "ER_NET_OK_PACKET_TOO_LARGE";
|
|
exports[3069] = "ER_INVALID_JSON_DATA";
|
|
exports[3070] = "ER_INVALID_GEOJSON_MISSING_MEMBER";
|
|
exports[3071] = "ER_INVALID_GEOJSON_WRONG_TYPE";
|
|
exports[3072] = "ER_INVALID_GEOJSON_UNSPECIFIED";
|
|
exports[3073] = "ER_DIMENSION_UNSUPPORTED";
|
|
exports[3074] = "ER_SLAVE_CHANNEL_DOES_NOT_EXIST";
|
|
exports[3075] = "ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT";
|
|
exports[3076] = "ER_SLAVE_CHANNEL_NAME_INVALID_OR_TOO_LONG";
|
|
exports[3077] = "ER_SLAVE_NEW_CHANNEL_WRONG_REPOSITORY";
|
|
exports[3078] = "ER_SLAVE_CHANNEL_DELETE";
|
|
exports[3079] = "ER_SLAVE_MULTIPLE_CHANNELS_CMD";
|
|
exports[3080] = "ER_SLAVE_MAX_CHANNELS_EXCEEDED";
|
|
exports[3081] = "ER_SLAVE_CHANNEL_MUST_STOP";
|
|
exports[3082] = "ER_SLAVE_CHANNEL_NOT_RUNNING";
|
|
exports[3083] = "ER_SLAVE_CHANNEL_WAS_RUNNING";
|
|
exports[3084] = "ER_SLAVE_CHANNEL_WAS_NOT_RUNNING";
|
|
exports[3085] = "ER_SLAVE_CHANNEL_SQL_THREAD_MUST_STOP";
|
|
exports[3086] = "ER_SLAVE_CHANNEL_SQL_SKIP_COUNTER";
|
|
exports[3087] = "ER_WRONG_FIELD_WITH_GROUP_V2";
|
|
exports[3088] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2";
|
|
exports[3089] = "ER_WARN_DEPRECATED_SYSVAR_UPDATE";
|
|
exports[3090] = "ER_WARN_DEPRECATED_SQLMODE";
|
|
exports[3091] = "ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID";
|
|
exports[3092] = "ER_GROUP_REPLICATION_CONFIGURATION";
|
|
exports[3093] = "ER_GROUP_REPLICATION_RUNNING";
|
|
exports[3094] = "ER_GROUP_REPLICATION_APPLIER_INIT_ERROR";
|
|
exports[3095] = "ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT";
|
|
exports[3096] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR";
|
|
exports[3097] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR";
|
|
exports[3098] = "ER_BEFORE_DML_VALIDATION_ERROR";
|
|
exports[3099] = "ER_PREVENTS_VARIABLE_WITHOUT_RBR";
|
|
exports[3100] = "ER_RUN_HOOK_ERROR";
|
|
exports[3101] = "ER_TRANSACTION_ROLLBACK_DURING_COMMIT";
|
|
exports[3102] = "ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED";
|
|
exports[3103] = "ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN";
|
|
exports[3104] = "ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN";
|
|
exports[3105] = "ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN";
|
|
exports[3106] = "ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN";
|
|
exports[3107] = "ER_GENERATED_COLUMN_NON_PRIOR";
|
|
exports[3108] = "ER_DEPENDENT_BY_GENERATED_COLUMN";
|
|
exports[3109] = "ER_GENERATED_COLUMN_REF_AUTO_INC";
|
|
exports[3110] = "ER_FEATURE_NOT_AVAILABLE";
|
|
exports[3111] = "ER_CANT_SET_GTID_MODE";
|
|
exports[3112] = "ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF";
|
|
exports[3113] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION";
|
|
exports[3114] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON";
|
|
exports[3115] = "ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF";
|
|
exports[3116] = "ER_CANT_SET_ENFORCE_GTID_CONSISTENCY_ON_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS";
|
|
exports[3117] = "ER_SET_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS";
|
|
exports[3118] = "ER_ACCOUNT_HAS_BEEN_LOCKED";
|
|
exports[3119] = "ER_WRONG_TABLESPACE_NAME";
|
|
exports[3120] = "ER_TABLESPACE_IS_NOT_EMPTY";
|
|
exports[3121] = "ER_WRONG_FILE_NAME";
|
|
exports[3122] = "ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION";
|
|
exports[3123] = "ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR";
|
|
exports[3124] = "ER_WARN_BAD_MAX_EXECUTION_TIME";
|
|
exports[3125] = "ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME";
|
|
exports[3126] = "ER_WARN_CONFLICTING_HINT";
|
|
exports[3127] = "ER_WARN_UNKNOWN_QB_NAME";
|
|
exports[3128] = "ER_UNRESOLVED_HINT_NAME";
|
|
exports[3129] = "ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE";
|
|
exports[3130] = "ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED";
|
|
exports[3131] = "ER_LOCKING_SERVICE_WRONG_NAME";
|
|
exports[3132] = "ER_LOCKING_SERVICE_DEADLOCK";
|
|
exports[3133] = "ER_LOCKING_SERVICE_TIMEOUT";
|
|
exports[3134] = "ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED";
|
|
exports[3135] = "ER_SQL_MODE_MERGED";
|
|
exports[3136] = "ER_VTOKEN_PLUGIN_TOKEN_MISMATCH";
|
|
exports[3137] = "ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND";
|
|
exports[3138] = "ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID";
|
|
exports[3139] = "ER_SLAVE_CHANNEL_OPERATION_NOT_ALLOWED";
|
|
exports[3140] = "ER_INVALID_JSON_TEXT";
|
|
exports[3141] = "ER_INVALID_JSON_TEXT_IN_PARAM";
|
|
exports[3142] = "ER_INVALID_JSON_BINARY_DATA";
|
|
exports[3143] = "ER_INVALID_JSON_PATH";
|
|
exports[3144] = "ER_INVALID_JSON_CHARSET";
|
|
exports[3145] = "ER_INVALID_JSON_CHARSET_IN_FUNCTION";
|
|
exports[3146] = "ER_INVALID_TYPE_FOR_JSON";
|
|
exports[3147] = "ER_INVALID_CAST_TO_JSON";
|
|
exports[3148] = "ER_INVALID_JSON_PATH_CHARSET";
|
|
exports[3149] = "ER_INVALID_JSON_PATH_WILDCARD";
|
|
exports[3150] = "ER_JSON_VALUE_TOO_BIG";
|
|
exports[3151] = "ER_JSON_KEY_TOO_BIG";
|
|
exports[3152] = "ER_JSON_USED_AS_KEY";
|
|
exports[3153] = "ER_JSON_VACUOUS_PATH";
|
|
exports[3154] = "ER_JSON_BAD_ONE_OR_ALL_ARG";
|
|
exports[3155] = "ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE";
|
|
exports[3156] = "ER_INVALID_JSON_VALUE_FOR_CAST";
|
|
exports[3157] = "ER_JSON_DOCUMENT_TOO_DEEP";
|
|
exports[3158] = "ER_JSON_DOCUMENT_NULL_KEY";
|
|
exports[3159] = "ER_SECURE_TRANSPORT_REQUIRED";
|
|
exports[3160] = "ER_NO_SECURE_TRANSPORTS_CONFIGURED";
|
|
exports[3161] = "ER_DISABLED_STORAGE_ENGINE";
|
|
exports[3162] = "ER_USER_DOES_NOT_EXIST";
|
|
exports[3163] = "ER_USER_ALREADY_EXISTS";
|
|
exports[3164] = "ER_AUDIT_API_ABORT";
|
|
exports[3165] = "ER_INVALID_JSON_PATH_ARRAY_CELL";
|
|
exports[3166] = "ER_BUFPOOL_RESIZE_INPROGRESS";
|
|
exports[3167] = "ER_FEATURE_DISABLED_SEE_DOC";
|
|
exports[3168] = "ER_SERVER_ISNT_AVAILABLE";
|
|
exports[3169] = "ER_SESSION_WAS_KILLED";
|
|
exports[3170] = "ER_CAPACITY_EXCEEDED";
|
|
exports[3171] = "ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER";
|
|
exports[3172] = "ER_TABLE_NEEDS_UPG_PART";
|
|
exports[3173] = "ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID";
|
|
exports[3174] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL";
|
|
exports[3175] = "ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT";
|
|
exports[3176] = "ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE";
|
|
exports[3177] = "ER_LOCK_REFUSED_BY_ENGINE";
|
|
exports[3178] = "ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN";
|
|
exports[3179] = "ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE";
|
|
exports[3180] = "ER_MASTER_KEY_ROTATION_ERROR_BY_SE";
|
|
exports[3181] = "ER_MASTER_KEY_ROTATION_BINLOG_FAILED";
|
|
exports[3182] = "ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE";
|
|
exports[3183] = "ER_TABLESPACE_CANNOT_ENCRYPT";
|
|
exports[3184] = "ER_INVALID_ENCRYPTION_OPTION";
|
|
exports[3185] = "ER_CANNOT_FIND_KEY_IN_KEYRING";
|
|
exports[3186] = "ER_CAPACITY_EXCEEDED_IN_PARSER";
|
|
exports[3187] = "ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE";
|
|
exports[3188] = "ER_KEYRING_UDF_KEYRING_SERVICE_ERROR";
|
|
exports[3189] = "ER_USER_COLUMN_OLD_LENGTH";
|
|
exports[3190] = "ER_CANT_RESET_MASTER";
|
|
exports[3191] = "ER_GROUP_REPLICATION_MAX_GROUP_SIZE";
|
|
exports[3192] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED";
|
|
exports[3193] = "ER_TABLE_REFERENCED";
|
|
exports[3194] = "ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE";
|
|
exports[3195] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO";
|
|
exports[3196] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID";
|
|
exports[3197] = "ER_XA_RETRY";
|
|
exports[3198] = "ER_KEYRING_AWS_UDF_AWS_KMS_ERROR";
|
|
exports[3199] = "ER_BINLOG_UNSAFE_XA";
|
|
exports[3200] = "ER_UDF_ERROR";
|
|
exports[3201] = "ER_KEYRING_MIGRATION_FAILURE";
|
|
exports[3202] = "ER_KEYRING_ACCESS_DENIED_ERROR";
|
|
exports[3203] = "ER_KEYRING_MIGRATION_STATUS";
|
|
exports[3204] = "ER_PLUGIN_FAILED_TO_OPEN_TABLES";
|
|
exports[3205] = "ER_PLUGIN_FAILED_TO_OPEN_TABLE";
|
|
exports[3206] = "ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED";
|
|
exports[3207] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET";
|
|
exports[3208] = "ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY";
|
|
exports[3209] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED";
|
|
exports[3210] = "ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED";
|
|
exports[3211] = "ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE";
|
|
exports[3212] = "ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED";
|
|
exports[3213] = "ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS";
|
|
exports[3214] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE";
|
|
exports[3215] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT";
|
|
exports[3216] = "ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED";
|
|
exports[3217] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE";
|
|
exports[3218] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE";
|
|
exports[3219] = "ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR";
|
|
exports[3220] = "ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY";
|
|
exports[3221] = "ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY";
|
|
exports[3222] = "ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS";
|
|
exports[3223] = "ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC";
|
|
exports[3224] = "ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER";
|
|
exports[3225] = "ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER";
|
|
exports[3226] = "WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP";
|
|
exports[3227] = "ER_XA_REPLICATION_FILTERS";
|
|
exports[3228] = "ER_CANT_OPEN_ERROR_LOG";
|
|
exports[3229] = "ER_GROUPING_ON_TIMESTAMP_IN_DST";
|
|
exports[3230] = "ER_CANT_START_SERVER_NAMED_PIPE";
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/Timer.js
|
|
var require_Timer = __commonJS((exports, module) => {
|
|
var Timers = __require("timers");
|
|
module.exports = Timer;
|
|
function Timer(object) {
|
|
this._object = object;
|
|
this._timeout = null;
|
|
}
|
|
Timer.prototype.active = function active() {
|
|
if (this._timeout) {
|
|
if (this._timeout.refresh) {
|
|
this._timeout.refresh();
|
|
} else {
|
|
Timers.active(this._timeout);
|
|
}
|
|
}
|
|
};
|
|
Timer.prototype.start = function start(msecs) {
|
|
this.stop();
|
|
this._timeout = Timers.setTimeout(this._onTimeout.bind(this), msecs);
|
|
};
|
|
Timer.prototype.stop = function stop() {
|
|
if (this._timeout) {
|
|
Timers.clearTimeout(this._timeout);
|
|
this._timeout = null;
|
|
}
|
|
};
|
|
Timer.prototype._onTimeout = function _onTimeout() {
|
|
return this._object._onTimeout();
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Sequence.js
|
|
var require_Sequence = __commonJS((exports, module) => {
|
|
var Util = __require("util");
|
|
var EventEmitter = __require("events").EventEmitter;
|
|
var Packets = require_packets();
|
|
var ErrorConstants = require_errors();
|
|
var Timer = require_Timer();
|
|
var listenerCount = EventEmitter.listenerCount || function(emitter, type) {
|
|
return emitter.listeners(type).length;
|
|
};
|
|
var LONG_STACK_DELIMITER = "\n --------------------\n";
|
|
module.exports = Sequence;
|
|
Util.inherits(Sequence, EventEmitter);
|
|
function Sequence(options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
EventEmitter.call(this);
|
|
options = options || {};
|
|
this._callback = callback;
|
|
this._callSite = null;
|
|
this._ended = false;
|
|
this._timeout = options.timeout;
|
|
this._timer = new Timer(this);
|
|
}
|
|
Sequence.determinePacket = function(byte) {
|
|
switch (byte) {
|
|
case 0:
|
|
return Packets.OkPacket;
|
|
case 254:
|
|
return Packets.EofPacket;
|
|
case 255:
|
|
return Packets.ErrorPacket;
|
|
default:
|
|
return;
|
|
}
|
|
};
|
|
Sequence.prototype.hasErrorHandler = function() {
|
|
return Boolean(this._callback) || listenerCount(this, "error") > 1;
|
|
};
|
|
Sequence.prototype._packetToError = function(packet) {
|
|
var code = ErrorConstants[packet.errno] || "UNKNOWN_CODE_PLEASE_REPORT";
|
|
var err = new Error(code + ": " + packet.message);
|
|
err.code = code;
|
|
err.errno = packet.errno;
|
|
err.sqlMessage = packet.message;
|
|
err.sqlState = packet.sqlState;
|
|
return err;
|
|
};
|
|
Sequence.prototype.end = function(err) {
|
|
if (this._ended) {
|
|
return;
|
|
}
|
|
this._ended = true;
|
|
if (err) {
|
|
this._addLongStackTrace(err);
|
|
}
|
|
this._callSite = null;
|
|
try {
|
|
if (err) {
|
|
this.emit("error", err);
|
|
}
|
|
} finally {
|
|
try {
|
|
if (this._callback) {
|
|
this._callback.apply(this, arguments);
|
|
}
|
|
} finally {
|
|
this.emit("end");
|
|
}
|
|
}
|
|
};
|
|
Sequence.prototype["OkPacket"] = function(packet) {
|
|
this.end(null, packet);
|
|
};
|
|
Sequence.prototype["ErrorPacket"] = function(packet) {
|
|
this.end(this._packetToError(packet));
|
|
};
|
|
Sequence.prototype.start = function() {
|
|
};
|
|
Sequence.prototype._addLongStackTrace = function _addLongStackTrace(err) {
|
|
var callSiteStack = this._callSite && this._callSite.stack;
|
|
if (!callSiteStack || typeof callSiteStack !== "string") {
|
|
return;
|
|
}
|
|
if (err.stack.indexOf(LONG_STACK_DELIMITER) !== -1) {
|
|
return;
|
|
}
|
|
var index = callSiteStack.indexOf("\n");
|
|
if (index !== -1) {
|
|
err.stack += LONG_STACK_DELIMITER + callSiteStack.substr(index + 1);
|
|
}
|
|
};
|
|
Sequence.prototype._onTimeout = function _onTimeout() {
|
|
this.emit("timeout");
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/Auth.js
|
|
var require_Auth = __commonJS((exports) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var Crypto = __require("crypto");
|
|
var Auth = exports;
|
|
function auth(name, data, options) {
|
|
options = options || {};
|
|
switch (name) {
|
|
case "mysql_native_password":
|
|
return Auth.token(options.password, data.slice(0, 20));
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
Auth.auth = auth;
|
|
function sha1(msg) {
|
|
var hash = Crypto.createHash("sha1");
|
|
hash.update(msg, "binary");
|
|
return hash.digest("binary");
|
|
}
|
|
Auth.sha1 = sha1;
|
|
function xor(a, b) {
|
|
a = Buffer2.from(a, "binary");
|
|
b = Buffer2.from(b, "binary");
|
|
var result = Buffer2.allocUnsafe(a.length);
|
|
for (var i = 0;i < a.length; i++) {
|
|
result[i] = a[i] ^ b[i];
|
|
}
|
|
return result;
|
|
}
|
|
Auth.xor = xor;
|
|
Auth.token = function(password, scramble) {
|
|
if (!password) {
|
|
return Buffer2.alloc(0);
|
|
}
|
|
var stage1 = sha1(Buffer2.from(password, "utf8").toString("binary"));
|
|
var stage2 = sha1(stage1);
|
|
var stage3 = sha1(scramble.toString("binary") + stage2);
|
|
return xor(stage3, stage1);
|
|
};
|
|
Auth.hashPassword = function(password) {
|
|
var nr = [20528, 22325];
|
|
var add = 7;
|
|
var nr2 = [4660, 22129];
|
|
var result = Buffer2.alloc(8);
|
|
if (typeof password === "string") {
|
|
password = Buffer2.from(password);
|
|
}
|
|
for (var i = 0;i < password.length; i++) {
|
|
var c = password[i];
|
|
if (c === 32 || c === 9) {
|
|
continue;
|
|
}
|
|
nr = this.xor32(nr, this.add32(this.mul32(this.add32(this.and32(nr, [0, 63]), [0, add]), [0, c]), this.shl32(nr, 8)));
|
|
nr2 = this.add32(nr2, this.xor32(this.shl32(nr2, 8), nr));
|
|
add += c;
|
|
}
|
|
this.int31Write(result, nr, 0);
|
|
this.int31Write(result, nr2, 4);
|
|
return result;
|
|
};
|
|
Auth.randomInit = function(seed1, seed2) {
|
|
return {
|
|
max_value: 1073741823,
|
|
max_value_dbl: 1073741823,
|
|
seed1: seed1 % 1073741823,
|
|
seed2: seed2 % 1073741823
|
|
};
|
|
};
|
|
Auth.myRnd = function(r) {
|
|
r.seed1 = (r.seed1 * 3 + r.seed2) % r.max_value;
|
|
r.seed2 = (r.seed1 + r.seed2 + 33) % r.max_value;
|
|
return r.seed1 / r.max_value_dbl;
|
|
};
|
|
Auth.scramble323 = function(message, password) {
|
|
if (!password) {
|
|
return Buffer2.alloc(0);
|
|
}
|
|
var to = Buffer2.allocUnsafe(8);
|
|
var hashPass = this.hashPassword(password);
|
|
var hashMessage = this.hashPassword(message.slice(0, 8));
|
|
var seed1 = this.int32Read(hashPass, 0) ^ this.int32Read(hashMessage, 0);
|
|
var seed2 = this.int32Read(hashPass, 4) ^ this.int32Read(hashMessage, 4);
|
|
var r = this.randomInit(seed1, seed2);
|
|
for (var i = 0;i < 8; i++) {
|
|
to[i] = Math.floor(this.myRnd(r) * 31) + 64;
|
|
}
|
|
var extra = Math.floor(this.myRnd(r) * 31);
|
|
for (var i = 0;i < 8; i++) {
|
|
to[i] ^= extra;
|
|
}
|
|
return to;
|
|
};
|
|
Auth.xor32 = function(a, b) {
|
|
return [a[0] ^ b[0], a[1] ^ b[1]];
|
|
};
|
|
Auth.add32 = function(a, b) {
|
|
var w1 = a[1] + b[1];
|
|
var w2 = a[0] + b[0] + ((w1 & 4294901760) >> 16);
|
|
return [w2 & 65535, w1 & 65535];
|
|
};
|
|
Auth.mul32 = function(a, b) {
|
|
var w1 = a[1] * b[1];
|
|
var w2 = (a[1] * b[1] >> 16 & 65535) + (a[0] * b[1] & 65535) + (a[1] * b[0] & 65535);
|
|
return [w2 & 65535, w1 & 65535];
|
|
};
|
|
Auth.and32 = function(a, b) {
|
|
return [a[0] & b[0], a[1] & b[1]];
|
|
};
|
|
Auth.shl32 = function(a, b) {
|
|
var w1 = a[1] << b;
|
|
var w2 = a[0] << b | (w1 & 4294901760) >> 16;
|
|
return [w2 & 65535, w1 & 65535];
|
|
};
|
|
Auth.int31Write = function(buffer, number, offset) {
|
|
buffer[offset] = number[0] >> 8 & 127;
|
|
buffer[offset + 1] = number[0] & 255;
|
|
buffer[offset + 2] = number[1] >> 8 & 255;
|
|
buffer[offset + 3] = number[1] & 255;
|
|
};
|
|
Auth.int32Read = function(buffer, offset) {
|
|
return (buffer[offset] << 24) + (buffer[offset + 1] << 16) + (buffer[offset + 2] << 8) + buffer[offset + 3];
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/ChangeUser.js
|
|
var require_ChangeUser = __commonJS((exports, module) => {
|
|
var Sequence = require_Sequence();
|
|
var Util = __require("util");
|
|
var Packets = require_packets();
|
|
var Auth = require_Auth();
|
|
module.exports = ChangeUser;
|
|
Util.inherits(ChangeUser, Sequence);
|
|
function ChangeUser(options, callback) {
|
|
Sequence.call(this, options, callback);
|
|
this._user = options.user;
|
|
this._password = options.password;
|
|
this._database = options.database;
|
|
this._charsetNumber = options.charsetNumber;
|
|
this._currentConfig = options.currentConfig;
|
|
}
|
|
ChangeUser.prototype.determinePacket = function determinePacket(firstByte) {
|
|
switch (firstByte) {
|
|
case 254:
|
|
return Packets.AuthSwitchRequestPacket;
|
|
case 255:
|
|
return Packets.ErrorPacket;
|
|
default:
|
|
return;
|
|
}
|
|
};
|
|
ChangeUser.prototype.start = function(handshakeInitializationPacket) {
|
|
var scrambleBuff = handshakeInitializationPacket.scrambleBuff();
|
|
scrambleBuff = Auth.token(this._password, scrambleBuff);
|
|
var packet = new Packets.ComChangeUserPacket({
|
|
user: this._user,
|
|
scrambleBuff,
|
|
database: this._database,
|
|
charsetNumber: this._charsetNumber
|
|
});
|
|
this._currentConfig.user = this._user;
|
|
this._currentConfig.password = this._password;
|
|
this._currentConfig.database = this._database;
|
|
this._currentConfig.charsetNumber = this._charsetNumber;
|
|
this.emit("packet", packet);
|
|
};
|
|
ChangeUser.prototype["AuthSwitchRequestPacket"] = function(packet) {
|
|
var name = packet.authMethodName;
|
|
var data = Auth.auth(name, packet.authMethodData, {
|
|
password: this._password
|
|
});
|
|
if (data !== undefined) {
|
|
this.emit("packet", new Packets.AuthSwitchResponsePacket({
|
|
data
|
|
}));
|
|
} else {
|
|
var err = new Error("MySQL is requesting the " + name + " authentication method, which is not supported.");
|
|
err.code = "UNSUPPORTED_AUTH_METHOD";
|
|
err.fatal = true;
|
|
this.end(err);
|
|
}
|
|
};
|
|
ChangeUser.prototype["ErrorPacket"] = function(packet) {
|
|
var err = this._packetToError(packet);
|
|
err.fatal = true;
|
|
this.end(err);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Handshake.js
|
|
var require_Handshake = __commonJS((exports, module) => {
|
|
var Sequence = require_Sequence();
|
|
var Util = __require("util");
|
|
var Packets = require_packets();
|
|
var Auth = require_Auth();
|
|
var ClientConstants = require_client();
|
|
module.exports = Handshake;
|
|
Util.inherits(Handshake, Sequence);
|
|
function Handshake(options, callback) {
|
|
Sequence.call(this, options, callback);
|
|
options = options || {};
|
|
this._config = options.config;
|
|
this._handshakeInitializationPacket = null;
|
|
}
|
|
Handshake.prototype.determinePacket = function determinePacket(firstByte, parser) {
|
|
if (firstByte === 255) {
|
|
return Packets.ErrorPacket;
|
|
}
|
|
if (!this._handshakeInitializationPacket) {
|
|
return Packets.HandshakeInitializationPacket;
|
|
}
|
|
if (firstByte === 254) {
|
|
return parser.packetLength() === 1 ? Packets.UseOldPasswordPacket : Packets.AuthSwitchRequestPacket;
|
|
}
|
|
return;
|
|
};
|
|
Handshake.prototype["AuthSwitchRequestPacket"] = function(packet) {
|
|
var name = packet.authMethodName;
|
|
var data = Auth.auth(name, packet.authMethodData, {
|
|
password: this._config.password
|
|
});
|
|
if (data !== undefined) {
|
|
this.emit("packet", new Packets.AuthSwitchResponsePacket({
|
|
data
|
|
}));
|
|
} else {
|
|
var err = new Error("MySQL is requesting the " + name + " authentication method, which is not supported.");
|
|
err.code = "UNSUPPORTED_AUTH_METHOD";
|
|
err.fatal = true;
|
|
this.end(err);
|
|
}
|
|
};
|
|
Handshake.prototype["HandshakeInitializationPacket"] = function(packet) {
|
|
this._handshakeInitializationPacket = packet;
|
|
this._config.protocol41 = packet.protocol41;
|
|
var serverSSLSupport = packet.serverCapabilities1 & ClientConstants.CLIENT_SSL;
|
|
if (this._config.ssl) {
|
|
if (!serverSSLSupport) {
|
|
var err = new Error("Server does not support secure connection");
|
|
err.code = "HANDSHAKE_NO_SSL_SUPPORT";
|
|
err.fatal = true;
|
|
this.end(err);
|
|
return;
|
|
}
|
|
this._config.clientFlags |= ClientConstants.CLIENT_SSL;
|
|
this.emit("packet", new Packets.SSLRequestPacket({
|
|
clientFlags: this._config.clientFlags,
|
|
maxPacketSize: this._config.maxPacketSize,
|
|
charsetNumber: this._config.charsetNumber
|
|
}));
|
|
this.emit("start-tls");
|
|
} else {
|
|
this._sendCredentials();
|
|
}
|
|
};
|
|
Handshake.prototype._tlsUpgradeCompleteHandler = function() {
|
|
this._sendCredentials();
|
|
};
|
|
Handshake.prototype._sendCredentials = function() {
|
|
var packet = this._handshakeInitializationPacket;
|
|
this.emit("packet", new Packets.ClientAuthenticationPacket({
|
|
clientFlags: this._config.clientFlags,
|
|
maxPacketSize: this._config.maxPacketSize,
|
|
charsetNumber: this._config.charsetNumber,
|
|
user: this._config.user,
|
|
database: this._config.database,
|
|
protocol41: packet.protocol41,
|
|
scrambleBuff: packet.protocol41 ? Auth.token(this._config.password, packet.scrambleBuff()) : Auth.scramble323(packet.scrambleBuff(), this._config.password)
|
|
}));
|
|
};
|
|
Handshake.prototype["UseOldPasswordPacket"] = function() {
|
|
if (!this._config.insecureAuth) {
|
|
var err = new Error("MySQL server is requesting the old and insecure pre-4.1 auth mechanism. " + "Upgrade the user password or use the {insecureAuth: true} option.");
|
|
err.code = "HANDSHAKE_INSECURE_AUTH";
|
|
err.fatal = true;
|
|
this.end(err);
|
|
return;
|
|
}
|
|
this.emit("packet", new Packets.OldPasswordPacket({
|
|
scrambleBuff: Auth.scramble323(this._handshakeInitializationPacket.scrambleBuff(), this._config.password)
|
|
}));
|
|
};
|
|
Handshake.prototype["ErrorPacket"] = function(packet) {
|
|
var err = this._packetToError(packet, true);
|
|
err.fatal = true;
|
|
this.end(err);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Ping.js
|
|
var require_Ping = __commonJS((exports, module) => {
|
|
var Sequence = require_Sequence();
|
|
var Util = __require("util");
|
|
var Packets = require_packets();
|
|
module.exports = Ping;
|
|
Util.inherits(Ping, Sequence);
|
|
function Ping(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
Sequence.call(this, options, callback);
|
|
}
|
|
Ping.prototype.start = function() {
|
|
this.emit("packet", new Packets.ComPingPacket);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/ResultSet.js
|
|
var require_ResultSet = __commonJS((exports, module) => {
|
|
module.exports = ResultSet;
|
|
function ResultSet(resultSetHeaderPacket) {
|
|
this.resultSetHeaderPacket = resultSetHeaderPacket;
|
|
this.fieldPackets = [];
|
|
this.eofPackets = [];
|
|
this.rows = [];
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/constants/server_status.js
|
|
var require_server_status = __commonJS((exports) => {
|
|
exports.SERVER_STATUS_IN_TRANS = 1;
|
|
exports.SERVER_STATUS_AUTOCOMMIT = 2;
|
|
exports.SERVER_MORE_RESULTS_EXISTS = 8;
|
|
exports.SERVER_QUERY_NO_GOOD_INDEX_USED = 16;
|
|
exports.SERVER_QUERY_NO_INDEX_USED = 32;
|
|
exports.SERVER_STATUS_CURSOR_EXISTS = 64;
|
|
exports.SERVER_STATUS_LAST_ROW_SENT = 128;
|
|
exports.SERVER_STATUS_DB_DROPPED = 256;
|
|
exports.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512;
|
|
exports.SERVER_STATUS_METADATA_CHANGED = 1024;
|
|
exports.SERVER_QUERY_WAS_SLOW = 2048;
|
|
exports.SERVER_PS_OUT_PARAMS = 4096;
|
|
});
|
|
|
|
// node_modules/process-nextick-args/index.js
|
|
var require_process_nextick_args = __commonJS((exports, module) => {
|
|
if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
|
|
module.exports = { nextTick };
|
|
} else {
|
|
module.exports = process;
|
|
}
|
|
function nextTick(fn, arg1, arg2, arg3) {
|
|
if (typeof fn !== "function") {
|
|
throw new TypeError('"callback" argument must be a function');
|
|
}
|
|
var len = arguments.length;
|
|
var args, i;
|
|
switch (len) {
|
|
case 0:
|
|
case 1:
|
|
return process.nextTick(fn);
|
|
case 2:
|
|
return process.nextTick(function afterTickOne() {
|
|
fn.call(null, arg1);
|
|
});
|
|
case 3:
|
|
return process.nextTick(function afterTickTwo() {
|
|
fn.call(null, arg1, arg2);
|
|
});
|
|
case 4:
|
|
return process.nextTick(function afterTickThree() {
|
|
fn.call(null, arg1, arg2, arg3);
|
|
});
|
|
default:
|
|
args = new Array(len - 1);
|
|
i = 0;
|
|
while (i < args.length) {
|
|
args[i++] = arguments[i];
|
|
}
|
|
return process.nextTick(function afterTick() {
|
|
fn.apply(null, args);
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/isarray/index.js
|
|
var require_isarray = __commonJS((exports, module) => {
|
|
var toString = {}.toString;
|
|
module.exports = Array.isArray || function(arr) {
|
|
return toString.call(arr) == "[object Array]";
|
|
};
|
|
});
|
|
|
|
// node_modules/core-util-is/lib/util.js
|
|
var require_util = __commonJS((exports) => {
|
|
function isArray(arg) {
|
|
if (Array.isArray) {
|
|
return Array.isArray(arg);
|
|
}
|
|
return objectToString(arg) === "[object Array]";
|
|
}
|
|
exports.isArray = isArray;
|
|
function isBoolean(arg) {
|
|
return typeof arg === "boolean";
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
function isNumber(arg) {
|
|
return typeof arg === "number";
|
|
}
|
|
exports.isNumber = isNumber;
|
|
function isString(arg) {
|
|
return typeof arg === "string";
|
|
}
|
|
exports.isString = isString;
|
|
function isSymbol(arg) {
|
|
return typeof arg === "symbol";
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
function isUndefined(arg) {
|
|
return arg === undefined;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
function isRegExp(re) {
|
|
return objectToString(re) === "[object RegExp]";
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
function isObject(arg) {
|
|
return typeof arg === "object" && arg !== null;
|
|
}
|
|
exports.isObject = isObject;
|
|
function isDate(d) {
|
|
return objectToString(d) === "[object Date]";
|
|
}
|
|
exports.isDate = isDate;
|
|
function isError(e) {
|
|
return objectToString(e) === "[object Error]" || e instanceof Error;
|
|
}
|
|
exports.isError = isError;
|
|
function isFunction(arg) {
|
|
return typeof arg === "function";
|
|
}
|
|
exports.isFunction = isFunction;
|
|
function isPrimitive(arg) {
|
|
return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
exports.isBuffer = __require("buffer").Buffer.isBuffer;
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
});
|
|
|
|
// node_modules/inherits/inherits_browser.js
|
|
var require_inherits_browser = __commonJS((exports, module) => {
|
|
if (typeof Object.create === "function") {
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
}
|
|
};
|
|
} else {
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
var TempCtor = function() {
|
|
};
|
|
TempCtor.prototype = superCtor.prototype;
|
|
ctor.prototype = new TempCtor;
|
|
ctor.prototype.constructor = ctor;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/inherits/inherits.js
|
|
var require_inherits = __commonJS((exports, module) => {
|
|
try {
|
|
util = __require("util");
|
|
if (typeof util.inherits !== "function")
|
|
throw "";
|
|
module.exports = util.inherits;
|
|
} catch (e) {
|
|
module.exports = require_inherits_browser();
|
|
}
|
|
var util;
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/internal/streams/BufferList.js
|
|
var require_BufferList2 = __commonJS((exports, module) => {
|
|
function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var util = __require("util");
|
|
function copyBuffer(src, target, offset) {
|
|
src.copy(target, offset);
|
|
}
|
|
module.exports = function() {
|
|
function BufferList() {
|
|
_classCallCheck(this, BufferList);
|
|
this.head = null;
|
|
this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
BufferList.prototype.push = function push(v) {
|
|
var entry = { data: v, next: null };
|
|
if (this.length > 0)
|
|
this.tail.next = entry;
|
|
else
|
|
this.head = entry;
|
|
this.tail = entry;
|
|
++this.length;
|
|
};
|
|
BufferList.prototype.unshift = function unshift(v) {
|
|
var entry = { data: v, next: this.head };
|
|
if (this.length === 0)
|
|
this.tail = entry;
|
|
this.head = entry;
|
|
++this.length;
|
|
};
|
|
BufferList.prototype.shift = function shift() {
|
|
if (this.length === 0)
|
|
return;
|
|
var ret = this.head.data;
|
|
if (this.length === 1)
|
|
this.head = this.tail = null;
|
|
else
|
|
this.head = this.head.next;
|
|
--this.length;
|
|
return ret;
|
|
};
|
|
BufferList.prototype.clear = function clear() {
|
|
this.head = this.tail = null;
|
|
this.length = 0;
|
|
};
|
|
BufferList.prototype.join = function join(s) {
|
|
if (this.length === 0)
|
|
return "";
|
|
var p = this.head;
|
|
var ret = "" + p.data;
|
|
while (p = p.next) {
|
|
ret += s + p.data;
|
|
}
|
|
return ret;
|
|
};
|
|
BufferList.prototype.concat = function concat(n) {
|
|
if (this.length === 0)
|
|
return Buffer2.alloc(0);
|
|
if (this.length === 1)
|
|
return this.head.data;
|
|
var ret = Buffer2.allocUnsafe(n >>> 0);
|
|
var p = this.head;
|
|
var i = 0;
|
|
while (p) {
|
|
copyBuffer(p.data, ret, i);
|
|
i += p.data.length;
|
|
p = p.next;
|
|
}
|
|
return ret;
|
|
};
|
|
return BufferList;
|
|
}();
|
|
if (util && util.inspect && util.inspect.custom) {
|
|
module.exports.prototype[util.inspect.custom] = function() {
|
|
var obj = util.inspect({ length: this.length });
|
|
return this.constructor.name + " " + obj;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/internal/streams/destroy.js
|
|
var require_destroy = __commonJS((exports, module) => {
|
|
var pna = require_process_nextick_args();
|
|
function destroy(err, cb) {
|
|
var _this = this;
|
|
var readableDestroyed = this._readableState && this._readableState.destroyed;
|
|
var writableDestroyed = this._writableState && this._writableState.destroyed;
|
|
if (readableDestroyed || writableDestroyed) {
|
|
if (cb) {
|
|
cb(err);
|
|
} else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
|
|
pna.nextTick(emitErrorNT, this, err);
|
|
}
|
|
return this;
|
|
}
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = true;
|
|
}
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = true;
|
|
}
|
|
this._destroy(err || null, function(err2) {
|
|
if (!cb && err2) {
|
|
pna.nextTick(emitErrorNT, _this, err2);
|
|
if (_this._writableState) {
|
|
_this._writableState.errorEmitted = true;
|
|
}
|
|
} else if (cb) {
|
|
cb(err2);
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
function undestroy() {
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = false;
|
|
this._readableState.reading = false;
|
|
this._readableState.ended = false;
|
|
this._readableState.endEmitted = false;
|
|
}
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = false;
|
|
this._writableState.ended = false;
|
|
this._writableState.ending = false;
|
|
this._writableState.finished = false;
|
|
this._writableState.errorEmitted = false;
|
|
}
|
|
}
|
|
function emitErrorNT(self2, err) {
|
|
self2.emit("error", err);
|
|
}
|
|
module.exports = {
|
|
destroy,
|
|
undestroy
|
|
};
|
|
});
|
|
|
|
// node_modules/util-deprecate/node.js
|
|
var require_node = __commonJS((exports, module) => {
|
|
module.exports = __require("util").deprecate;
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/_stream_writable.js
|
|
var require__stream_writable = __commonJS((exports, module) => {
|
|
var pna = require_process_nextick_args();
|
|
module.exports = Writable;
|
|
function CorkedRequest(state) {
|
|
var _this = this;
|
|
this.next = null;
|
|
this.entry = null;
|
|
this.finish = function() {
|
|
onCorkedFinish(_this, state);
|
|
};
|
|
}
|
|
var asyncWrite = ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
|
|
var Duplex;
|
|
Writable.WritableState = WritableState;
|
|
var util = Object.create(require_util());
|
|
util.inherits = require_inherits();
|
|
var internalUtil = {
|
|
deprecate: require_node()
|
|
};
|
|
var Stream = __require("stream");
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var OurUint8Array = global.Uint8Array || function() {
|
|
};
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer2.from(chunk);
|
|
}
|
|
function _isUint8Array(obj) {
|
|
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
var destroyImpl = require_destroy();
|
|
util.inherits(Writable, Stream);
|
|
function nop() {
|
|
}
|
|
function WritableState(options, stream) {
|
|
Duplex = Duplex || require__stream_duplex();
|
|
options = options || {};
|
|
var isDuplex = stream instanceof Duplex;
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex)
|
|
this.objectMode = this.objectMode || !!options.writableObjectMode;
|
|
var hwm = options.highWaterMark;
|
|
var writableHwm = options.writableHighWaterMark;
|
|
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
|
|
if (hwm || hwm === 0)
|
|
this.highWaterMark = hwm;
|
|
else if (isDuplex && (writableHwm || writableHwm === 0))
|
|
this.highWaterMark = writableHwm;
|
|
else
|
|
this.highWaterMark = defaultHwm;
|
|
this.highWaterMark = Math.floor(this.highWaterMark);
|
|
this.finalCalled = false;
|
|
this.needDrain = false;
|
|
this.ending = false;
|
|
this.ended = false;
|
|
this.finished = false;
|
|
this.destroyed = false;
|
|
var noDecode = options.decodeStrings === false;
|
|
this.decodeStrings = !noDecode;
|
|
this.defaultEncoding = options.defaultEncoding || "utf8";
|
|
this.length = 0;
|
|
this.writing = false;
|
|
this.corked = 0;
|
|
this.sync = true;
|
|
this.bufferProcessing = false;
|
|
this.onwrite = function(er) {
|
|
onwrite(stream, er);
|
|
};
|
|
this.writecb = null;
|
|
this.writelen = 0;
|
|
this.bufferedRequest = null;
|
|
this.lastBufferedRequest = null;
|
|
this.pendingcb = 0;
|
|
this.prefinished = false;
|
|
this.errorEmitted = false;
|
|
this.bufferedRequestCount = 0;
|
|
this.corkedRequestsFree = new CorkedRequest(this);
|
|
}
|
|
WritableState.prototype.getBuffer = function getBuffer() {
|
|
var current = this.bufferedRequest;
|
|
var out = [];
|
|
while (current) {
|
|
out.push(current);
|
|
current = current.next;
|
|
}
|
|
return out;
|
|
};
|
|
(function() {
|
|
try {
|
|
Object.defineProperty(WritableState.prototype, "buffer", {
|
|
get: internalUtil.deprecate(function() {
|
|
return this.getBuffer();
|
|
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer " + "instead.", "DEP0003")
|
|
});
|
|
} catch (_) {
|
|
}
|
|
})();
|
|
var realHasInstance;
|
|
if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
|
|
realHasInstance = Function.prototype[Symbol.hasInstance];
|
|
Object.defineProperty(Writable, Symbol.hasInstance, {
|
|
value: function(object) {
|
|
if (realHasInstance.call(this, object))
|
|
return true;
|
|
if (this !== Writable)
|
|
return false;
|
|
return object && object._writableState instanceof WritableState;
|
|
}
|
|
});
|
|
} else {
|
|
realHasInstance = function(object) {
|
|
return object instanceof this;
|
|
};
|
|
}
|
|
function Writable(options) {
|
|
Duplex = Duplex || require__stream_duplex();
|
|
if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
|
|
return new Writable(options);
|
|
}
|
|
this._writableState = new WritableState(options, this);
|
|
this.writable = true;
|
|
if (options) {
|
|
if (typeof options.write === "function")
|
|
this._write = options.write;
|
|
if (typeof options.writev === "function")
|
|
this._writev = options.writev;
|
|
if (typeof options.destroy === "function")
|
|
this._destroy = options.destroy;
|
|
if (typeof options.final === "function")
|
|
this._final = options.final;
|
|
}
|
|
Stream.call(this);
|
|
}
|
|
Writable.prototype.pipe = function() {
|
|
this.emit("error", new Error("Cannot pipe, not readable"));
|
|
};
|
|
function writeAfterEnd(stream, cb) {
|
|
var er = new Error("write after end");
|
|
stream.emit("error", er);
|
|
pna.nextTick(cb, er);
|
|
}
|
|
function validChunk(stream, state, chunk, cb) {
|
|
var valid = true;
|
|
var er = false;
|
|
if (chunk === null) {
|
|
er = new TypeError("May not write null values to stream");
|
|
} else if (typeof chunk !== "string" && chunk !== undefined && !state.objectMode) {
|
|
er = new TypeError("Invalid non-string/buffer chunk");
|
|
}
|
|
if (er) {
|
|
stream.emit("error", er);
|
|
pna.nextTick(cb, er);
|
|
valid = false;
|
|
}
|
|
return valid;
|
|
}
|
|
Writable.prototype.write = function(chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
var ret = false;
|
|
var isBuf = !state.objectMode && _isUint8Array(chunk);
|
|
if (isBuf && !Buffer2.isBuffer(chunk)) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (isBuf)
|
|
encoding = "buffer";
|
|
else if (!encoding)
|
|
encoding = state.defaultEncoding;
|
|
if (typeof cb !== "function")
|
|
cb = nop;
|
|
if (state.ended)
|
|
writeAfterEnd(this, cb);
|
|
else if (isBuf || validChunk(this, state, chunk, cb)) {
|
|
state.pendingcb++;
|
|
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
|
|
}
|
|
return ret;
|
|
};
|
|
Writable.prototype.cork = function() {
|
|
var state = this._writableState;
|
|
state.corked++;
|
|
};
|
|
Writable.prototype.uncork = function() {
|
|
var state = this._writableState;
|
|
if (state.corked) {
|
|
state.corked--;
|
|
if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest)
|
|
clearBuffer(this, state);
|
|
}
|
|
};
|
|
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
|
|
if (typeof encoding === "string")
|
|
encoding = encoding.toLowerCase();
|
|
if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
this._writableState.defaultEncoding = encoding;
|
|
return this;
|
|
};
|
|
function decodeChunk(state, chunk, encoding) {
|
|
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
|
|
chunk = Buffer2.from(chunk, encoding);
|
|
}
|
|
return chunk;
|
|
}
|
|
Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
});
|
|
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
|
|
if (!isBuf) {
|
|
var newChunk = decodeChunk(state, chunk, encoding);
|
|
if (chunk !== newChunk) {
|
|
isBuf = true;
|
|
encoding = "buffer";
|
|
chunk = newChunk;
|
|
}
|
|
}
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
state.length += len;
|
|
var ret = state.length < state.highWaterMark;
|
|
if (!ret)
|
|
state.needDrain = true;
|
|
if (state.writing || state.corked) {
|
|
var last = state.lastBufferedRequest;
|
|
state.lastBufferedRequest = {
|
|
chunk,
|
|
encoding,
|
|
isBuf,
|
|
callback: cb,
|
|
next: null
|
|
};
|
|
if (last) {
|
|
last.next = state.lastBufferedRequest;
|
|
} else {
|
|
state.bufferedRequest = state.lastBufferedRequest;
|
|
}
|
|
state.bufferedRequestCount += 1;
|
|
} else {
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
}
|
|
return ret;
|
|
}
|
|
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
|
|
state.writelen = len;
|
|
state.writecb = cb;
|
|
state.writing = true;
|
|
state.sync = true;
|
|
if (writev)
|
|
stream._writev(chunk, state.onwrite);
|
|
else
|
|
stream._write(chunk, encoding, state.onwrite);
|
|
state.sync = false;
|
|
}
|
|
function onwriteError(stream, state, sync, er, cb) {
|
|
--state.pendingcb;
|
|
if (sync) {
|
|
pna.nextTick(cb, er);
|
|
pna.nextTick(finishMaybe, stream, state);
|
|
stream._writableState.errorEmitted = true;
|
|
stream.emit("error", er);
|
|
} else {
|
|
cb(er);
|
|
stream._writableState.errorEmitted = true;
|
|
stream.emit("error", er);
|
|
finishMaybe(stream, state);
|
|
}
|
|
}
|
|
function onwriteStateUpdate(state) {
|
|
state.writing = false;
|
|
state.writecb = null;
|
|
state.length -= state.writelen;
|
|
state.writelen = 0;
|
|
}
|
|
function onwrite(stream, er) {
|
|
var state = stream._writableState;
|
|
var sync = state.sync;
|
|
var cb = state.writecb;
|
|
onwriteStateUpdate(state);
|
|
if (er)
|
|
onwriteError(stream, state, sync, er, cb);
|
|
else {
|
|
var finished = needFinish(state);
|
|
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
|
|
clearBuffer(stream, state);
|
|
}
|
|
if (sync) {
|
|
asyncWrite(afterWrite, stream, state, finished, cb);
|
|
} else {
|
|
afterWrite(stream, state, finished, cb);
|
|
}
|
|
}
|
|
}
|
|
function afterWrite(stream, state, finished, cb) {
|
|
if (!finished)
|
|
onwriteDrain(stream, state);
|
|
state.pendingcb--;
|
|
cb();
|
|
finishMaybe(stream, state);
|
|
}
|
|
function onwriteDrain(stream, state) {
|
|
if (state.length === 0 && state.needDrain) {
|
|
state.needDrain = false;
|
|
stream.emit("drain");
|
|
}
|
|
}
|
|
function clearBuffer(stream, state) {
|
|
state.bufferProcessing = true;
|
|
var entry = state.bufferedRequest;
|
|
if (stream._writev && entry && entry.next) {
|
|
var l = state.bufferedRequestCount;
|
|
var buffer = new Array(l);
|
|
var holder = state.corkedRequestsFree;
|
|
holder.entry = entry;
|
|
var count = 0;
|
|
var allBuffers = true;
|
|
while (entry) {
|
|
buffer[count] = entry;
|
|
if (!entry.isBuf)
|
|
allBuffers = false;
|
|
entry = entry.next;
|
|
count += 1;
|
|
}
|
|
buffer.allBuffers = allBuffers;
|
|
doWrite(stream, state, true, state.length, buffer, "", holder.finish);
|
|
state.pendingcb++;
|
|
state.lastBufferedRequest = null;
|
|
if (holder.next) {
|
|
state.corkedRequestsFree = holder.next;
|
|
holder.next = null;
|
|
} else {
|
|
state.corkedRequestsFree = new CorkedRequest(state);
|
|
}
|
|
state.bufferedRequestCount = 0;
|
|
} else {
|
|
while (entry) {
|
|
var chunk = entry.chunk;
|
|
var encoding = entry.encoding;
|
|
var cb = entry.callback;
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
entry = entry.next;
|
|
state.bufferedRequestCount--;
|
|
if (state.writing) {
|
|
break;
|
|
}
|
|
}
|
|
if (entry === null)
|
|
state.lastBufferedRequest = null;
|
|
}
|
|
state.bufferedRequest = entry;
|
|
state.bufferProcessing = false;
|
|
}
|
|
Writable.prototype._write = function(chunk, encoding, cb) {
|
|
cb(new Error("_write() is not implemented"));
|
|
};
|
|
Writable.prototype._writev = null;
|
|
Writable.prototype.end = function(chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
if (typeof chunk === "function") {
|
|
cb = chunk;
|
|
chunk = null;
|
|
encoding = null;
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (chunk !== null && chunk !== undefined)
|
|
this.write(chunk, encoding);
|
|
if (state.corked) {
|
|
state.corked = 1;
|
|
this.uncork();
|
|
}
|
|
if (!state.ending && !state.finished)
|
|
endWritable(this, state, cb);
|
|
};
|
|
function needFinish(state) {
|
|
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
|
|
}
|
|
function callFinal(stream, state) {
|
|
stream._final(function(err) {
|
|
state.pendingcb--;
|
|
if (err) {
|
|
stream.emit("error", err);
|
|
}
|
|
state.prefinished = true;
|
|
stream.emit("prefinish");
|
|
finishMaybe(stream, state);
|
|
});
|
|
}
|
|
function prefinish(stream, state) {
|
|
if (!state.prefinished && !state.finalCalled) {
|
|
if (typeof stream._final === "function") {
|
|
state.pendingcb++;
|
|
state.finalCalled = true;
|
|
pna.nextTick(callFinal, stream, state);
|
|
} else {
|
|
state.prefinished = true;
|
|
stream.emit("prefinish");
|
|
}
|
|
}
|
|
}
|
|
function finishMaybe(stream, state) {
|
|
var need = needFinish(state);
|
|
if (need) {
|
|
prefinish(stream, state);
|
|
if (state.pendingcb === 0) {
|
|
state.finished = true;
|
|
stream.emit("finish");
|
|
}
|
|
}
|
|
return need;
|
|
}
|
|
function endWritable(stream, state, cb) {
|
|
state.ending = true;
|
|
finishMaybe(stream, state);
|
|
if (cb) {
|
|
if (state.finished)
|
|
pna.nextTick(cb);
|
|
else
|
|
stream.once("finish", cb);
|
|
}
|
|
state.ended = true;
|
|
stream.writable = false;
|
|
}
|
|
function onCorkedFinish(corkReq, state, err) {
|
|
var entry = corkReq.entry;
|
|
corkReq.entry = null;
|
|
while (entry) {
|
|
var cb = entry.callback;
|
|
state.pendingcb--;
|
|
cb(err);
|
|
entry = entry.next;
|
|
}
|
|
if (state.corkedRequestsFree) {
|
|
state.corkedRequestsFree.next = corkReq;
|
|
} else {
|
|
state.corkedRequestsFree = corkReq;
|
|
}
|
|
}
|
|
Object.defineProperty(Writable.prototype, "destroyed", {
|
|
get: function() {
|
|
if (this._writableState === undefined) {
|
|
return false;
|
|
}
|
|
return this._writableState.destroyed;
|
|
},
|
|
set: function(value) {
|
|
if (!this._writableState) {
|
|
return;
|
|
}
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
Writable.prototype.destroy = destroyImpl.destroy;
|
|
Writable.prototype._undestroy = destroyImpl.undestroy;
|
|
Writable.prototype._destroy = function(err, cb) {
|
|
this.end();
|
|
cb(err);
|
|
};
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/_stream_duplex.js
|
|
var require__stream_duplex = __commonJS((exports, module) => {
|
|
var pna = require_process_nextick_args();
|
|
var objectKeys = Object.keys || function(obj) {
|
|
var keys2 = [];
|
|
for (var key in obj) {
|
|
keys2.push(key);
|
|
}
|
|
return keys2;
|
|
};
|
|
module.exports = Duplex;
|
|
var util = Object.create(require_util());
|
|
util.inherits = require_inherits();
|
|
var Readable = require__stream_readable();
|
|
var Writable = require__stream_writable();
|
|
util.inherits(Duplex, Readable);
|
|
{
|
|
keys = objectKeys(Writable.prototype);
|
|
for (v = 0;v < keys.length; v++) {
|
|
method = keys[v];
|
|
if (!Duplex.prototype[method])
|
|
Duplex.prototype[method] = Writable.prototype[method];
|
|
}
|
|
}
|
|
var keys;
|
|
var method;
|
|
var v;
|
|
function Duplex(options) {
|
|
if (!(this instanceof Duplex))
|
|
return new Duplex(options);
|
|
Readable.call(this, options);
|
|
Writable.call(this, options);
|
|
if (options && options.readable === false)
|
|
this.readable = false;
|
|
if (options && options.writable === false)
|
|
this.writable = false;
|
|
this.allowHalfOpen = true;
|
|
if (options && options.allowHalfOpen === false)
|
|
this.allowHalfOpen = false;
|
|
this.once("end", onend);
|
|
}
|
|
Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
});
|
|
function onend() {
|
|
if (this.allowHalfOpen || this._writableState.ended)
|
|
return;
|
|
pna.nextTick(onEndNT, this);
|
|
}
|
|
function onEndNT(self2) {
|
|
self2.end();
|
|
}
|
|
Object.defineProperty(Duplex.prototype, "destroyed", {
|
|
get: function() {
|
|
if (this._readableState === undefined || this._writableState === undefined) {
|
|
return false;
|
|
}
|
|
return this._readableState.destroyed && this._writableState.destroyed;
|
|
},
|
|
set: function(value) {
|
|
if (this._readableState === undefined || this._writableState === undefined) {
|
|
return;
|
|
}
|
|
this._readableState.destroyed = value;
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
Duplex.prototype._destroy = function(err, cb) {
|
|
this.push(null);
|
|
this.end();
|
|
pna.nextTick(cb, err);
|
|
};
|
|
});
|
|
|
|
// node_modules/string_decoder/lib/string_decoder.js
|
|
var require_string_decoder = __commonJS((exports) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var isEncoding = Buffer2.isEncoding || function(encoding) {
|
|
encoding = "" + encoding;
|
|
switch (encoding && encoding.toLowerCase()) {
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
case "raw":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
function _normalizeEncoding(enc) {
|
|
if (!enc)
|
|
return "utf8";
|
|
var retried;
|
|
while (true) {
|
|
switch (enc) {
|
|
case "utf8":
|
|
case "utf-8":
|
|
return "utf8";
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return "utf16le";
|
|
case "latin1":
|
|
case "binary":
|
|
return "latin1";
|
|
case "base64":
|
|
case "ascii":
|
|
case "hex":
|
|
return enc;
|
|
default:
|
|
if (retried)
|
|
return;
|
|
enc = ("" + enc).toLowerCase();
|
|
retried = true;
|
|
}
|
|
}
|
|
}
|
|
function normalizeEncoding(enc) {
|
|
var nenc = _normalizeEncoding(enc);
|
|
if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc)))
|
|
throw new Error("Unknown encoding: " + enc);
|
|
return nenc || enc;
|
|
}
|
|
exports.StringDecoder = StringDecoder;
|
|
function StringDecoder(encoding) {
|
|
this.encoding = normalizeEncoding(encoding);
|
|
var nb;
|
|
switch (this.encoding) {
|
|
case "utf16le":
|
|
this.text = utf16Text;
|
|
this.end = utf16End;
|
|
nb = 4;
|
|
break;
|
|
case "utf8":
|
|
this.fillLast = utf8FillLast;
|
|
nb = 4;
|
|
break;
|
|
case "base64":
|
|
this.text = base64Text;
|
|
this.end = base64End;
|
|
nb = 3;
|
|
break;
|
|
default:
|
|
this.write = simpleWrite;
|
|
this.end = simpleEnd;
|
|
return;
|
|
}
|
|
this.lastNeed = 0;
|
|
this.lastTotal = 0;
|
|
this.lastChar = Buffer2.allocUnsafe(nb);
|
|
}
|
|
StringDecoder.prototype.write = function(buf) {
|
|
if (buf.length === 0)
|
|
return "";
|
|
var r;
|
|
var i;
|
|
if (this.lastNeed) {
|
|
r = this.fillLast(buf);
|
|
if (r === undefined)
|
|
return "";
|
|
i = this.lastNeed;
|
|
this.lastNeed = 0;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
if (i < buf.length)
|
|
return r ? r + this.text(buf, i) : this.text(buf, i);
|
|
return r || "";
|
|
};
|
|
StringDecoder.prototype.end = utf8End;
|
|
StringDecoder.prototype.text = utf8Text;
|
|
StringDecoder.prototype.fillLast = function(buf) {
|
|
if (this.lastNeed <= buf.length) {
|
|
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
|
|
this.lastNeed -= buf.length;
|
|
};
|
|
function utf8CheckByte(byte) {
|
|
if (byte <= 127)
|
|
return 0;
|
|
else if (byte >> 5 === 6)
|
|
return 2;
|
|
else if (byte >> 4 === 14)
|
|
return 3;
|
|
else if (byte >> 3 === 30)
|
|
return 4;
|
|
return byte >> 6 === 2 ? -1 : -2;
|
|
}
|
|
function utf8CheckIncomplete(self2, buf, i) {
|
|
var j = buf.length - 1;
|
|
if (j < i)
|
|
return 0;
|
|
var nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0)
|
|
self2.lastNeed = nb - 1;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2)
|
|
return 0;
|
|
nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0)
|
|
self2.lastNeed = nb - 2;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2)
|
|
return 0;
|
|
nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0) {
|
|
if (nb === 2)
|
|
nb = 0;
|
|
else
|
|
self2.lastNeed = nb - 3;
|
|
}
|
|
return nb;
|
|
}
|
|
return 0;
|
|
}
|
|
function utf8CheckExtraBytes(self2, buf, p) {
|
|
if ((buf[0] & 192) !== 128) {
|
|
self2.lastNeed = 0;
|
|
return "\uFFFD";
|
|
}
|
|
if (self2.lastNeed > 1 && buf.length > 1) {
|
|
if ((buf[1] & 192) !== 128) {
|
|
self2.lastNeed = 1;
|
|
return "\uFFFD";
|
|
}
|
|
if (self2.lastNeed > 2 && buf.length > 2) {
|
|
if ((buf[2] & 192) !== 128) {
|
|
self2.lastNeed = 2;
|
|
return "\uFFFD";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function utf8FillLast(buf) {
|
|
var p = this.lastTotal - this.lastNeed;
|
|
var r = utf8CheckExtraBytes(this, buf, p);
|
|
if (r !== undefined)
|
|
return r;
|
|
if (this.lastNeed <= buf.length) {
|
|
buf.copy(this.lastChar, p, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf.copy(this.lastChar, p, 0, buf.length);
|
|
this.lastNeed -= buf.length;
|
|
}
|
|
function utf8Text(buf, i) {
|
|
var total = utf8CheckIncomplete(this, buf, i);
|
|
if (!this.lastNeed)
|
|
return buf.toString("utf8", i);
|
|
this.lastTotal = total;
|
|
var end = buf.length - (total - this.lastNeed);
|
|
buf.copy(this.lastChar, 0, end);
|
|
return buf.toString("utf8", i, end);
|
|
}
|
|
function utf8End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : "";
|
|
if (this.lastNeed)
|
|
return r + "\uFFFD";
|
|
return r;
|
|
}
|
|
function utf16Text(buf, i) {
|
|
if ((buf.length - i) % 2 === 0) {
|
|
var r = buf.toString("utf16le", i);
|
|
if (r) {
|
|
var c = r.charCodeAt(r.length - 1);
|
|
if (c >= 55296 && c <= 56319) {
|
|
this.lastNeed = 2;
|
|
this.lastTotal = 4;
|
|
this.lastChar[0] = buf[buf.length - 2];
|
|
this.lastChar[1] = buf[buf.length - 1];
|
|
return r.slice(0, -1);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
this.lastNeed = 1;
|
|
this.lastTotal = 2;
|
|
this.lastChar[0] = buf[buf.length - 1];
|
|
return buf.toString("utf16le", i, buf.length - 1);
|
|
}
|
|
function utf16End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : "";
|
|
if (this.lastNeed) {
|
|
var end = this.lastTotal - this.lastNeed;
|
|
return r + this.lastChar.toString("utf16le", 0, end);
|
|
}
|
|
return r;
|
|
}
|
|
function base64Text(buf, i) {
|
|
var n = (buf.length - i) % 3;
|
|
if (n === 0)
|
|
return buf.toString("base64", i);
|
|
this.lastNeed = 3 - n;
|
|
this.lastTotal = 3;
|
|
if (n === 1) {
|
|
this.lastChar[0] = buf[buf.length - 1];
|
|
} else {
|
|
this.lastChar[0] = buf[buf.length - 2];
|
|
this.lastChar[1] = buf[buf.length - 1];
|
|
}
|
|
return buf.toString("base64", i, buf.length - n);
|
|
}
|
|
function base64End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : "";
|
|
if (this.lastNeed)
|
|
return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
|
|
return r;
|
|
}
|
|
function simpleWrite(buf) {
|
|
return buf.toString(this.encoding);
|
|
}
|
|
function simpleEnd(buf) {
|
|
return buf && buf.length ? this.write(buf) : "";
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/_stream_readable.js
|
|
var require__stream_readable = __commonJS((exports, module) => {
|
|
var pna = require_process_nextick_args();
|
|
module.exports = Readable;
|
|
var isArray = require_isarray();
|
|
var Duplex;
|
|
Readable.ReadableState = ReadableState;
|
|
var EE = __require("events").EventEmitter;
|
|
var EElistenerCount = function(emitter, type) {
|
|
return emitter.listeners(type).length;
|
|
};
|
|
var Stream = __require("stream");
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var OurUint8Array = global.Uint8Array || function() {
|
|
};
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer2.from(chunk);
|
|
}
|
|
function _isUint8Array(obj) {
|
|
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
var util = Object.create(require_util());
|
|
util.inherits = require_inherits();
|
|
var debugUtil = __require("util");
|
|
var debug = undefined;
|
|
if (debugUtil && debugUtil.debuglog) {
|
|
debug = debugUtil.debuglog("stream");
|
|
} else {
|
|
debug = function() {
|
|
};
|
|
}
|
|
var BufferList = require_BufferList2();
|
|
var destroyImpl = require_destroy();
|
|
var StringDecoder;
|
|
util.inherits(Readable, Stream);
|
|
var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
|
|
function prependListener(emitter, event, fn) {
|
|
if (typeof emitter.prependListener === "function")
|
|
return emitter.prependListener(event, fn);
|
|
if (!emitter._events || !emitter._events[event])
|
|
emitter.on(event, fn);
|
|
else if (isArray(emitter._events[event]))
|
|
emitter._events[event].unshift(fn);
|
|
else
|
|
emitter._events[event] = [fn, emitter._events[event]];
|
|
}
|
|
function ReadableState(options, stream) {
|
|
Duplex = Duplex || require__stream_duplex();
|
|
options = options || {};
|
|
var isDuplex = stream instanceof Duplex;
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex)
|
|
this.objectMode = this.objectMode || !!options.readableObjectMode;
|
|
var hwm = options.highWaterMark;
|
|
var readableHwm = options.readableHighWaterMark;
|
|
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
|
|
if (hwm || hwm === 0)
|
|
this.highWaterMark = hwm;
|
|
else if (isDuplex && (readableHwm || readableHwm === 0))
|
|
this.highWaterMark = readableHwm;
|
|
else
|
|
this.highWaterMark = defaultHwm;
|
|
this.highWaterMark = Math.floor(this.highWaterMark);
|
|
this.buffer = new BufferList;
|
|
this.length = 0;
|
|
this.pipes = null;
|
|
this.pipesCount = 0;
|
|
this.flowing = null;
|
|
this.ended = false;
|
|
this.endEmitted = false;
|
|
this.reading = false;
|
|
this.sync = true;
|
|
this.needReadable = false;
|
|
this.emittedReadable = false;
|
|
this.readableListening = false;
|
|
this.resumeScheduled = false;
|
|
this.destroyed = false;
|
|
this.defaultEncoding = options.defaultEncoding || "utf8";
|
|
this.awaitDrain = 0;
|
|
this.readingMore = false;
|
|
this.decoder = null;
|
|
this.encoding = null;
|
|
if (options.encoding) {
|
|
if (!StringDecoder)
|
|
StringDecoder = require_string_decoder().StringDecoder;
|
|
this.decoder = new StringDecoder(options.encoding);
|
|
this.encoding = options.encoding;
|
|
}
|
|
}
|
|
function Readable(options) {
|
|
Duplex = Duplex || require__stream_duplex();
|
|
if (!(this instanceof Readable))
|
|
return new Readable(options);
|
|
this._readableState = new ReadableState(options, this);
|
|
this.readable = true;
|
|
if (options) {
|
|
if (typeof options.read === "function")
|
|
this._read = options.read;
|
|
if (typeof options.destroy === "function")
|
|
this._destroy = options.destroy;
|
|
}
|
|
Stream.call(this);
|
|
}
|
|
Object.defineProperty(Readable.prototype, "destroyed", {
|
|
get: function() {
|
|
if (this._readableState === undefined) {
|
|
return false;
|
|
}
|
|
return this._readableState.destroyed;
|
|
},
|
|
set: function(value) {
|
|
if (!this._readableState) {
|
|
return;
|
|
}
|
|
this._readableState.destroyed = value;
|
|
}
|
|
});
|
|
Readable.prototype.destroy = destroyImpl.destroy;
|
|
Readable.prototype._undestroy = destroyImpl.undestroy;
|
|
Readable.prototype._destroy = function(err, cb) {
|
|
this.push(null);
|
|
cb(err);
|
|
};
|
|
Readable.prototype.push = function(chunk, encoding) {
|
|
var state = this._readableState;
|
|
var skipChunkCheck;
|
|
if (!state.objectMode) {
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || state.defaultEncoding;
|
|
if (encoding !== state.encoding) {
|
|
chunk = Buffer2.from(chunk, encoding);
|
|
encoding = "";
|
|
}
|
|
skipChunkCheck = true;
|
|
}
|
|
} else {
|
|
skipChunkCheck = true;
|
|
}
|
|
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
|
|
};
|
|
Readable.prototype.unshift = function(chunk) {
|
|
return readableAddChunk(this, chunk, null, true, false);
|
|
};
|
|
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
|
|
var state = stream._readableState;
|
|
if (chunk === null) {
|
|
state.reading = false;
|
|
onEofChunk(stream, state);
|
|
} else {
|
|
var er;
|
|
if (!skipChunkCheck)
|
|
er = chunkInvalid(state, chunk);
|
|
if (er) {
|
|
stream.emit("error", er);
|
|
} else if (state.objectMode || chunk && chunk.length > 0) {
|
|
if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
if (addToFront) {
|
|
if (state.endEmitted)
|
|
stream.emit("error", new Error("stream.unshift() after end event"));
|
|
else
|
|
addChunk(stream, state, chunk, true);
|
|
} else if (state.ended) {
|
|
stream.emit("error", new Error("stream.push() after EOF"));
|
|
} else {
|
|
state.reading = false;
|
|
if (state.decoder && !encoding) {
|
|
chunk = state.decoder.write(chunk);
|
|
if (state.objectMode || chunk.length !== 0)
|
|
addChunk(stream, state, chunk, false);
|
|
else
|
|
maybeReadMore(stream, state);
|
|
} else {
|
|
addChunk(stream, state, chunk, false);
|
|
}
|
|
}
|
|
} else if (!addToFront) {
|
|
state.reading = false;
|
|
}
|
|
}
|
|
return needMoreData(state);
|
|
}
|
|
function addChunk(stream, state, chunk, addToFront) {
|
|
if (state.flowing && state.length === 0 && !state.sync) {
|
|
stream.emit("data", chunk);
|
|
stream.read(0);
|
|
} else {
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
if (addToFront)
|
|
state.buffer.unshift(chunk);
|
|
else
|
|
state.buffer.push(chunk);
|
|
if (state.needReadable)
|
|
emitReadable(stream);
|
|
}
|
|
maybeReadMore(stream, state);
|
|
}
|
|
function chunkInvalid(state, chunk) {
|
|
var er;
|
|
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== undefined && !state.objectMode) {
|
|
er = new TypeError("Invalid non-string/buffer chunk");
|
|
}
|
|
return er;
|
|
}
|
|
function needMoreData(state) {
|
|
return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
|
|
}
|
|
Readable.prototype.isPaused = function() {
|
|
return this._readableState.flowing === false;
|
|
};
|
|
Readable.prototype.setEncoding = function(enc) {
|
|
if (!StringDecoder)
|
|
StringDecoder = require_string_decoder().StringDecoder;
|
|
this._readableState.decoder = new StringDecoder(enc);
|
|
this._readableState.encoding = enc;
|
|
return this;
|
|
};
|
|
var MAX_HWM = 8388608;
|
|
function computeNewHighWaterMark(n) {
|
|
if (n >= MAX_HWM) {
|
|
n = MAX_HWM;
|
|
} else {
|
|
n--;
|
|
n |= n >>> 1;
|
|
n |= n >>> 2;
|
|
n |= n >>> 4;
|
|
n |= n >>> 8;
|
|
n |= n >>> 16;
|
|
n++;
|
|
}
|
|
return n;
|
|
}
|
|
function howMuchToRead(n, state) {
|
|
if (n <= 0 || state.length === 0 && state.ended)
|
|
return 0;
|
|
if (state.objectMode)
|
|
return 1;
|
|
if (n !== n) {
|
|
if (state.flowing && state.length)
|
|
return state.buffer.head.data.length;
|
|
else
|
|
return state.length;
|
|
}
|
|
if (n > state.highWaterMark)
|
|
state.highWaterMark = computeNewHighWaterMark(n);
|
|
if (n <= state.length)
|
|
return n;
|
|
if (!state.ended) {
|
|
state.needReadable = true;
|
|
return 0;
|
|
}
|
|
return state.length;
|
|
}
|
|
Readable.prototype.read = function(n) {
|
|
debug("read", n);
|
|
n = parseInt(n, 10);
|
|
var state = this._readableState;
|
|
var nOrig = n;
|
|
if (n !== 0)
|
|
state.emittedReadable = false;
|
|
if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
|
|
debug("read: emitReadable", state.length, state.ended);
|
|
if (state.length === 0 && state.ended)
|
|
endReadable(this);
|
|
else
|
|
emitReadable(this);
|
|
return null;
|
|
}
|
|
n = howMuchToRead(n, state);
|
|
if (n === 0 && state.ended) {
|
|
if (state.length === 0)
|
|
endReadable(this);
|
|
return null;
|
|
}
|
|
var doRead = state.needReadable;
|
|
debug("need readable", doRead);
|
|
if (state.length === 0 || state.length - n < state.highWaterMark) {
|
|
doRead = true;
|
|
debug("length less than watermark", doRead);
|
|
}
|
|
if (state.ended || state.reading) {
|
|
doRead = false;
|
|
debug("reading or ended", doRead);
|
|
} else if (doRead) {
|
|
debug("do read");
|
|
state.reading = true;
|
|
state.sync = true;
|
|
if (state.length === 0)
|
|
state.needReadable = true;
|
|
this._read(state.highWaterMark);
|
|
state.sync = false;
|
|
if (!state.reading)
|
|
n = howMuchToRead(nOrig, state);
|
|
}
|
|
var ret;
|
|
if (n > 0)
|
|
ret = fromList(n, state);
|
|
else
|
|
ret = null;
|
|
if (ret === null) {
|
|
state.needReadable = true;
|
|
n = 0;
|
|
} else {
|
|
state.length -= n;
|
|
}
|
|
if (state.length === 0) {
|
|
if (!state.ended)
|
|
state.needReadable = true;
|
|
if (nOrig !== n && state.ended)
|
|
endReadable(this);
|
|
}
|
|
if (ret !== null)
|
|
this.emit("data", ret);
|
|
return ret;
|
|
};
|
|
function onEofChunk(stream, state) {
|
|
if (state.ended)
|
|
return;
|
|
if (state.decoder) {
|
|
var chunk = state.decoder.end();
|
|
if (chunk && chunk.length) {
|
|
state.buffer.push(chunk);
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
}
|
|
}
|
|
state.ended = true;
|
|
emitReadable(stream);
|
|
}
|
|
function emitReadable(stream) {
|
|
var state = stream._readableState;
|
|
state.needReadable = false;
|
|
if (!state.emittedReadable) {
|
|
debug("emitReadable", state.flowing);
|
|
state.emittedReadable = true;
|
|
if (state.sync)
|
|
pna.nextTick(emitReadable_, stream);
|
|
else
|
|
emitReadable_(stream);
|
|
}
|
|
}
|
|
function emitReadable_(stream) {
|
|
debug("emit readable");
|
|
stream.emit("readable");
|
|
flow(stream);
|
|
}
|
|
function maybeReadMore(stream, state) {
|
|
if (!state.readingMore) {
|
|
state.readingMore = true;
|
|
pna.nextTick(maybeReadMore_, stream, state);
|
|
}
|
|
}
|
|
function maybeReadMore_(stream, state) {
|
|
var len = state.length;
|
|
while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
|
|
debug("maybeReadMore read 0");
|
|
stream.read(0);
|
|
if (len === state.length)
|
|
break;
|
|
else
|
|
len = state.length;
|
|
}
|
|
state.readingMore = false;
|
|
}
|
|
Readable.prototype._read = function(n) {
|
|
this.emit("error", new Error("_read() is not implemented"));
|
|
};
|
|
Readable.prototype.pipe = function(dest, pipeOpts) {
|
|
var src = this;
|
|
var state = this._readableState;
|
|
switch (state.pipesCount) {
|
|
case 0:
|
|
state.pipes = dest;
|
|
break;
|
|
case 1:
|
|
state.pipes = [state.pipes, dest];
|
|
break;
|
|
default:
|
|
state.pipes.push(dest);
|
|
break;
|
|
}
|
|
state.pipesCount += 1;
|
|
debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
|
|
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
|
|
var endFn = doEnd ? onend : unpipe;
|
|
if (state.endEmitted)
|
|
pna.nextTick(endFn);
|
|
else
|
|
src.once("end", endFn);
|
|
dest.on("unpipe", onunpipe);
|
|
function onunpipe(readable, unpipeInfo) {
|
|
debug("onunpipe");
|
|
if (readable === src) {
|
|
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
|
|
unpipeInfo.hasUnpiped = true;
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
function onend() {
|
|
debug("onend");
|
|
dest.end();
|
|
}
|
|
var ondrain = pipeOnDrain(src);
|
|
dest.on("drain", ondrain);
|
|
var cleanedUp = false;
|
|
function cleanup() {
|
|
debug("cleanup");
|
|
dest.removeListener("close", onclose);
|
|
dest.removeListener("finish", onfinish);
|
|
dest.removeListener("drain", ondrain);
|
|
dest.removeListener("error", onerror);
|
|
dest.removeListener("unpipe", onunpipe);
|
|
src.removeListener("end", onend);
|
|
src.removeListener("end", unpipe);
|
|
src.removeListener("data", ondata);
|
|
cleanedUp = true;
|
|
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
|
|
ondrain();
|
|
}
|
|
var increasedAwaitDrain = false;
|
|
src.on("data", ondata);
|
|
function ondata(chunk) {
|
|
debug("ondata");
|
|
increasedAwaitDrain = false;
|
|
var ret = dest.write(chunk);
|
|
if (ret === false && !increasedAwaitDrain) {
|
|
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
|
|
debug("false write response, pause", src._readableState.awaitDrain);
|
|
src._readableState.awaitDrain++;
|
|
increasedAwaitDrain = true;
|
|
}
|
|
src.pause();
|
|
}
|
|
}
|
|
function onerror(er) {
|
|
debug("onerror", er);
|
|
unpipe();
|
|
dest.removeListener("error", onerror);
|
|
if (EElistenerCount(dest, "error") === 0)
|
|
dest.emit("error", er);
|
|
}
|
|
prependListener(dest, "error", onerror);
|
|
function onclose() {
|
|
dest.removeListener("finish", onfinish);
|
|
unpipe();
|
|
}
|
|
dest.once("close", onclose);
|
|
function onfinish() {
|
|
debug("onfinish");
|
|
dest.removeListener("close", onclose);
|
|
unpipe();
|
|
}
|
|
dest.once("finish", onfinish);
|
|
function unpipe() {
|
|
debug("unpipe");
|
|
src.unpipe(dest);
|
|
}
|
|
dest.emit("pipe", src);
|
|
if (!state.flowing) {
|
|
debug("pipe resume");
|
|
src.resume();
|
|
}
|
|
return dest;
|
|
};
|
|
function pipeOnDrain(src) {
|
|
return function() {
|
|
var state = src._readableState;
|
|
debug("pipeOnDrain", state.awaitDrain);
|
|
if (state.awaitDrain)
|
|
state.awaitDrain--;
|
|
if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
|
|
state.flowing = true;
|
|
flow(src);
|
|
}
|
|
};
|
|
}
|
|
Readable.prototype.unpipe = function(dest) {
|
|
var state = this._readableState;
|
|
var unpipeInfo = { hasUnpiped: false };
|
|
if (state.pipesCount === 0)
|
|
return this;
|
|
if (state.pipesCount === 1) {
|
|
if (dest && dest !== state.pipes)
|
|
return this;
|
|
if (!dest)
|
|
dest = state.pipes;
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
if (dest)
|
|
dest.emit("unpipe", this, unpipeInfo);
|
|
return this;
|
|
}
|
|
if (!dest) {
|
|
var dests = state.pipes;
|
|
var len = state.pipesCount;
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
for (var i = 0;i < len; i++) {
|
|
dests[i].emit("unpipe", this, unpipeInfo);
|
|
}
|
|
return this;
|
|
}
|
|
var index = indexOf(state.pipes, dest);
|
|
if (index === -1)
|
|
return this;
|
|
state.pipes.splice(index, 1);
|
|
state.pipesCount -= 1;
|
|
if (state.pipesCount === 1)
|
|
state.pipes = state.pipes[0];
|
|
dest.emit("unpipe", this, unpipeInfo);
|
|
return this;
|
|
};
|
|
Readable.prototype.on = function(ev, fn) {
|
|
var res = Stream.prototype.on.call(this, ev, fn);
|
|
if (ev === "data") {
|
|
if (this._readableState.flowing !== false)
|
|
this.resume();
|
|
} else if (ev === "readable") {
|
|
var state = this._readableState;
|
|
if (!state.endEmitted && !state.readableListening) {
|
|
state.readableListening = state.needReadable = true;
|
|
state.emittedReadable = false;
|
|
if (!state.reading) {
|
|
pna.nextTick(nReadingNextTick, this);
|
|
} else if (state.length) {
|
|
emitReadable(this);
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
Readable.prototype.addListener = Readable.prototype.on;
|
|
function nReadingNextTick(self2) {
|
|
debug("readable nexttick read 0");
|
|
self2.read(0);
|
|
}
|
|
Readable.prototype.resume = function() {
|
|
var state = this._readableState;
|
|
if (!state.flowing) {
|
|
debug("resume");
|
|
state.flowing = true;
|
|
resume(this, state);
|
|
}
|
|
return this;
|
|
};
|
|
function resume(stream, state) {
|
|
if (!state.resumeScheduled) {
|
|
state.resumeScheduled = true;
|
|
pna.nextTick(resume_, stream, state);
|
|
}
|
|
}
|
|
function resume_(stream, state) {
|
|
if (!state.reading) {
|
|
debug("resume read 0");
|
|
stream.read(0);
|
|
}
|
|
state.resumeScheduled = false;
|
|
state.awaitDrain = 0;
|
|
stream.emit("resume");
|
|
flow(stream);
|
|
if (state.flowing && !state.reading)
|
|
stream.read(0);
|
|
}
|
|
Readable.prototype.pause = function() {
|
|
debug("call pause flowing=%j", this._readableState.flowing);
|
|
if (this._readableState.flowing !== false) {
|
|
debug("pause");
|
|
this._readableState.flowing = false;
|
|
this.emit("pause");
|
|
}
|
|
return this;
|
|
};
|
|
function flow(stream) {
|
|
var state = stream._readableState;
|
|
debug("flow", state.flowing);
|
|
while (state.flowing && stream.read() !== null) {
|
|
}
|
|
}
|
|
Readable.prototype.wrap = function(stream) {
|
|
var _this = this;
|
|
var state = this._readableState;
|
|
var paused = false;
|
|
stream.on("end", function() {
|
|
debug("wrapped end");
|
|
if (state.decoder && !state.ended) {
|
|
var chunk = state.decoder.end();
|
|
if (chunk && chunk.length)
|
|
_this.push(chunk);
|
|
}
|
|
_this.push(null);
|
|
});
|
|
stream.on("data", function(chunk) {
|
|
debug("wrapped data");
|
|
if (state.decoder)
|
|
chunk = state.decoder.write(chunk);
|
|
if (state.objectMode && (chunk === null || chunk === undefined))
|
|
return;
|
|
else if (!state.objectMode && (!chunk || !chunk.length))
|
|
return;
|
|
var ret = _this.push(chunk);
|
|
if (!ret) {
|
|
paused = true;
|
|
stream.pause();
|
|
}
|
|
});
|
|
for (var i in stream) {
|
|
if (this[i] === undefined && typeof stream[i] === "function") {
|
|
this[i] = function(method) {
|
|
return function() {
|
|
return stream[method].apply(stream, arguments);
|
|
};
|
|
}(i);
|
|
}
|
|
}
|
|
for (var n = 0;n < kProxyEvents.length; n++) {
|
|
stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
|
|
}
|
|
this._read = function(n2) {
|
|
debug("wrapped _read", n2);
|
|
if (paused) {
|
|
paused = false;
|
|
stream.resume();
|
|
}
|
|
};
|
|
return this;
|
|
};
|
|
Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function() {
|
|
return this._readableState.highWaterMark;
|
|
}
|
|
});
|
|
Readable._fromList = fromList;
|
|
function fromList(n, state) {
|
|
if (state.length === 0)
|
|
return null;
|
|
var ret;
|
|
if (state.objectMode)
|
|
ret = state.buffer.shift();
|
|
else if (!n || n >= state.length) {
|
|
if (state.decoder)
|
|
ret = state.buffer.join("");
|
|
else if (state.buffer.length === 1)
|
|
ret = state.buffer.head.data;
|
|
else
|
|
ret = state.buffer.concat(state.length);
|
|
state.buffer.clear();
|
|
} else {
|
|
ret = fromListPartial(n, state.buffer, state.decoder);
|
|
}
|
|
return ret;
|
|
}
|
|
function fromListPartial(n, list, hasStrings) {
|
|
var ret;
|
|
if (n < list.head.data.length) {
|
|
ret = list.head.data.slice(0, n);
|
|
list.head.data = list.head.data.slice(n);
|
|
} else if (n === list.head.data.length) {
|
|
ret = list.shift();
|
|
} else {
|
|
ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
|
|
}
|
|
return ret;
|
|
}
|
|
function copyFromBufferString(n, list) {
|
|
var p = list.head;
|
|
var c = 1;
|
|
var ret = p.data;
|
|
n -= ret.length;
|
|
while (p = p.next) {
|
|
var str = p.data;
|
|
var nb = n > str.length ? str.length : n;
|
|
if (nb === str.length)
|
|
ret += str;
|
|
else
|
|
ret += str.slice(0, n);
|
|
n -= nb;
|
|
if (n === 0) {
|
|
if (nb === str.length) {
|
|
++c;
|
|
if (p.next)
|
|
list.head = p.next;
|
|
else
|
|
list.head = list.tail = null;
|
|
} else {
|
|
list.head = p;
|
|
p.data = str.slice(nb);
|
|
}
|
|
break;
|
|
}
|
|
++c;
|
|
}
|
|
list.length -= c;
|
|
return ret;
|
|
}
|
|
function copyFromBuffer(n, list) {
|
|
var ret = Buffer2.allocUnsafe(n);
|
|
var p = list.head;
|
|
var c = 1;
|
|
p.data.copy(ret);
|
|
n -= p.data.length;
|
|
while (p = p.next) {
|
|
var buf = p.data;
|
|
var nb = n > buf.length ? buf.length : n;
|
|
buf.copy(ret, ret.length - n, 0, nb);
|
|
n -= nb;
|
|
if (n === 0) {
|
|
if (nb === buf.length) {
|
|
++c;
|
|
if (p.next)
|
|
list.head = p.next;
|
|
else
|
|
list.head = list.tail = null;
|
|
} else {
|
|
list.head = p;
|
|
p.data = buf.slice(nb);
|
|
}
|
|
break;
|
|
}
|
|
++c;
|
|
}
|
|
list.length -= c;
|
|
return ret;
|
|
}
|
|
function endReadable(stream) {
|
|
var state = stream._readableState;
|
|
if (state.length > 0)
|
|
throw new Error('"endReadable()" called on non-empty stream');
|
|
if (!state.endEmitted) {
|
|
state.ended = true;
|
|
pna.nextTick(endReadableNT, state, stream);
|
|
}
|
|
}
|
|
function endReadableNT(state, stream) {
|
|
if (!state.endEmitted && state.length === 0) {
|
|
state.endEmitted = true;
|
|
stream.readable = false;
|
|
stream.emit("end");
|
|
}
|
|
}
|
|
function indexOf(xs, x) {
|
|
for (var i = 0, l = xs.length;i < l; i++) {
|
|
if (xs[i] === x)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/_stream_transform.js
|
|
var require__stream_transform = __commonJS((exports, module) => {
|
|
module.exports = Transform;
|
|
var Duplex = require__stream_duplex();
|
|
var util = Object.create(require_util());
|
|
util.inherits = require_inherits();
|
|
util.inherits(Transform, Duplex);
|
|
function afterTransform(er, data) {
|
|
var ts = this._transformState;
|
|
ts.transforming = false;
|
|
var cb = ts.writecb;
|
|
if (!cb) {
|
|
return this.emit("error", new Error("write callback called multiple times"));
|
|
}
|
|
ts.writechunk = null;
|
|
ts.writecb = null;
|
|
if (data != null)
|
|
this.push(data);
|
|
cb(er);
|
|
var rs = this._readableState;
|
|
rs.reading = false;
|
|
if (rs.needReadable || rs.length < rs.highWaterMark) {
|
|
this._read(rs.highWaterMark);
|
|
}
|
|
}
|
|
function Transform(options) {
|
|
if (!(this instanceof Transform))
|
|
return new Transform(options);
|
|
Duplex.call(this, options);
|
|
this._transformState = {
|
|
afterTransform: afterTransform.bind(this),
|
|
needTransform: false,
|
|
transforming: false,
|
|
writecb: null,
|
|
writechunk: null,
|
|
writeencoding: null
|
|
};
|
|
this._readableState.needReadable = true;
|
|
this._readableState.sync = false;
|
|
if (options) {
|
|
if (typeof options.transform === "function")
|
|
this._transform = options.transform;
|
|
if (typeof options.flush === "function")
|
|
this._flush = options.flush;
|
|
}
|
|
this.on("prefinish", prefinish);
|
|
}
|
|
function prefinish() {
|
|
var _this = this;
|
|
if (typeof this._flush === "function") {
|
|
this._flush(function(er, data) {
|
|
done(_this, er, data);
|
|
});
|
|
} else {
|
|
done(this, null, null);
|
|
}
|
|
}
|
|
Transform.prototype.push = function(chunk, encoding) {
|
|
this._transformState.needTransform = false;
|
|
return Duplex.prototype.push.call(this, chunk, encoding);
|
|
};
|
|
Transform.prototype._transform = function(chunk, encoding, cb) {
|
|
throw new Error("_transform() is not implemented");
|
|
};
|
|
Transform.prototype._write = function(chunk, encoding, cb) {
|
|
var ts = this._transformState;
|
|
ts.writecb = cb;
|
|
ts.writechunk = chunk;
|
|
ts.writeencoding = encoding;
|
|
if (!ts.transforming) {
|
|
var rs = this._readableState;
|
|
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark)
|
|
this._read(rs.highWaterMark);
|
|
}
|
|
};
|
|
Transform.prototype._read = function(n) {
|
|
var ts = this._transformState;
|
|
if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
|
|
ts.transforming = true;
|
|
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
|
|
} else {
|
|
ts.needTransform = true;
|
|
}
|
|
};
|
|
Transform.prototype._destroy = function(err, cb) {
|
|
var _this2 = this;
|
|
Duplex.prototype._destroy.call(this, err, function(err2) {
|
|
cb(err2);
|
|
_this2.emit("close");
|
|
});
|
|
};
|
|
function done(stream, er, data) {
|
|
if (er)
|
|
return stream.emit("error", er);
|
|
if (data != null)
|
|
stream.push(data);
|
|
if (stream._writableState.length)
|
|
throw new Error("Calling transform done when ws.length != 0");
|
|
if (stream._transformState.transforming)
|
|
throw new Error("Calling transform done when still transforming");
|
|
return stream.push(null);
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-stream/lib/_stream_passthrough.js
|
|
var require__stream_passthrough = __commonJS((exports, module) => {
|
|
module.exports = PassThrough;
|
|
var Transform = require__stream_transform();
|
|
var util = Object.create(require_util());
|
|
util.inherits = require_inherits();
|
|
util.inherits(PassThrough, Transform);
|
|
function PassThrough(options) {
|
|
if (!(this instanceof PassThrough))
|
|
return new PassThrough(options);
|
|
Transform.call(this, options);
|
|
}
|
|
PassThrough.prototype._transform = function(chunk, encoding, cb) {
|
|
cb(null, chunk);
|
|
};
|
|
});
|
|
|
|
// node_modules/readable-stream/readable.js
|
|
var require_readable = __commonJS((exports, module) => {
|
|
var Stream = __require("stream");
|
|
if (process.env.READABLE_STREAM === "disable" && Stream) {
|
|
module.exports = Stream;
|
|
exports = module.exports = Stream.Readable;
|
|
exports.Readable = Stream.Readable;
|
|
exports.Writable = Stream.Writable;
|
|
exports.Duplex = Stream.Duplex;
|
|
exports.Transform = Stream.Transform;
|
|
exports.PassThrough = Stream.PassThrough;
|
|
exports.Stream = Stream;
|
|
} else {
|
|
exports = module.exports = require__stream_readable();
|
|
exports.Stream = Stream || exports;
|
|
exports.Readable = exports;
|
|
exports.Writable = require__stream_writable();
|
|
exports.Duplex = require__stream_duplex();
|
|
exports.Transform = require__stream_transform();
|
|
exports.PassThrough = require__stream_passthrough();
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Query.js
|
|
var require_Query = __commonJS((exports, module) => {
|
|
var ClientConstants = require_client();
|
|
var fs2 = __require("fs");
|
|
var Packets = require_packets();
|
|
var ResultSet = require_ResultSet();
|
|
var Sequence = require_Sequence();
|
|
var ServerStatus = require_server_status();
|
|
var Readable = require_readable();
|
|
var Util = __require("util");
|
|
module.exports = Query;
|
|
Util.inherits(Query, Sequence);
|
|
function Query(options, callback) {
|
|
Sequence.call(this, options, callback);
|
|
this.sql = options.sql;
|
|
this.values = options.values;
|
|
this.typeCast = options.typeCast === undefined ? true : options.typeCast;
|
|
this.nestTables = options.nestTables || false;
|
|
this._resultSet = null;
|
|
this._results = [];
|
|
this._fields = [];
|
|
this._index = 0;
|
|
this._loadError = null;
|
|
}
|
|
Query.prototype.start = function() {
|
|
this.emit("packet", new Packets.ComQueryPacket(this.sql));
|
|
};
|
|
Query.prototype.determinePacket = function determinePacket(byte, parser) {
|
|
var resultSet = this._resultSet;
|
|
if (!resultSet) {
|
|
switch (byte) {
|
|
case 0:
|
|
return Packets.OkPacket;
|
|
case 251:
|
|
return Packets.LocalInfileRequestPacket;
|
|
case 255:
|
|
return Packets.ErrorPacket;
|
|
default:
|
|
return Packets.ResultSetHeaderPacket;
|
|
}
|
|
}
|
|
if (resultSet.eofPackets.length === 0) {
|
|
return resultSet.fieldPackets.length < resultSet.resultSetHeaderPacket.fieldCount ? Packets.FieldPacket : Packets.EofPacket;
|
|
}
|
|
if (byte === 255) {
|
|
return Packets.ErrorPacket;
|
|
}
|
|
if (byte === 254 && parser.packetLength() < 9) {
|
|
return Packets.EofPacket;
|
|
}
|
|
return Packets.RowDataPacket;
|
|
};
|
|
Query.prototype["OkPacket"] = function(packet) {
|
|
try {
|
|
if (!this._callback) {
|
|
this.emit("result", packet, this._index);
|
|
} else {
|
|
this._results.push(packet);
|
|
this._fields.push(undefined);
|
|
}
|
|
} finally {
|
|
this._index++;
|
|
this._resultSet = null;
|
|
this._handleFinalResultPacket(packet);
|
|
}
|
|
};
|
|
Query.prototype["ErrorPacket"] = function(packet) {
|
|
var err = this._packetToError(packet);
|
|
var results = this._results.length > 0 ? this._results : undefined;
|
|
var fields = this._fields.length > 0 ? this._fields : undefined;
|
|
err.index = this._index;
|
|
err.sql = this.sql;
|
|
this.end(err, results, fields);
|
|
};
|
|
Query.prototype["LocalInfileRequestPacket"] = function(packet) {
|
|
if (this._connection.config.clientFlags & ClientConstants.CLIENT_LOCAL_FILES) {
|
|
this._sendLocalDataFile(packet.filename);
|
|
} else {
|
|
this._loadError = new Error("Load local files command is disabled");
|
|
this._loadError.code = "LOCAL_FILES_DISABLED";
|
|
this._loadError.fatal = false;
|
|
this.emit("packet", new Packets.EmptyPacket);
|
|
}
|
|
};
|
|
Query.prototype["ResultSetHeaderPacket"] = function(packet) {
|
|
this._resultSet = new ResultSet(packet);
|
|
};
|
|
Query.prototype["FieldPacket"] = function(packet) {
|
|
this._resultSet.fieldPackets.push(packet);
|
|
};
|
|
Query.prototype["EofPacket"] = function(packet) {
|
|
this._resultSet.eofPackets.push(packet);
|
|
if (this._resultSet.eofPackets.length === 1 && !this._callback) {
|
|
this.emit("fields", this._resultSet.fieldPackets, this._index);
|
|
}
|
|
if (this._resultSet.eofPackets.length !== 2) {
|
|
return;
|
|
}
|
|
if (this._callback) {
|
|
this._results.push(this._resultSet.rows);
|
|
this._fields.push(this._resultSet.fieldPackets);
|
|
}
|
|
this._index++;
|
|
this._resultSet = null;
|
|
this._handleFinalResultPacket(packet);
|
|
};
|
|
Query.prototype._handleFinalResultPacket = function(packet) {
|
|
if (packet.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) {
|
|
return;
|
|
}
|
|
var results = this._results.length > 1 ? this._results : this._results[0];
|
|
var fields = this._fields.length > 1 ? this._fields : this._fields[0];
|
|
this.end(this._loadError, results, fields);
|
|
};
|
|
Query.prototype["RowDataPacket"] = function(packet, parser, connection) {
|
|
packet.parse(parser, this._resultSet.fieldPackets, this.typeCast, this.nestTables, connection);
|
|
if (this._callback) {
|
|
this._resultSet.rows.push(packet);
|
|
} else {
|
|
this.emit("result", packet, this._index);
|
|
}
|
|
};
|
|
Query.prototype._sendLocalDataFile = function(path) {
|
|
var self2 = this;
|
|
var localStream = fs2.createReadStream(path, {
|
|
flag: "r",
|
|
encoding: null,
|
|
autoClose: true
|
|
});
|
|
this.on("pause", function() {
|
|
localStream.pause();
|
|
});
|
|
this.on("resume", function() {
|
|
localStream.resume();
|
|
});
|
|
localStream.on("data", function(data) {
|
|
self2.emit("packet", new Packets.LocalDataFilePacket(data));
|
|
});
|
|
localStream.on("error", function(err) {
|
|
self2._loadError = err;
|
|
localStream.emit("end");
|
|
});
|
|
localStream.on("end", function() {
|
|
self2.emit("packet", new Packets.EmptyPacket);
|
|
});
|
|
};
|
|
Query.prototype.stream = function(options) {
|
|
var self2 = this;
|
|
options = options || {};
|
|
options.objectMode = true;
|
|
var stream = new Readable(options);
|
|
stream._read = function() {
|
|
self2._connection && self2._connection.resume();
|
|
};
|
|
stream.once("end", function() {
|
|
process.nextTick(function() {
|
|
stream.emit("close");
|
|
});
|
|
});
|
|
this.on("result", function(row, i) {
|
|
if (!stream.push(row))
|
|
self2._connection.pause();
|
|
stream.emit("result", row, i);
|
|
});
|
|
this.on("error", function(err) {
|
|
stream.emit("error", err);
|
|
});
|
|
this.on("end", function() {
|
|
stream.push(null);
|
|
});
|
|
this.on("fields", function(fields, i) {
|
|
stream.emit("fields", fields, i);
|
|
});
|
|
return stream;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Quit.js
|
|
var require_Quit = __commonJS((exports, module) => {
|
|
var Sequence = require_Sequence();
|
|
var Util = __require("util");
|
|
var Packets = require_packets();
|
|
module.exports = Quit;
|
|
Util.inherits(Quit, Sequence);
|
|
function Quit(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
Sequence.call(this, options, callback);
|
|
this._started = false;
|
|
}
|
|
Quit.prototype.end = function end(err) {
|
|
if (this._ended) {
|
|
return;
|
|
}
|
|
if (!this._started) {
|
|
Sequence.prototype.end.call(this, err);
|
|
return;
|
|
}
|
|
if (err && err.code === "ECONNRESET" && err.syscall === "read") {
|
|
Sequence.prototype.end.call(this);
|
|
return;
|
|
}
|
|
Sequence.prototype.end.call(this, err);
|
|
};
|
|
Quit.prototype.start = function() {
|
|
this._started = true;
|
|
this.emit("packet", new Packets.ComQuitPacket);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/Statistics.js
|
|
var require_Statistics = __commonJS((exports, module) => {
|
|
var Sequence = require_Sequence();
|
|
var Util = __require("util");
|
|
var Packets = require_packets();
|
|
module.exports = Statistics;
|
|
Util.inherits(Statistics, Sequence);
|
|
function Statistics(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
Sequence.call(this, options, callback);
|
|
}
|
|
Statistics.prototype.start = function() {
|
|
this.emit("packet", new Packets.ComStatisticsPacket);
|
|
};
|
|
Statistics.prototype["StatisticsPacket"] = function(packet) {
|
|
this.end(null, packet);
|
|
};
|
|
Statistics.prototype.determinePacket = function determinePacket(firstByte) {
|
|
if (firstByte === 85) {
|
|
return Packets.StatisticsPacket;
|
|
}
|
|
return;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/sequences/index.js
|
|
var require_sequences = __commonJS((exports) => {
|
|
exports.ChangeUser = require_ChangeUser();
|
|
exports.Handshake = require_Handshake();
|
|
exports.Ping = require_Ping();
|
|
exports.Query = require_Query();
|
|
exports.Quit = require_Quit();
|
|
exports.Sequence = require_Sequence();
|
|
exports.Statistics = require_Statistics();
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/PacketWriter.js
|
|
var require_PacketWriter = __commonJS((exports, module) => {
|
|
var BIT_16 = Math.pow(2, 16);
|
|
var BIT_24 = Math.pow(2, 24);
|
|
var BUFFER_ALLOC_SIZE = Math.pow(2, 8);
|
|
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
|
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
module.exports = PacketWriter;
|
|
function PacketWriter() {
|
|
this._buffer = null;
|
|
this._offset = 0;
|
|
}
|
|
PacketWriter.prototype.toBuffer = function toBuffer(parser) {
|
|
if (!this._buffer) {
|
|
this._buffer = Buffer2.alloc(0);
|
|
this._offset = 0;
|
|
}
|
|
var buffer = this._buffer;
|
|
var length = this._offset;
|
|
var packets = Math.floor(length / MAX_PACKET_LENGTH) + 1;
|
|
this._buffer = Buffer2.allocUnsafe(length + packets * 4);
|
|
this._offset = 0;
|
|
for (var packet = 0;packet < packets; packet++) {
|
|
var isLast = packet + 1 === packets;
|
|
var packetLength = isLast ? length % MAX_PACKET_LENGTH : MAX_PACKET_LENGTH;
|
|
var packetNumber = parser.incrementPacketNumber();
|
|
this.writeUnsignedNumber(3, packetLength);
|
|
this.writeUnsignedNumber(1, packetNumber);
|
|
var start = packet * MAX_PACKET_LENGTH;
|
|
var end = start + packetLength;
|
|
this.writeBuffer(buffer.slice(start, end));
|
|
}
|
|
return this._buffer;
|
|
};
|
|
PacketWriter.prototype.writeUnsignedNumber = function(bytes, value) {
|
|
this._allocate(bytes);
|
|
for (var i = 0;i < bytes; i++) {
|
|
this._buffer[this._offset++] = value >> i * 8 & 255;
|
|
}
|
|
};
|
|
PacketWriter.prototype.writeFiller = function(bytes) {
|
|
this._allocate(bytes);
|
|
for (var i = 0;i < bytes; i++) {
|
|
this._buffer[this._offset++] = 0;
|
|
}
|
|
};
|
|
PacketWriter.prototype.writeNullTerminatedString = function(value, encoding) {
|
|
value = value || "";
|
|
value = value + "";
|
|
var bytes = Buffer2.byteLength(value, encoding || "utf-8") + 1;
|
|
this._allocate(bytes);
|
|
this._buffer.write(value, this._offset, encoding);
|
|
this._buffer[this._offset + bytes - 1] = 0;
|
|
this._offset += bytes;
|
|
};
|
|
PacketWriter.prototype.writeString = function(value) {
|
|
value = value || "";
|
|
value = value + "";
|
|
var bytes = Buffer2.byteLength(value, "utf-8");
|
|
this._allocate(bytes);
|
|
this._buffer.write(value, this._offset, "utf-8");
|
|
this._offset += bytes;
|
|
};
|
|
PacketWriter.prototype.writeBuffer = function(value) {
|
|
var bytes = value.length;
|
|
this._allocate(bytes);
|
|
value.copy(this._buffer, this._offset);
|
|
this._offset += bytes;
|
|
};
|
|
PacketWriter.prototype.writeLengthCodedNumber = function(value) {
|
|
if (value === null) {
|
|
this._allocate(1);
|
|
this._buffer[this._offset++] = 251;
|
|
return;
|
|
}
|
|
if (value <= 250) {
|
|
this._allocate(1);
|
|
this._buffer[this._offset++] = value;
|
|
return;
|
|
}
|
|
if (value > IEEE_754_BINARY_64_PRECISION) {
|
|
throw new Error("writeLengthCodedNumber: JS precision range exceeded, your " + 'number is > 53 bit: "' + value + '"');
|
|
}
|
|
if (value < BIT_16) {
|
|
this._allocate(3);
|
|
this._buffer[this._offset++] = 252;
|
|
} else if (value < BIT_24) {
|
|
this._allocate(4);
|
|
this._buffer[this._offset++] = 253;
|
|
} else {
|
|
this._allocate(9);
|
|
this._buffer[this._offset++] = 254;
|
|
}
|
|
this._buffer[this._offset++] = value & 255;
|
|
this._buffer[this._offset++] = value >> 8 & 255;
|
|
if (value < BIT_16) {
|
|
return;
|
|
}
|
|
this._buffer[this._offset++] = value >> 16 & 255;
|
|
if (value < BIT_24) {
|
|
return;
|
|
}
|
|
this._buffer[this._offset++] = value >> 24 & 255;
|
|
value = value.toString(2);
|
|
value = value.substr(0, value.length - 32);
|
|
value = parseInt(value, 2);
|
|
this._buffer[this._offset++] = value & 255;
|
|
this._buffer[this._offset++] = value >> 8 & 255;
|
|
this._buffer[this._offset++] = value >> 16 & 255;
|
|
this._buffer[this._offset++] = 0;
|
|
};
|
|
PacketWriter.prototype.writeLengthCodedBuffer = function(value) {
|
|
var bytes = value.length;
|
|
this.writeLengthCodedNumber(bytes);
|
|
this.writeBuffer(value);
|
|
};
|
|
PacketWriter.prototype.writeNullTerminatedBuffer = function(value) {
|
|
this.writeBuffer(value);
|
|
this.writeFiller(1);
|
|
};
|
|
PacketWriter.prototype.writeLengthCodedString = function(value) {
|
|
if (value === null) {
|
|
this.writeLengthCodedNumber(null);
|
|
return;
|
|
}
|
|
value = value === undefined ? "" : String(value);
|
|
var bytes = Buffer2.byteLength(value, "utf-8");
|
|
this.writeLengthCodedNumber(bytes);
|
|
if (!bytes) {
|
|
return;
|
|
}
|
|
this._allocate(bytes);
|
|
this._buffer.write(value, this._offset, "utf-8");
|
|
this._offset += bytes;
|
|
};
|
|
PacketWriter.prototype._allocate = function _allocate(bytes) {
|
|
if (!this._buffer) {
|
|
this._buffer = Buffer2.alloc(Math.max(BUFFER_ALLOC_SIZE, bytes));
|
|
this._offset = 0;
|
|
return;
|
|
}
|
|
var bytesRemaining = this._buffer.length - this._offset;
|
|
if (bytesRemaining >= bytes) {
|
|
return;
|
|
}
|
|
var newSize = this._buffer.length + Math.max(BUFFER_ALLOC_SIZE, bytes);
|
|
var oldBuffer = this._buffer;
|
|
this._buffer = Buffer2.alloc(newSize);
|
|
oldBuffer.copy(this._buffer);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/protocol/Protocol.js
|
|
var require_Protocol = __commonJS((exports, module) => {
|
|
var Parser = require_Parser();
|
|
var Sequences = require_sequences();
|
|
var Packets = require_packets();
|
|
var Stream = __require("stream").Stream;
|
|
var Util = __require("util");
|
|
var PacketWriter = require_PacketWriter();
|
|
module.exports = Protocol;
|
|
Util.inherits(Protocol, Stream);
|
|
function Protocol(options) {
|
|
Stream.call(this);
|
|
options = options || {};
|
|
this.readable = true;
|
|
this.writable = true;
|
|
this._config = options.config || {};
|
|
this._connection = options.connection;
|
|
this._callback = null;
|
|
this._fatalError = null;
|
|
this._quitSequence = null;
|
|
this._handshake = false;
|
|
this._handshaked = false;
|
|
this._ended = false;
|
|
this._destroyed = false;
|
|
this._queue = [];
|
|
this._handshakeInitializationPacket = null;
|
|
this._parser = new Parser({
|
|
onError: this.handleParserError.bind(this),
|
|
onPacket: this._parsePacket.bind(this),
|
|
config: this._config
|
|
});
|
|
}
|
|
Protocol.prototype.write = function(buffer) {
|
|
this._parser.write(buffer);
|
|
return true;
|
|
};
|
|
Protocol.prototype.handshake = function handshake(options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
options = options || {};
|
|
options.config = this._config;
|
|
var sequence = this._enqueue(new Sequences.Handshake(options, callback));
|
|
this._handshake = true;
|
|
return sequence;
|
|
};
|
|
Protocol.prototype.query = function query(options, callback) {
|
|
return this._enqueue(new Sequences.Query(options, callback));
|
|
};
|
|
Protocol.prototype.changeUser = function changeUser(options, callback) {
|
|
return this._enqueue(new Sequences.ChangeUser(options, callback));
|
|
};
|
|
Protocol.prototype.ping = function ping(options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
return this._enqueue(new Sequences.Ping(options, callback));
|
|
};
|
|
Protocol.prototype.stats = function stats(options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
return this._enqueue(new Sequences.Statistics(options, callback));
|
|
};
|
|
Protocol.prototype.quit = function quit(options, callback) {
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
var self2 = this;
|
|
var sequence = this._enqueue(new Sequences.Quit(options, callback));
|
|
sequence.on("end", function() {
|
|
self2.end();
|
|
});
|
|
return this._quitSequence = sequence;
|
|
};
|
|
Protocol.prototype.end = function() {
|
|
if (this._ended) {
|
|
return;
|
|
}
|
|
this._ended = true;
|
|
if (this._quitSequence && (this._quitSequence._ended || this._queue[0] === this._quitSequence)) {
|
|
this._quitSequence.end();
|
|
this.emit("end");
|
|
return;
|
|
}
|
|
var err = new Error("Connection lost: The server closed the connection.");
|
|
err.fatal = true;
|
|
err.code = "PROTOCOL_CONNECTION_LOST";
|
|
this._delegateError(err);
|
|
};
|
|
Protocol.prototype.pause = function() {
|
|
this._parser.pause();
|
|
var seq = this._queue[0];
|
|
if (seq && seq.emit) {
|
|
seq.emit("pause");
|
|
}
|
|
};
|
|
Protocol.prototype.resume = function() {
|
|
this._parser.resume();
|
|
var seq = this._queue[0];
|
|
if (seq && seq.emit) {
|
|
seq.emit("resume");
|
|
}
|
|
};
|
|
Protocol.prototype._enqueue = function(sequence) {
|
|
if (!this._validateEnqueue(sequence)) {
|
|
return sequence;
|
|
}
|
|
if (this._config.trace) {
|
|
sequence._callSite = sequence._callSite || new Error;
|
|
}
|
|
this._queue.push(sequence);
|
|
this.emit("enqueue", sequence);
|
|
var self2 = this;
|
|
sequence.on("error", function(err) {
|
|
self2._delegateError(err, sequence);
|
|
}).on("packet", function(packet) {
|
|
sequence._timer.active();
|
|
self2._emitPacket(packet);
|
|
}).on("timeout", function() {
|
|
var err = new Error(sequence.constructor.name + " inactivity timeout");
|
|
err.code = "PROTOCOL_SEQUENCE_TIMEOUT";
|
|
err.fatal = true;
|
|
err.timeout = sequence._timeout;
|
|
self2._delegateError(err, sequence);
|
|
});
|
|
if (sequence.constructor === Sequences.Handshake) {
|
|
sequence.on("start-tls", function() {
|
|
sequence._timer.active();
|
|
self2._connection._startTLS(function(err) {
|
|
if (err) {
|
|
err.code = "HANDSHAKE_SSL_ERROR";
|
|
err.fatal = true;
|
|
sequence.end(err);
|
|
return;
|
|
}
|
|
sequence._timer.active();
|
|
sequence._tlsUpgradeCompleteHandler();
|
|
});
|
|
});
|
|
sequence.on("end", function() {
|
|
self2._handshaked = true;
|
|
if (!self2._fatalError) {
|
|
self2.emit("handshake", self2._handshakeInitializationPacket);
|
|
}
|
|
});
|
|
}
|
|
sequence.on("end", function() {
|
|
self2._dequeue(sequence);
|
|
});
|
|
if (this._queue.length === 1) {
|
|
this._parser.resetPacketNumber();
|
|
this._startSequence(sequence);
|
|
}
|
|
return sequence;
|
|
};
|
|
Protocol.prototype._validateEnqueue = function _validateEnqueue(sequence) {
|
|
var err;
|
|
var prefix = "Cannot enqueue " + sequence.constructor.name;
|
|
if (this._fatalError) {
|
|
err = new Error(prefix + " after fatal error.");
|
|
err.code = "PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR";
|
|
} else if (this._quitSequence) {
|
|
err = new Error(prefix + " after invoking quit.");
|
|
err.code = "PROTOCOL_ENQUEUE_AFTER_QUIT";
|
|
} else if (this._destroyed) {
|
|
err = new Error(prefix + " after being destroyed.");
|
|
err.code = "PROTOCOL_ENQUEUE_AFTER_DESTROY";
|
|
} else if ((this._handshake || this._handshaked) && sequence.constructor === Sequences.Handshake) {
|
|
err = new Error(prefix + " after already enqueuing a Handshake.");
|
|
err.code = "PROTOCOL_ENQUEUE_HANDSHAKE_TWICE";
|
|
} else {
|
|
return true;
|
|
}
|
|
var self2 = this;
|
|
err.fatal = false;
|
|
sequence.on("error", function(err2) {
|
|
self2._delegateError(err2, sequence);
|
|
});
|
|
process.nextTick(function() {
|
|
sequence.end(err);
|
|
});
|
|
return false;
|
|
};
|
|
Protocol.prototype._parsePacket = function() {
|
|
var sequence = this._queue[0];
|
|
if (!sequence) {
|
|
var err = new Error("Received packet with no active sequence.");
|
|
err.code = "PROTOCOL_STRAY_PACKET";
|
|
err.fatal = true;
|
|
this._delegateError(err);
|
|
return;
|
|
}
|
|
var Packet = this._determinePacket(sequence);
|
|
var packet = new Packet({ protocol41: this._config.protocol41 });
|
|
var packetName = Packet.name;
|
|
if (Packet === Packets.RowDataPacket) {
|
|
sequence.RowDataPacket(packet, this._parser, this._connection);
|
|
if (this._config.debug) {
|
|
this._debugPacket(true, packet);
|
|
}
|
|
return;
|
|
}
|
|
if (this._config.debug) {
|
|
this._parsePacketDebug(packet);
|
|
} else {
|
|
packet.parse(this._parser);
|
|
}
|
|
if (Packet === Packets.HandshakeInitializationPacket) {
|
|
this._handshakeInitializationPacket = packet;
|
|
this.emit("initialize", packet);
|
|
}
|
|
sequence._timer.active();
|
|
if (!sequence[packetName]) {
|
|
var err = new Error("Received packet in the wrong sequence.");
|
|
err.code = "PROTOCOL_INCORRECT_PACKET_SEQUENCE";
|
|
err.fatal = true;
|
|
this._delegateError(err);
|
|
return;
|
|
}
|
|
sequence[packetName](packet);
|
|
};
|
|
Protocol.prototype._parsePacketDebug = function _parsePacketDebug(packet) {
|
|
try {
|
|
packet.parse(this._parser);
|
|
} finally {
|
|
this._debugPacket(true, packet);
|
|
}
|
|
};
|
|
Protocol.prototype._emitPacket = function(packet) {
|
|
var packetWriter = new PacketWriter;
|
|
packet.write(packetWriter);
|
|
this.emit("data", packetWriter.toBuffer(this._parser));
|
|
if (this._config.debug) {
|
|
this._debugPacket(false, packet);
|
|
}
|
|
};
|
|
Protocol.prototype._determinePacket = function(sequence) {
|
|
var firstByte = this._parser.peak();
|
|
if (sequence.determinePacket) {
|
|
var Packet = sequence.determinePacket(firstByte, this._parser);
|
|
if (Packet) {
|
|
return Packet;
|
|
}
|
|
}
|
|
switch (firstByte) {
|
|
case 0:
|
|
return Packets.OkPacket;
|
|
case 254:
|
|
return Packets.EofPacket;
|
|
case 255:
|
|
return Packets.ErrorPacket;
|
|
}
|
|
throw new Error("Could not determine packet, firstByte = " + firstByte);
|
|
};
|
|
Protocol.prototype._dequeue = function(sequence) {
|
|
sequence._timer.stop();
|
|
if (this._fatalError) {
|
|
return;
|
|
}
|
|
this._queue.shift();
|
|
var sequence = this._queue[0];
|
|
if (!sequence) {
|
|
this.emit("drain");
|
|
return;
|
|
}
|
|
this._parser.resetPacketNumber();
|
|
this._startSequence(sequence);
|
|
};
|
|
Protocol.prototype._startSequence = function(sequence) {
|
|
if (sequence._timeout > 0 && isFinite(sequence._timeout)) {
|
|
sequence._timer.start(sequence._timeout);
|
|
}
|
|
if (sequence.constructor === Sequences.ChangeUser) {
|
|
sequence.start(this._handshakeInitializationPacket);
|
|
} else {
|
|
sequence.start();
|
|
}
|
|
};
|
|
Protocol.prototype.handleNetworkError = function(err) {
|
|
err.fatal = true;
|
|
var sequence = this._queue[0];
|
|
if (sequence) {
|
|
sequence.end(err);
|
|
} else {
|
|
this._delegateError(err);
|
|
}
|
|
};
|
|
Protocol.prototype.handleParserError = function handleParserError(err) {
|
|
var sequence = this._queue[0];
|
|
if (sequence) {
|
|
sequence.end(err);
|
|
} else {
|
|
this._delegateError(err);
|
|
}
|
|
};
|
|
Protocol.prototype._delegateError = function(err, sequence) {
|
|
if (this._fatalError) {
|
|
return;
|
|
}
|
|
if (err.fatal) {
|
|
this._fatalError = err;
|
|
}
|
|
if (this._shouldErrorBubbleUp(err, sequence)) {
|
|
this.emit("unhandledError", err);
|
|
} else if (err.fatal) {
|
|
var queue = this._queue;
|
|
process.nextTick(function() {
|
|
queue.forEach(function(sequence2) {
|
|
sequence2.end(err);
|
|
});
|
|
queue.length = 0;
|
|
});
|
|
}
|
|
if (err.fatal) {
|
|
this.emit("end", err);
|
|
}
|
|
};
|
|
Protocol.prototype._shouldErrorBubbleUp = function(err, sequence) {
|
|
if (sequence) {
|
|
if (sequence.hasErrorHandler()) {
|
|
return false;
|
|
} else if (!err.fatal) {
|
|
return true;
|
|
}
|
|
}
|
|
return err.fatal && !this._hasPendingErrorHandlers();
|
|
};
|
|
Protocol.prototype._hasPendingErrorHandlers = function() {
|
|
return this._queue.some(function(sequence) {
|
|
return sequence.hasErrorHandler();
|
|
});
|
|
};
|
|
Protocol.prototype.destroy = function() {
|
|
this._destroyed = true;
|
|
this._parser.pause();
|
|
if (this._connection.state !== "disconnected") {
|
|
if (!this._ended) {
|
|
this.end();
|
|
}
|
|
}
|
|
};
|
|
Protocol.prototype._debugPacket = function(incoming, packet) {
|
|
var connection = this._connection;
|
|
var direction = incoming ? "<--" : "-->";
|
|
var packetName = packet.constructor.name;
|
|
var threadId = connection && connection.threadId !== null ? " (" + connection.threadId + ")" : "";
|
|
if (Array.isArray(this._config.debug) && this._config.debug.indexOf(packetName) === -1) {
|
|
return;
|
|
}
|
|
var packetPayload = Util.inspect(packet).replace(/^[^{]+/, "");
|
|
console.log("%s%s %s %s\n", direction, threadId, packetName, packetPayload);
|
|
};
|
|
});
|
|
|
|
// node_modules/sqlstring/lib/SqlString.js
|
|
var require_SqlString = __commonJS((exports) => {
|
|
var SqlString = exports;
|
|
var ID_GLOBAL_REGEXP = /`/g;
|
|
var QUAL_GLOBAL_REGEXP = /\./g;
|
|
var CHARS_GLOBAL_REGEXP = /[\0\b\t\n\r\x1a\"\'\\]/g;
|
|
var CHARS_ESCAPE_MAP = {
|
|
"\0": "\\0",
|
|
"\b": "\\b",
|
|
"\t": "\\t",
|
|
"\n": "\\n",
|
|
"\r": "\\r",
|
|
"\x1A": "\\Z",
|
|
'"': '\\"',
|
|
"\'": "\\\'",
|
|
"\\": "\\\\"
|
|
};
|
|
SqlString.escapeId = function escapeId(val, forbidQualified) {
|
|
if (Array.isArray(val)) {
|
|
var sql = "";
|
|
for (var i = 0;i < val.length; i++) {
|
|
sql += (i === 0 ? "" : ", ") + SqlString.escapeId(val[i], forbidQualified);
|
|
}
|
|
return sql;
|
|
} else if (forbidQualified) {
|
|
return "`" + String(val).replace(ID_GLOBAL_REGEXP, "``") + "`";
|
|
} else {
|
|
return "`" + String(val).replace(ID_GLOBAL_REGEXP, "``").replace(QUAL_GLOBAL_REGEXP, "`.`") + "`";
|
|
}
|
|
};
|
|
SqlString.escape = function escape(val, stringifyObjects, timeZone) {
|
|
if (val === undefined || val === null) {
|
|
return "NULL";
|
|
}
|
|
switch (typeof val) {
|
|
case "boolean":
|
|
return val ? "true" : "false";
|
|
case "number":
|
|
return val + "";
|
|
case "object":
|
|
if (val instanceof Date) {
|
|
return SqlString.dateToString(val, timeZone || "local");
|
|
} else if (Array.isArray(val)) {
|
|
return SqlString.arrayToList(val, timeZone);
|
|
} else if (Buffer.isBuffer(val)) {
|
|
return SqlString.bufferToString(val);
|
|
} else if (typeof val.toSqlString === "function") {
|
|
return String(val.toSqlString());
|
|
} else if (stringifyObjects) {
|
|
return escapeString(val.toString());
|
|
} else {
|
|
return SqlString.objectToValues(val, timeZone);
|
|
}
|
|
default:
|
|
return escapeString(val);
|
|
}
|
|
};
|
|
SqlString.arrayToList = function arrayToList(array, timeZone) {
|
|
var sql = "";
|
|
for (var i = 0;i < array.length; i++) {
|
|
var val = array[i];
|
|
if (Array.isArray(val)) {
|
|
sql += (i === 0 ? "" : ", ") + "(" + SqlString.arrayToList(val, timeZone) + ")";
|
|
} else {
|
|
sql += (i === 0 ? "" : ", ") + SqlString.escape(val, true, timeZone);
|
|
}
|
|
}
|
|
return sql;
|
|
};
|
|
SqlString.format = function format(sql, values, stringifyObjects, timeZone) {
|
|
if (values == null) {
|
|
return sql;
|
|
}
|
|
if (!(values instanceof Array || Array.isArray(values))) {
|
|
values = [values];
|
|
}
|
|
var chunkIndex = 0;
|
|
var placeholdersRegex = /\?+/g;
|
|
var result = "";
|
|
var valuesIndex = 0;
|
|
var match;
|
|
while (valuesIndex < values.length && (match = placeholdersRegex.exec(sql))) {
|
|
var len = match[0].length;
|
|
if (len > 2) {
|
|
continue;
|
|
}
|
|
var value = len === 2 ? SqlString.escapeId(values[valuesIndex]) : SqlString.escape(values[valuesIndex], stringifyObjects, timeZone);
|
|
result += sql.slice(chunkIndex, match.index) + value;
|
|
chunkIndex = placeholdersRegex.lastIndex;
|
|
valuesIndex++;
|
|
}
|
|
if (chunkIndex === 0) {
|
|
return sql;
|
|
}
|
|
if (chunkIndex < sql.length) {
|
|
return result + sql.slice(chunkIndex);
|
|
}
|
|
return result;
|
|
};
|
|
SqlString.dateToString = function dateToString(date, timeZone) {
|
|
var dt = new Date(date);
|
|
if (isNaN(dt.getTime())) {
|
|
return "NULL";
|
|
}
|
|
var year;
|
|
var month;
|
|
var day;
|
|
var hour;
|
|
var minute;
|
|
var second;
|
|
var millisecond;
|
|
if (timeZone === "local") {
|
|
year = dt.getFullYear();
|
|
month = dt.getMonth() + 1;
|
|
day = dt.getDate();
|
|
hour = dt.getHours();
|
|
minute = dt.getMinutes();
|
|
second = dt.getSeconds();
|
|
millisecond = dt.getMilliseconds();
|
|
} else {
|
|
var tz = convertTimezone(timeZone);
|
|
if (tz !== false && tz !== 0) {
|
|
dt.setTime(dt.getTime() + tz * 60000);
|
|
}
|
|
year = dt.getUTCFullYear();
|
|
month = dt.getUTCMonth() + 1;
|
|
day = dt.getUTCDate();
|
|
hour = dt.getUTCHours();
|
|
minute = dt.getUTCMinutes();
|
|
second = dt.getUTCSeconds();
|
|
millisecond = dt.getUTCMilliseconds();
|
|
}
|
|
var str = zeroPad(year, 4) + "-" + zeroPad(month, 2) + "-" + zeroPad(day, 2) + " " + zeroPad(hour, 2) + ":" + zeroPad(minute, 2) + ":" + zeroPad(second, 2) + "." + zeroPad(millisecond, 3);
|
|
return escapeString(str);
|
|
};
|
|
SqlString.bufferToString = function bufferToString(buffer) {
|
|
return "X" + escapeString(buffer.toString("hex"));
|
|
};
|
|
SqlString.objectToValues = function objectToValues(object, timeZone) {
|
|
var sql = "";
|
|
for (var key in object) {
|
|
var val = object[key];
|
|
if (typeof val === "function") {
|
|
continue;
|
|
}
|
|
sql += (sql.length === 0 ? "" : ", ") + SqlString.escapeId(key) + " = " + SqlString.escape(val, true, timeZone);
|
|
}
|
|
return sql;
|
|
};
|
|
SqlString.raw = function raw(sql) {
|
|
if (typeof sql !== "string") {
|
|
throw new TypeError("argument sql must be a string");
|
|
}
|
|
return {
|
|
toSqlString: function toSqlString() {
|
|
return sql;
|
|
}
|
|
};
|
|
};
|
|
function escapeString(val) {
|
|
var chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex = 0;
|
|
var escapedVal = "";
|
|
var match;
|
|
while (match = CHARS_GLOBAL_REGEXP.exec(val)) {
|
|
escapedVal += val.slice(chunkIndex, match.index) + CHARS_ESCAPE_MAP[match[0]];
|
|
chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex;
|
|
}
|
|
if (chunkIndex === 0) {
|
|
return "'" + val + "'";
|
|
}
|
|
if (chunkIndex < val.length) {
|
|
return "'" + escapedVal + val.slice(chunkIndex) + "'";
|
|
}
|
|
return "'" + escapedVal + "'";
|
|
}
|
|
function zeroPad(number, length) {
|
|
number = number.toString();
|
|
while (number.length < length) {
|
|
number = "0" + number;
|
|
}
|
|
return number;
|
|
}
|
|
function convertTimezone(tz) {
|
|
if (tz === "Z") {
|
|
return 0;
|
|
}
|
|
var m = tz.match(/([\+\-\s])(\d\d):?(\d\d)?/);
|
|
if (m) {
|
|
return (m[1] === "-" ? -1 : 1) * (parseInt(m[2], 10) + (m[3] ? parseInt(m[3], 10) : 0) / 60) * 60;
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/Connection.js
|
|
var require_Connection = __commonJS((exports, module) => {
|
|
var Crypto = __require("crypto");
|
|
var Events = __require("events");
|
|
var Net = __require("net");
|
|
var tls = __require("tls");
|
|
var ConnectionConfig = require_ConnectionConfig();
|
|
var Protocol = require_Protocol();
|
|
var SqlString = require_SqlString();
|
|
var Query = require_Query();
|
|
var Util = __require("util");
|
|
module.exports = Connection;
|
|
Util.inherits(Connection, Events.EventEmitter);
|
|
function Connection(options) {
|
|
Events.EventEmitter.call(this);
|
|
this.config = options.config;
|
|
this._socket = options.socket;
|
|
this._protocol = new Protocol({ config: this.config, connection: this });
|
|
this._connectCalled = false;
|
|
this.state = "disconnected";
|
|
this.threadId = null;
|
|
}
|
|
Connection.createQuery = function createQuery(sql, values, callback) {
|
|
if (sql instanceof Query) {
|
|
return sql;
|
|
}
|
|
var cb = callback;
|
|
var options = {};
|
|
if (typeof sql === "function") {
|
|
cb = sql;
|
|
} else if (typeof sql === "object") {
|
|
options = Object.create(sql);
|
|
if (typeof values === "function") {
|
|
cb = values;
|
|
} else if (values !== undefined) {
|
|
Object.defineProperty(options, "values", { value: values });
|
|
}
|
|
} else {
|
|
options.sql = sql;
|
|
if (typeof values === "function") {
|
|
cb = values;
|
|
} else if (values !== undefined) {
|
|
options.values = values;
|
|
}
|
|
}
|
|
if (cb !== undefined) {
|
|
cb = wrapCallbackInDomain(null, cb);
|
|
if (cb === undefined) {
|
|
throw new TypeError("argument callback must be a function when provided");
|
|
}
|
|
}
|
|
return new Query(options, cb);
|
|
};
|
|
Connection.prototype.connect = function connect(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
if (!this._connectCalled) {
|
|
this._connectCalled = true;
|
|
this._socket = this.config.socketPath ? Net.createConnection(this.config.socketPath) : Net.createConnection(this.config.port, this.config.host);
|
|
if (Events.usingDomains) {
|
|
this._socket.domain = this.domain;
|
|
}
|
|
var connection = this;
|
|
this._protocol.on("data", function(data) {
|
|
connection._socket.write(data);
|
|
});
|
|
this._socket.on("data", wrapToDomain(connection, function(data) {
|
|
connection._protocol.write(data);
|
|
}));
|
|
this._protocol.on("end", function() {
|
|
connection._socket.end();
|
|
});
|
|
this._socket.on("end", wrapToDomain(connection, function() {
|
|
connection._protocol.end();
|
|
}));
|
|
this._socket.on("error", this._handleNetworkError.bind(this));
|
|
this._socket.on("connect", this._handleProtocolConnect.bind(this));
|
|
this._protocol.on("handshake", this._handleProtocolHandshake.bind(this));
|
|
this._protocol.on("initialize", this._handleProtocolInitialize.bind(this));
|
|
this._protocol.on("unhandledError", this._handleProtocolError.bind(this));
|
|
this._protocol.on("drain", this._handleProtocolDrain.bind(this));
|
|
this._protocol.on("end", this._handleProtocolEnd.bind(this));
|
|
this._protocol.on("enqueue", this._handleProtocolEnqueue.bind(this));
|
|
if (this.config.connectTimeout) {
|
|
var handleConnectTimeout = this._handleConnectTimeout.bind(this);
|
|
this._socket.setTimeout(this.config.connectTimeout, handleConnectTimeout);
|
|
this._socket.once("connect", function() {
|
|
this.setTimeout(0, handleConnectTimeout);
|
|
});
|
|
}
|
|
}
|
|
this._protocol.handshake(options, wrapCallbackInDomain(this, callback));
|
|
};
|
|
Connection.prototype.changeUser = function changeUser(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
this._implyConnect();
|
|
var charsetNumber = options.charset ? ConnectionConfig.getCharsetNumber(options.charset) : this.config.charsetNumber;
|
|
return this._protocol.changeUser({
|
|
user: options.user || this.config.user,
|
|
password: options.password || this.config.password,
|
|
database: options.database || this.config.database,
|
|
timeout: options.timeout,
|
|
charsetNumber,
|
|
currentConfig: this.config
|
|
}, wrapCallbackInDomain(this, callback));
|
|
};
|
|
Connection.prototype.beginTransaction = function beginTransaction(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
options = options || {};
|
|
options.sql = "START TRANSACTION";
|
|
options.values = null;
|
|
return this.query(options, callback);
|
|
};
|
|
Connection.prototype.commit = function commit(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
options = options || {};
|
|
options.sql = "COMMIT";
|
|
options.values = null;
|
|
return this.query(options, callback);
|
|
};
|
|
Connection.prototype.rollback = function rollback(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
options = options || {};
|
|
options.sql = "ROLLBACK";
|
|
options.values = null;
|
|
return this.query(options, callback);
|
|
};
|
|
Connection.prototype.query = function query(sql, values, cb) {
|
|
var query = Connection.createQuery(sql, values, cb);
|
|
query._connection = this;
|
|
if (!(typeof sql === "object" && ("typeCast" in sql))) {
|
|
query.typeCast = this.config.typeCast;
|
|
}
|
|
if (query.sql) {
|
|
query.sql = this.format(query.sql, query.values);
|
|
}
|
|
if (query._callback) {
|
|
query._callback = wrapCallbackInDomain(this, query._callback);
|
|
}
|
|
this._implyConnect();
|
|
return this._protocol._enqueue(query);
|
|
};
|
|
Connection.prototype.ping = function ping(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
this._implyConnect();
|
|
this._protocol.ping(options, wrapCallbackInDomain(this, callback));
|
|
};
|
|
Connection.prototype.statistics = function statistics(options, callback) {
|
|
if (!callback && typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
this._implyConnect();
|
|
this._protocol.stats(options, wrapCallbackInDomain(this, callback));
|
|
};
|
|
Connection.prototype.end = function end(options, callback) {
|
|
var cb = callback;
|
|
var opts = options;
|
|
if (!callback && typeof options === "function") {
|
|
cb = options;
|
|
opts = null;
|
|
}
|
|
opts = Object.create(opts || null);
|
|
if (opts.timeout === undefined) {
|
|
opts.timeout = 30000;
|
|
}
|
|
this._implyConnect();
|
|
this._protocol.quit(opts, wrapCallbackInDomain(this, cb));
|
|
};
|
|
Connection.prototype.destroy = function() {
|
|
this.state = "disconnected";
|
|
this._implyConnect();
|
|
this._socket.destroy();
|
|
this._protocol.destroy();
|
|
};
|
|
Connection.prototype.pause = function() {
|
|
this._socket.pause();
|
|
this._protocol.pause();
|
|
};
|
|
Connection.prototype.resume = function() {
|
|
this._socket.resume();
|
|
this._protocol.resume();
|
|
};
|
|
Connection.prototype.escape = function(value) {
|
|
return SqlString.escape(value, false, this.config.timezone);
|
|
};
|
|
Connection.prototype.escapeId = function escapeId(value) {
|
|
return SqlString.escapeId(value, false);
|
|
};
|
|
Connection.prototype.format = function(sql, values) {
|
|
if (typeof this.config.queryFormat === "function") {
|
|
return this.config.queryFormat.call(this, sql, values, this.config.timezone);
|
|
}
|
|
return SqlString.format(sql, values, this.config.stringifyObjects, this.config.timezone);
|
|
};
|
|
if (tls.TLSSocket) {
|
|
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
|
var connection = this;
|
|
createSecureContext(this.config, function(err, secureContext) {
|
|
if (err) {
|
|
onSecure(err);
|
|
return;
|
|
}
|
|
connection._socket.removeAllListeners("data");
|
|
connection._protocol.removeAllListeners("data");
|
|
var rejectUnauthorized = connection.config.ssl.rejectUnauthorized;
|
|
var secureEstablished = false;
|
|
var secureSocket = new tls.TLSSocket(connection._socket, {
|
|
rejectUnauthorized,
|
|
requestCert: true,
|
|
secureContext,
|
|
isServer: false
|
|
});
|
|
secureSocket.on("_tlsError", function(err2) {
|
|
if (secureEstablished) {
|
|
connection._handleNetworkError(err2);
|
|
} else {
|
|
onSecure(err2);
|
|
}
|
|
});
|
|
secureSocket.pipe(connection._protocol);
|
|
connection._protocol.on("data", function(data) {
|
|
secureSocket.write(data);
|
|
});
|
|
secureSocket.on("secure", function() {
|
|
secureEstablished = true;
|
|
onSecure(rejectUnauthorized ? this.ssl.verifyError() : null);
|
|
});
|
|
secureSocket._start();
|
|
});
|
|
};
|
|
} else {
|
|
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
|
var connection = this;
|
|
var credentials = Crypto.createCredentials({
|
|
ca: this.config.ssl.ca,
|
|
cert: this.config.ssl.cert,
|
|
ciphers: this.config.ssl.ciphers,
|
|
key: this.config.ssl.key,
|
|
passphrase: this.config.ssl.passphrase
|
|
});
|
|
var rejectUnauthorized = this.config.ssl.rejectUnauthorized;
|
|
var secureEstablished = false;
|
|
var securePair = tls.createSecurePair(credentials, false, true, rejectUnauthorized);
|
|
securePair.on("error", function(err) {
|
|
if (secureEstablished) {
|
|
connection._handleNetworkError(err);
|
|
} else {
|
|
onSecure(err);
|
|
}
|
|
});
|
|
this._socket.removeAllListeners("data");
|
|
this._protocol.removeAllListeners("data");
|
|
securePair.encrypted.pipe(this._socket);
|
|
this._socket.on("data", function(data) {
|
|
securePair.encrypted.write(data);
|
|
});
|
|
securePair.cleartext.pipe(this._protocol);
|
|
this._protocol.on("data", function(data) {
|
|
securePair.cleartext.write(data);
|
|
});
|
|
securePair.on("secure", function() {
|
|
secureEstablished = true;
|
|
if (!rejectUnauthorized) {
|
|
onSecure();
|
|
return;
|
|
}
|
|
var verifyError = this.ssl.verifyError();
|
|
var err = verifyError;
|
|
if (typeof err === "string") {
|
|
err = new Error(verifyError);
|
|
err.code = verifyError;
|
|
}
|
|
onSecure(err);
|
|
});
|
|
securePair._cycle = securePair.cycle;
|
|
securePair.cycle = function cycle() {
|
|
if (this.ssl && this.ssl.error) {
|
|
this.error();
|
|
}
|
|
return this._cycle.apply(this, arguments);
|
|
};
|
|
};
|
|
}
|
|
Connection.prototype._handleConnectTimeout = function() {
|
|
if (this._socket) {
|
|
this._socket.setTimeout(0);
|
|
this._socket.destroy();
|
|
}
|
|
var err = new Error("connect ETIMEDOUT");
|
|
err.errorno = "ETIMEDOUT";
|
|
err.code = "ETIMEDOUT";
|
|
err.syscall = "connect";
|
|
this._handleNetworkError(err);
|
|
};
|
|
Connection.prototype._handleNetworkError = function(err) {
|
|
this._protocol.handleNetworkError(err);
|
|
};
|
|
Connection.prototype._handleProtocolError = function(err) {
|
|
this.state = "protocol_error";
|
|
this.emit("error", err);
|
|
};
|
|
Connection.prototype._handleProtocolDrain = function() {
|
|
this.emit("drain");
|
|
};
|
|
Connection.prototype._handleProtocolConnect = function() {
|
|
this.state = "connected";
|
|
this.emit("connect");
|
|
};
|
|
Connection.prototype._handleProtocolHandshake = function _handleProtocolHandshake() {
|
|
this.state = "authenticated";
|
|
};
|
|
Connection.prototype._handleProtocolInitialize = function _handleProtocolInitialize(packet) {
|
|
this.threadId = packet.threadId;
|
|
};
|
|
Connection.prototype._handleProtocolEnd = function(err) {
|
|
this.state = "disconnected";
|
|
this.emit("end", err);
|
|
};
|
|
Connection.prototype._handleProtocolEnqueue = function _handleProtocolEnqueue(sequence) {
|
|
this.emit("enqueue", sequence);
|
|
};
|
|
Connection.prototype._implyConnect = function() {
|
|
if (!this._connectCalled) {
|
|
this.connect();
|
|
}
|
|
};
|
|
function createSecureContext(config, cb) {
|
|
var context = null;
|
|
var error = null;
|
|
try {
|
|
context = tls.createSecureContext({
|
|
ca: config.ssl.ca,
|
|
cert: config.ssl.cert,
|
|
ciphers: config.ssl.ciphers,
|
|
key: config.ssl.key,
|
|
passphrase: config.ssl.passphrase
|
|
});
|
|
} catch (err) {
|
|
error = err;
|
|
}
|
|
cb(error, context);
|
|
}
|
|
function unwrapFromDomain(fn) {
|
|
return function() {
|
|
var domains = [];
|
|
var ret;
|
|
while (process.domain) {
|
|
domains.shift(process.domain);
|
|
process.domain.exit();
|
|
}
|
|
try {
|
|
ret = fn.apply(this, arguments);
|
|
} finally {
|
|
for (var i = 0;i < domains.length; i++) {
|
|
domains[i].enter();
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
function wrapCallbackInDomain(ee, fn) {
|
|
if (typeof fn !== "function") {
|
|
return;
|
|
}
|
|
if (fn.domain) {
|
|
return fn;
|
|
}
|
|
var domain = process.domain;
|
|
if (domain) {
|
|
return domain.bind(fn);
|
|
} else if (ee) {
|
|
return unwrapFromDomain(wrapToDomain(ee, fn));
|
|
} else {
|
|
return fn;
|
|
}
|
|
}
|
|
function wrapToDomain(ee, fn) {
|
|
return function() {
|
|
if (Events.usingDomains && ee.domain) {
|
|
ee.domain.enter();
|
|
fn.apply(this, arguments);
|
|
ee.domain.exit();
|
|
} else {
|
|
fn.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/PoolConnection.js
|
|
var require_PoolConnection = __commonJS((exports, module) => {
|
|
var inherits = __require("util").inherits;
|
|
var Connection = require_Connection();
|
|
var Events = __require("events");
|
|
module.exports = PoolConnection;
|
|
inherits(PoolConnection, Connection);
|
|
function PoolConnection(pool, options) {
|
|
Connection.call(this, options);
|
|
this._pool = pool;
|
|
if (Events.usingDomains) {
|
|
this.domain = pool.domain;
|
|
}
|
|
this.on("end", this._removeFromPool);
|
|
this.on("error", function(err) {
|
|
if (err.fatal) {
|
|
this._removeFromPool();
|
|
}
|
|
});
|
|
}
|
|
PoolConnection.prototype.release = function release() {
|
|
var pool = this._pool;
|
|
if (!pool || pool._closed) {
|
|
return;
|
|
}
|
|
return pool.releaseConnection(this);
|
|
};
|
|
PoolConnection.prototype._realEnd = Connection.prototype.end;
|
|
PoolConnection.prototype.end = function() {
|
|
console.warn("Calling conn.end() to release a pooled connection is " + "deprecated. In next version calling conn.end() will be " + "restored to default conn.end() behavior. Use " + "conn.release() instead.");
|
|
this.release();
|
|
};
|
|
PoolConnection.prototype.destroy = function() {
|
|
Connection.prototype.destroy.apply(this, arguments);
|
|
this._removeFromPool(this);
|
|
};
|
|
PoolConnection.prototype._removeFromPool = function _removeFromPool() {
|
|
if (!this._pool || this._pool._closed) {
|
|
return;
|
|
}
|
|
var pool = this._pool;
|
|
this._pool = null;
|
|
pool._purgeConnection(this);
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/Pool.js
|
|
var require_Pool = __commonJS((exports, module) => {
|
|
var mysql = require_mysql();
|
|
var Connection = require_Connection();
|
|
var EventEmitter = __require("events").EventEmitter;
|
|
var Util = __require("util");
|
|
var PoolConnection = require_PoolConnection();
|
|
module.exports = Pool;
|
|
Util.inherits(Pool, EventEmitter);
|
|
function Pool(options) {
|
|
EventEmitter.call(this);
|
|
this.config = options.config;
|
|
this.config.connectionConfig.pool = this;
|
|
this._acquiringConnections = [];
|
|
this._allConnections = [];
|
|
this._freeConnections = [];
|
|
this._connectionQueue = [];
|
|
this._closed = false;
|
|
}
|
|
Pool.prototype.getConnection = function(cb) {
|
|
if (this._closed) {
|
|
var err = new Error("Pool is closed.");
|
|
err.code = "POOL_CLOSED";
|
|
process.nextTick(function() {
|
|
cb(err);
|
|
});
|
|
return;
|
|
}
|
|
var connection;
|
|
var pool = this;
|
|
if (this._freeConnections.length > 0) {
|
|
connection = this._freeConnections.shift();
|
|
this.acquireConnection(connection, cb);
|
|
return;
|
|
}
|
|
if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) {
|
|
connection = new PoolConnection(this, { config: this.config.newConnectionConfig() });
|
|
this._acquiringConnections.push(connection);
|
|
this._allConnections.push(connection);
|
|
connection.connect({ timeout: this.config.acquireTimeout }, function onConnect(err2) {
|
|
spliceConnection(pool._acquiringConnections, connection);
|
|
if (pool._closed) {
|
|
err2 = new Error("Pool is closed.");
|
|
err2.code = "POOL_CLOSED";
|
|
}
|
|
if (err2) {
|
|
pool._purgeConnection(connection);
|
|
cb(err2);
|
|
return;
|
|
}
|
|
pool.emit("connection", connection);
|
|
pool.emit("acquire", connection);
|
|
cb(null, connection);
|
|
});
|
|
return;
|
|
}
|
|
if (!this.config.waitForConnections) {
|
|
process.nextTick(function() {
|
|
var err2 = new Error("No connections available.");
|
|
err2.code = "POOL_CONNLIMIT";
|
|
cb(err2);
|
|
});
|
|
return;
|
|
}
|
|
this._enqueueCallback(cb);
|
|
};
|
|
Pool.prototype.acquireConnection = function acquireConnection(connection, cb) {
|
|
if (connection._pool !== this) {
|
|
throw new Error("Connection acquired from wrong pool.");
|
|
}
|
|
var changeUser = this._needsChangeUser(connection);
|
|
var pool = this;
|
|
this._acquiringConnections.push(connection);
|
|
function onOperationComplete(err) {
|
|
spliceConnection(pool._acquiringConnections, connection);
|
|
if (pool._closed) {
|
|
err = new Error("Pool is closed.");
|
|
err.code = "POOL_CLOSED";
|
|
}
|
|
if (err) {
|
|
pool._connectionQueue.unshift(cb);
|
|
pool._purgeConnection(connection);
|
|
return;
|
|
}
|
|
if (changeUser) {
|
|
pool.emit("connection", connection);
|
|
}
|
|
pool.emit("acquire", connection);
|
|
cb(null, connection);
|
|
}
|
|
if (changeUser) {
|
|
connection.config = this.config.newConnectionConfig();
|
|
connection.changeUser({ timeout: this.config.acquireTimeout }, onOperationComplete);
|
|
} else {
|
|
connection.ping({ timeout: this.config.acquireTimeout }, onOperationComplete);
|
|
}
|
|
};
|
|
Pool.prototype.releaseConnection = function releaseConnection(connection) {
|
|
if (this._acquiringConnections.indexOf(connection) !== -1) {
|
|
return;
|
|
}
|
|
if (connection._pool) {
|
|
if (connection._pool !== this) {
|
|
throw new Error("Connection released to wrong pool");
|
|
}
|
|
if (this._freeConnections.indexOf(connection) !== -1) {
|
|
throw new Error("Connection already released");
|
|
} else {
|
|
this._freeConnections.push(connection);
|
|
this.emit("release", connection);
|
|
}
|
|
}
|
|
if (this._closed) {
|
|
this._connectionQueue.splice(0).forEach(function(cb) {
|
|
var err = new Error("Pool is closed.");
|
|
err.code = "POOL_CLOSED";
|
|
process.nextTick(function() {
|
|
cb(err);
|
|
});
|
|
});
|
|
} else if (this._connectionQueue.length) {
|
|
this.getConnection(this._connectionQueue.shift());
|
|
}
|
|
};
|
|
Pool.prototype.end = function(cb) {
|
|
this._closed = true;
|
|
if (typeof cb !== "function") {
|
|
cb = function(err) {
|
|
if (err)
|
|
throw err;
|
|
};
|
|
}
|
|
var calledBack = false;
|
|
var waitingClose = 0;
|
|
function onEnd(err) {
|
|
if (!calledBack && (err || --waitingClose <= 0)) {
|
|
calledBack = true;
|
|
cb(err);
|
|
}
|
|
}
|
|
while (this._allConnections.length !== 0) {
|
|
waitingClose++;
|
|
this._purgeConnection(this._allConnections[0], onEnd);
|
|
}
|
|
if (waitingClose === 0) {
|
|
process.nextTick(onEnd);
|
|
}
|
|
};
|
|
Pool.prototype.query = function(sql, values, cb) {
|
|
var query = Connection.createQuery(sql, values, cb);
|
|
if (!(typeof sql === "object" && ("typeCast" in sql))) {
|
|
query.typeCast = this.config.connectionConfig.typeCast;
|
|
}
|
|
if (this.config.connectionConfig.trace) {
|
|
query._callSite = new Error;
|
|
}
|
|
this.getConnection(function(err, conn) {
|
|
if (err) {
|
|
query.on("error", function() {
|
|
});
|
|
query.end(err);
|
|
return;
|
|
}
|
|
query.once("end", function() {
|
|
conn.release();
|
|
});
|
|
conn.query(query);
|
|
});
|
|
return query;
|
|
};
|
|
Pool.prototype._enqueueCallback = function _enqueueCallback(callback) {
|
|
if (this.config.queueLimit && this._connectionQueue.length >= this.config.queueLimit) {
|
|
process.nextTick(function() {
|
|
var err = new Error("Queue limit reached.");
|
|
err.code = "POOL_ENQUEUELIMIT";
|
|
callback(err);
|
|
});
|
|
return;
|
|
}
|
|
var cb = process.domain ? process.domain.bind(callback) : callback;
|
|
this._connectionQueue.push(cb);
|
|
this.emit("enqueue");
|
|
};
|
|
Pool.prototype._needsChangeUser = function _needsChangeUser(connection) {
|
|
var connConfig = connection.config;
|
|
var poolConfig = this.config.connectionConfig;
|
|
return connConfig.user !== poolConfig.user || connConfig.database !== poolConfig.database || connConfig.password !== poolConfig.password || connConfig.charsetNumber !== poolConfig.charsetNumber;
|
|
};
|
|
Pool.prototype._purgeConnection = function _purgeConnection(connection, callback) {
|
|
var cb = callback || function() {
|
|
};
|
|
if (connection.state === "disconnected") {
|
|
connection.destroy();
|
|
}
|
|
this._removeConnection(connection);
|
|
if (connection.state !== "disconnected" && !connection._protocol._quitSequence) {
|
|
connection._realEnd(cb);
|
|
return;
|
|
}
|
|
process.nextTick(cb);
|
|
};
|
|
Pool.prototype._removeConnection = function(connection) {
|
|
connection._pool = null;
|
|
spliceConnection(this._allConnections, connection);
|
|
spliceConnection(this._freeConnections, connection);
|
|
this.releaseConnection(connection);
|
|
};
|
|
Pool.prototype.escape = function(value) {
|
|
return mysql.escape(value, this.config.connectionConfig.stringifyObjects, this.config.connectionConfig.timezone);
|
|
};
|
|
Pool.prototype.escapeId = function escapeId(value) {
|
|
return mysql.escapeId(value, false);
|
|
};
|
|
function spliceConnection(array, connection) {
|
|
var index;
|
|
if ((index = array.indexOf(connection)) !== -1) {
|
|
array.splice(index, 1);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/lib/PoolConfig.js
|
|
var require_PoolConfig = __commonJS((exports, module) => {
|
|
var ConnectionConfig = require_ConnectionConfig();
|
|
module.exports = PoolConfig;
|
|
function PoolConfig(options) {
|
|
if (typeof options === "string") {
|
|
options = ConnectionConfig.parseUrl(options);
|
|
}
|
|
this.acquireTimeout = options.acquireTimeout === undefined ? 10 * 1000 : Number(options.acquireTimeout);
|
|
this.connectionConfig = new ConnectionConfig(options);
|
|
this.waitForConnections = options.waitForConnections === undefined ? true : Boolean(options.waitForConnections);
|
|
this.connectionLimit = options.connectionLimit === undefined ? 10 : Number(options.connectionLimit);
|
|
this.queueLimit = options.queueLimit === undefined ? 0 : Number(options.queueLimit);
|
|
}
|
|
PoolConfig.prototype.newConnectionConfig = function newConnectionConfig() {
|
|
var connectionConfig = new ConnectionConfig(this.connectionConfig);
|
|
connectionConfig.clientFlags = this.connectionConfig.clientFlags;
|
|
connectionConfig.maxPacketSize = this.connectionConfig.maxPacketSize;
|
|
return connectionConfig;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/PoolSelector.js
|
|
var require_PoolSelector = __commonJS((exports, module) => {
|
|
var PoolSelector = module.exports = {};
|
|
PoolSelector.RR = function PoolSelectorRoundRobin() {
|
|
var index = 0;
|
|
return function(clusterIds) {
|
|
if (index >= clusterIds.length) {
|
|
index = 0;
|
|
}
|
|
var clusterId = clusterIds[index++];
|
|
return clusterId;
|
|
};
|
|
};
|
|
PoolSelector.RANDOM = function PoolSelectorRandom() {
|
|
return function(clusterIds) {
|
|
return clusterIds[Math.floor(Math.random() * clusterIds.length)];
|
|
};
|
|
};
|
|
PoolSelector.ORDER = function PoolSelectorOrder() {
|
|
return function(clusterIds) {
|
|
return clusterIds[0];
|
|
};
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/PoolNamespace.js
|
|
var require_PoolNamespace = __commonJS((exports, module) => {
|
|
var Connection = require_Connection();
|
|
var PoolSelector = require_PoolSelector();
|
|
module.exports = PoolNamespace;
|
|
function PoolNamespace(cluster, pattern, selector) {
|
|
this._cluster = cluster;
|
|
this._pattern = pattern;
|
|
this._selector = new PoolSelector[selector];
|
|
}
|
|
PoolNamespace.prototype.getConnection = function(cb) {
|
|
var clusterNode = this._getClusterNode();
|
|
var cluster = this._cluster;
|
|
var namespace = this;
|
|
if (clusterNode === null) {
|
|
var err = null;
|
|
if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
|
|
err = new Error("Pool does not have online node.");
|
|
err.code = "POOL_NONEONLINE";
|
|
} else {
|
|
err = new Error("Pool does not exist.");
|
|
err.code = "POOL_NOEXIST";
|
|
}
|
|
cb(err);
|
|
return;
|
|
}
|
|
cluster._getConnection(clusterNode, function(err2, connection) {
|
|
var retry = err2 && cluster._canRetry && cluster._findNodeIds(namespace._pattern).length !== 0;
|
|
if (retry) {
|
|
namespace.getConnection(cb);
|
|
return;
|
|
}
|
|
if (err2) {
|
|
cb(err2);
|
|
return;
|
|
}
|
|
cb(null, connection);
|
|
});
|
|
};
|
|
PoolNamespace.prototype.query = function(sql, values, cb) {
|
|
var cluster = this._cluster;
|
|
var clusterNode = this._getClusterNode();
|
|
var query = Connection.createQuery(sql, values, cb);
|
|
var namespace = this;
|
|
if (clusterNode === null) {
|
|
var err = null;
|
|
if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
|
|
err = new Error("Pool does not have online node.");
|
|
err.code = "POOL_NONEONLINE";
|
|
} else {
|
|
err = new Error("Pool does not exist.");
|
|
err.code = "POOL_NOEXIST";
|
|
}
|
|
process.nextTick(function() {
|
|
query.on("error", function() {
|
|
});
|
|
query.end(err);
|
|
});
|
|
return query;
|
|
}
|
|
if (!(typeof sql === "object" && ("typeCast" in sql))) {
|
|
query.typeCast = clusterNode.pool.config.connectionConfig.typeCast;
|
|
}
|
|
if (clusterNode.pool.config.connectionConfig.trace) {
|
|
query._callSite = new Error;
|
|
}
|
|
cluster._getConnection(clusterNode, function(err2, conn) {
|
|
var retry = err2 && cluster._canRetry && cluster._findNodeIds(namespace._pattern).length !== 0;
|
|
if (retry) {
|
|
namespace.query(query);
|
|
return;
|
|
}
|
|
if (err2) {
|
|
query.on("error", function() {
|
|
});
|
|
query.end(err2);
|
|
return;
|
|
}
|
|
query.once("end", function() {
|
|
conn.release();
|
|
});
|
|
conn.query(query);
|
|
});
|
|
return query;
|
|
};
|
|
PoolNamespace.prototype._getClusterNode = function _getClusterNode() {
|
|
var foundNodeIds = this._cluster._findNodeIds(this._pattern);
|
|
var nodeId;
|
|
switch (foundNodeIds.length) {
|
|
case 0:
|
|
nodeId = null;
|
|
break;
|
|
case 1:
|
|
nodeId = foundNodeIds[0];
|
|
break;
|
|
default:
|
|
nodeId = this._selector(foundNodeIds);
|
|
break;
|
|
}
|
|
return nodeId !== null ? this._cluster._getNode(nodeId) : null;
|
|
};
|
|
});
|
|
|
|
// node_modules/mysql/lib/PoolCluster.js
|
|
var require_PoolCluster = __commonJS((exports, module) => {
|
|
var Pool = require_Pool();
|
|
var PoolConfig = require_PoolConfig();
|
|
var PoolNamespace = require_PoolNamespace();
|
|
var PoolSelector = require_PoolSelector();
|
|
var Util = __require("util");
|
|
var EventEmitter = __require("events").EventEmitter;
|
|
module.exports = PoolCluster;
|
|
function PoolCluster(config) {
|
|
EventEmitter.call(this);
|
|
config = config || {};
|
|
this._canRetry = typeof config.canRetry === "undefined" ? true : config.canRetry;
|
|
this._defaultSelector = config.defaultSelector || "RR";
|
|
this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
|
|
this._restoreNodeTimeout = config.restoreNodeTimeout || 0;
|
|
this._closed = false;
|
|
this._findCaches = Object.create(null);
|
|
this._lastId = 0;
|
|
this._namespaces = Object.create(null);
|
|
this._nodes = Object.create(null);
|
|
}
|
|
Util.inherits(PoolCluster, EventEmitter);
|
|
PoolCluster.prototype.add = function add(id, config) {
|
|
if (this._closed) {
|
|
throw new Error("PoolCluster is closed.");
|
|
}
|
|
var nodeId = typeof id === "object" ? "CLUSTER::" + ++this._lastId : String(id);
|
|
if (this._nodes[nodeId] !== undefined) {
|
|
throw new Error('Node ID "' + nodeId + '" is already defined in PoolCluster.');
|
|
}
|
|
var poolConfig = typeof id !== "object" ? new PoolConfig(config) : new PoolConfig(id);
|
|
this._nodes[nodeId] = {
|
|
id: nodeId,
|
|
errorCount: 0,
|
|
pool: new Pool({ config: poolConfig }),
|
|
_offlineUntil: 0
|
|
};
|
|
this._clearFindCaches();
|
|
};
|
|
PoolCluster.prototype.end = function end(callback) {
|
|
var cb = callback !== undefined ? callback : _cb;
|
|
if (typeof cb !== "function") {
|
|
throw TypeError("callback argument must be a function");
|
|
}
|
|
if (this._closed) {
|
|
process.nextTick(cb);
|
|
return;
|
|
}
|
|
this._closed = true;
|
|
var calledBack = false;
|
|
var nodeIds = Object.keys(this._nodes);
|
|
var waitingClose = 0;
|
|
function onEnd(err) {
|
|
if (!calledBack && (err || --waitingClose <= 0)) {
|
|
calledBack = true;
|
|
cb(err);
|
|
}
|
|
}
|
|
for (var i = 0;i < nodeIds.length; i++) {
|
|
var nodeId = nodeIds[i];
|
|
var node = this._nodes[nodeId];
|
|
waitingClose++;
|
|
node.pool.end(onEnd);
|
|
}
|
|
if (waitingClose === 0) {
|
|
process.nextTick(onEnd);
|
|
}
|
|
};
|
|
PoolCluster.prototype.of = function(pattern, selector) {
|
|
pattern = pattern || "*";
|
|
selector = selector || this._defaultSelector;
|
|
selector = selector.toUpperCase();
|
|
if (typeof PoolSelector[selector] === "undefined") {
|
|
selector = this._defaultSelector;
|
|
}
|
|
var key = pattern + selector;
|
|
if (typeof this._namespaces[key] === "undefined") {
|
|
this._namespaces[key] = new PoolNamespace(this, pattern, selector);
|
|
}
|
|
return this._namespaces[key];
|
|
};
|
|
PoolCluster.prototype.remove = function remove(pattern) {
|
|
var foundNodeIds = this._findNodeIds(pattern, true);
|
|
for (var i = 0;i < foundNodeIds.length; i++) {
|
|
var node = this._getNode(foundNodeIds[i]);
|
|
if (node) {
|
|
this._removeNode(node);
|
|
}
|
|
}
|
|
};
|
|
PoolCluster.prototype.getConnection = function(pattern, selector, cb) {
|
|
var namespace;
|
|
if (typeof pattern === "function") {
|
|
cb = pattern;
|
|
namespace = this.of();
|
|
} else {
|
|
if (typeof selector === "function") {
|
|
cb = selector;
|
|
selector = this._defaultSelector;
|
|
}
|
|
namespace = this.of(pattern, selector);
|
|
}
|
|
namespace.getConnection(cb);
|
|
};
|
|
PoolCluster.prototype._clearFindCaches = function _clearFindCaches() {
|
|
this._findCaches = Object.create(null);
|
|
};
|
|
PoolCluster.prototype._decreaseErrorCount = function _decreaseErrorCount(node) {
|
|
var errorCount = node.errorCount;
|
|
if (errorCount > this._removeNodeErrorCount) {
|
|
errorCount = this._removeNodeErrorCount;
|
|
}
|
|
if (errorCount < 1) {
|
|
errorCount = 1;
|
|
}
|
|
node.errorCount = errorCount - 1;
|
|
if (node._offlineUntil) {
|
|
node._offlineUntil = 0;
|
|
this.emit("online", node.id);
|
|
}
|
|
};
|
|
PoolCluster.prototype._findNodeIds = function _findNodeIds(pattern, includeOffline) {
|
|
var currentTime = 0;
|
|
var foundNodeIds = this._findCaches[pattern];
|
|
if (foundNodeIds === undefined) {
|
|
var expression = patternRegExp(pattern);
|
|
var nodeIds = Object.keys(this._nodes);
|
|
foundNodeIds = nodeIds.filter(function(id) {
|
|
return id.match(expression);
|
|
});
|
|
this._findCaches[pattern] = foundNodeIds;
|
|
}
|
|
if (includeOffline) {
|
|
return foundNodeIds;
|
|
}
|
|
return foundNodeIds.filter(function(nodeId) {
|
|
var node = this._getNode(nodeId);
|
|
if (!node._offlineUntil) {
|
|
return true;
|
|
}
|
|
if (!currentTime) {
|
|
currentTime = getMonotonicMilliseconds();
|
|
}
|
|
return node._offlineUntil <= currentTime;
|
|
}, this);
|
|
};
|
|
PoolCluster.prototype._getNode = function _getNode(id) {
|
|
return this._nodes[id] || null;
|
|
};
|
|
PoolCluster.prototype._increaseErrorCount = function _increaseErrorCount(node) {
|
|
var errorCount = ++node.errorCount;
|
|
if (this._removeNodeErrorCount > errorCount) {
|
|
return;
|
|
}
|
|
if (this._restoreNodeTimeout > 0) {
|
|
node._offlineUntil = getMonotonicMilliseconds() + this._restoreNodeTimeout;
|
|
this.emit("offline", node.id);
|
|
return;
|
|
}
|
|
this._removeNode(node);
|
|
this.emit("remove", node.id);
|
|
};
|
|
PoolCluster.prototype._getConnection = function(node, cb) {
|
|
var self2 = this;
|
|
node.pool.getConnection(function(err, connection) {
|
|
if (err) {
|
|
self2._increaseErrorCount(node);
|
|
cb(err);
|
|
return;
|
|
} else {
|
|
self2._decreaseErrorCount(node);
|
|
}
|
|
connection._clusterId = node.id;
|
|
cb(null, connection);
|
|
});
|
|
};
|
|
PoolCluster.prototype._removeNode = function _removeNode(node) {
|
|
delete this._nodes[node.id];
|
|
this._clearFindCaches();
|
|
node.pool.end(_noop);
|
|
};
|
|
function getMonotonicMilliseconds() {
|
|
var ms;
|
|
if (typeof process.hrtime === "function") {
|
|
ms = process.hrtime();
|
|
ms = ms[0] * 1000 + ms[1] * 0.000001;
|
|
} else {
|
|
ms = process.uptime() * 1000;
|
|
}
|
|
return Math.floor(ms);
|
|
}
|
|
function isRegExp(val) {
|
|
return typeof val === "object" && Object.prototype.toString.call(val) === "[object RegExp]";
|
|
}
|
|
function patternRegExp(pattern) {
|
|
if (isRegExp(pattern)) {
|
|
return pattern;
|
|
}
|
|
var source = pattern.replace(/([.+?^=!:${}()|\[\]\/\\])/g, "\\$1").replace(/\*/g, ".*");
|
|
return new RegExp("^" + source + "$");
|
|
}
|
|
function _cb(err) {
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
}
|
|
function _noop() {
|
|
}
|
|
});
|
|
|
|
// node_modules/mysql/index.js
|
|
var require_mysql = __commonJS((exports) => {
|
|
var Classes = Object.create(null);
|
|
exports.createConnection = function createConnection(config) {
|
|
var Connection = loadClass("Connection");
|
|
var ConnectionConfig = loadClass("ConnectionConfig");
|
|
return new Connection({ config: new ConnectionConfig(config) });
|
|
};
|
|
exports.createPool = function createPool(config) {
|
|
var Pool = loadClass("Pool");
|
|
var PoolConfig = loadClass("PoolConfig");
|
|
return new Pool({ config: new PoolConfig(config) });
|
|
};
|
|
exports.createPoolCluster = function createPoolCluster(config) {
|
|
var PoolCluster = loadClass("PoolCluster");
|
|
return new PoolCluster(config);
|
|
};
|
|
exports.createQuery = function createQuery(sql, values, callback) {
|
|
var Connection = loadClass("Connection");
|
|
return Connection.createQuery(sql, values, callback);
|
|
};
|
|
exports.escape = function escape(value, stringifyObjects, timeZone) {
|
|
var SqlString = loadClass("SqlString");
|
|
return SqlString.escape(value, stringifyObjects, timeZone);
|
|
};
|
|
exports.escapeId = function escapeId(value, forbidQualified) {
|
|
var SqlString = loadClass("SqlString");
|
|
return SqlString.escapeId(value, forbidQualified);
|
|
};
|
|
exports.format = function format(sql, values, stringifyObjects, timeZone) {
|
|
var SqlString = loadClass("SqlString");
|
|
return SqlString.format(sql, values, stringifyObjects, timeZone);
|
|
};
|
|
exports.raw = function raw(sql) {
|
|
var SqlString = loadClass("SqlString");
|
|
return SqlString.raw(sql);
|
|
};
|
|
Object.defineProperty(exports, "Types", {
|
|
get: loadClass.bind(null, "Types")
|
|
});
|
|
function loadClass(className) {
|
|
var Class = Classes[className];
|
|
if (Class !== undefined) {
|
|
return Class;
|
|
}
|
|
switch (className) {
|
|
case "Connection":
|
|
Class = require_Connection();
|
|
break;
|
|
case "ConnectionConfig":
|
|
Class = require_ConnectionConfig();
|
|
break;
|
|
case "Pool":
|
|
Class = require_Pool();
|
|
break;
|
|
case "PoolCluster":
|
|
Class = require_PoolCluster();
|
|
break;
|
|
case "PoolConfig":
|
|
Class = require_PoolConfig();
|
|
break;
|
|
case "SqlString":
|
|
Class = require_SqlString();
|
|
break;
|
|
case "Types":
|
|
Class = require_types();
|
|
break;
|
|
default:
|
|
throw new Error("Cannot find class \'" + className + "\'");
|
|
}
|
|
Classes[className] = Class;
|
|
return Class;
|
|
}
|
|
});
|
|
|
|
// node_modules/serverless-mysql/index.js
|
|
var require_serverless_mysql = __commonJS((exports, module) => {
|
|
var NodeURL = __require("url");
|
|
module.exports = (params) => {
|
|
let client = null;
|
|
let counter = 0;
|
|
let errors = 0;
|
|
let retries = 0;
|
|
let _cfg = {};
|
|
let _maxConns = { updated: 0 };
|
|
let _usedConns = { updated: 0 };
|
|
const tooManyConnsErrors = [
|
|
"ER_TOO_MANY_USER_CONNECTIONS",
|
|
"ER_CON_COUNT_ERROR",
|
|
"ER_USER_LIMIT_REACHED",
|
|
"ER_OUT_OF_RESOURCES",
|
|
"PROTOCOL_CONNECTION_LOST",
|
|
"PROTOCOL_SEQUENCE_TIMEOUT",
|
|
"ETIMEDOUT"
|
|
];
|
|
let MYSQL, manageConns, cap, base, maxRetries, connUtilization, backoff, zombieMinTimeout, zombieMaxTimeout, maxConnsFreq, usedConnsFreq, onConnect, onConnectError, onRetry, onClose, onError, onKill, onKillError, PromiseLibrary;
|
|
const getCounter = () => counter;
|
|
const incCounter = () => counter++;
|
|
const resetCounter = () => counter = 0;
|
|
const getClient = () => client;
|
|
const resetClient = () => client = null;
|
|
const resetRetries = () => retries = 0;
|
|
const getErrorCount = () => errors;
|
|
const getConfig = () => _cfg;
|
|
const config = (args) => {
|
|
if (typeof args === "string") {
|
|
return Object.assign(_cfg, uriToConnectionConfig(args));
|
|
}
|
|
return Object.assign(_cfg, args);
|
|
};
|
|
const delay = (ms) => new PromiseLibrary((res) => setTimeout(res, ms));
|
|
const randRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
|
|
const fullJitter = () => randRange(0, Math.min(cap, base * 2 ** retries));
|
|
const decorrelatedJitter = (sleep = 0) => Math.min(cap, randRange(base, sleep * 3));
|
|
const uriToConnectionConfig = (connectionString) => {
|
|
let uri = undefined;
|
|
try {
|
|
uri = new NodeURL.URL(connectionString);
|
|
} catch (error) {
|
|
throw new Error("Invalid data source URL provided");
|
|
}
|
|
const extraFields = {};
|
|
for (const [name, value] of uri.searchParams) {
|
|
extraFields[name] = value;
|
|
}
|
|
const database = uri.pathname && uri.pathname.startsWith("/") ? uri.pathname.slice(1) : undefined;
|
|
const connectionFields = {
|
|
host: uri.hostname ? uri.hostname : undefined,
|
|
user: uri.username ? uri.username : undefined,
|
|
port: uri.port ? Number(uri.port) : undefined,
|
|
password: uri.password ? uri.password : undefined,
|
|
database
|
|
};
|
|
return Object.assign(connectionFields, extraFields);
|
|
};
|
|
const connect = async (wait) => {
|
|
try {
|
|
await _connect();
|
|
} catch (e) {
|
|
if (tooManyConnsErrors.includes(e.code) && retries < maxRetries) {
|
|
retries++;
|
|
wait = Number.isInteger(wait) ? wait : 0;
|
|
let sleep = backoff === "decorrelated" ? decorrelatedJitter(wait) : typeof backoff === "function" ? backoff(wait, retries) : fullJitter();
|
|
onRetry(e, retries, sleep, typeof backoff === "function" ? "custom" : backoff);
|
|
await delay(sleep).then(() => connect(sleep));
|
|
} else {
|
|
onConnectError(e);
|
|
throw new Error(e);
|
|
}
|
|
}
|
|
};
|
|
const _connect = () => {
|
|
if (client === null) {
|
|
resetCounter();
|
|
return new PromiseLibrary((resolve, reject) => {
|
|
client = MYSQL.createConnection(_cfg);
|
|
client.connect(function(err) {
|
|
if (err) {
|
|
resetClient();
|
|
reject(err);
|
|
} else {
|
|
resetRetries();
|
|
onConnect(client);
|
|
return resolve(true);
|
|
}
|
|
});
|
|
client.on("error", async (err) => {
|
|
errors++;
|
|
resetClient();
|
|
resetCounter();
|
|
onError(err);
|
|
});
|
|
});
|
|
} else {
|
|
return PromiseLibrary.resolve();
|
|
}
|
|
};
|
|
const end = async () => {
|
|
if (client !== null && manageConns) {
|
|
incCounter();
|
|
let maxConns = await getMaxConnections();
|
|
let usedConns = await getTotalConnections();
|
|
if (usedConns.total / maxConns.total > connUtilization) {
|
|
let timeout = Math.min(Math.max(usedConns.maxAge, zombieMinTimeout), zombieMaxTimeout);
|
|
let killedZombies = timeout <= usedConns.maxAge ? await killZombieConnections(timeout) : 0;
|
|
if (killedZombies === 0) {
|
|
quit();
|
|
}
|
|
} else if (usedConns.maxAge > zombieMaxTimeout) {
|
|
await killZombieConnections(zombieMaxTimeout);
|
|
}
|
|
}
|
|
};
|
|
const quit = () => {
|
|
if (client !== null) {
|
|
client.end();
|
|
resetClient();
|
|
resetCounter();
|
|
onClose();
|
|
}
|
|
};
|
|
const query = async function(...args) {
|
|
await connect();
|
|
return new PromiseLibrary((resolve, reject) => {
|
|
if (client !== null) {
|
|
if (this && this.rollback && args.length === 0) {
|
|
return resolve([]);
|
|
}
|
|
client.query(...args, async (err, results) => {
|
|
if (err && err.code === "PROTOCOL_SEQUENCE_TIMEOUT") {
|
|
client.destroy();
|
|
resetClient();
|
|
reject(err);
|
|
} else if (err && (/^PROTOCOL_ENQUEUE_AFTER_/.test(err.code) || err.code === "PROTOCOL_CONNECTION_LOST" || err.code === "EPIPE" || err.code === "ECONNRESET")) {
|
|
resetClient();
|
|
return resolve(query(...args));
|
|
} else if (err) {
|
|
if (this && this.rollback) {
|
|
await query("ROLLBACK");
|
|
this.rollback(err);
|
|
}
|
|
reject(err);
|
|
}
|
|
return resolve(results);
|
|
});
|
|
}
|
|
});
|
|
};
|
|
const getMaxConnections = async () => {
|
|
if (Date.now() - _maxConns.updated > maxConnsFreq) {
|
|
let results = await query(`SELECT IF(@@max_user_connections > 0,
|
|
LEAST(@@max_user_connections,@@max_connections),
|
|
@@max_connections) AS total,
|
|
IF(@@max_user_connections > 0,true,false) AS userLimit`);
|
|
_maxConns = {
|
|
total: results[0].total || 0,
|
|
userLimit: results[0].userLimit === 1 ? true : false,
|
|
updated: Date.now()
|
|
};
|
|
}
|
|
return _maxConns;
|
|
};
|
|
const getTotalConnections = async () => {
|
|
if (Date.now() - _usedConns.updated > usedConnsFreq) {
|
|
let results = await query(`SELECT COUNT(ID) as total, MAX(time) as max_age
|
|
FROM information_schema.processlist
|
|
WHERE (user = ? AND @@max_user_connections > 0) OR true`, [_cfg.user]);
|
|
_usedConns = {
|
|
total: results[0].total || 0,
|
|
maxAge: results[0].max_age || 0,
|
|
updated: Date.now()
|
|
};
|
|
}
|
|
return _usedConns;
|
|
};
|
|
const killZombieConnections = async (timeout) => {
|
|
let killedZombies = 0;
|
|
let zombies = await query(`SELECT ID,time FROM information_schema.processlist
|
|
WHERE command = 'Sleep' AND time >= ? AND user = ?
|
|
ORDER BY time DESC`, [!isNaN(timeout) ? timeout : 60 * 15, _cfg.user]);
|
|
for (let i = 0;i < zombies.length; i++) {
|
|
try {
|
|
await query("KILL ?", zombies[i].ID);
|
|
onKill(zombies[i]);
|
|
killedZombies++;
|
|
} catch (e) {
|
|
onKillError(e);
|
|
}
|
|
}
|
|
return killedZombies;
|
|
};
|
|
const transaction = () => {
|
|
let queries = [];
|
|
let rollback = () => {
|
|
};
|
|
return {
|
|
query: function(...args) {
|
|
if (typeof args[0] === "function") {
|
|
queries.push(args[0]);
|
|
} else {
|
|
queries.push(() => [...args]);
|
|
}
|
|
return this;
|
|
},
|
|
rollback: function(fn) {
|
|
if (typeof fn === "function") {
|
|
rollback = fn;
|
|
}
|
|
return this;
|
|
},
|
|
commit: async function() {
|
|
return await commit(queries, rollback);
|
|
}
|
|
};
|
|
};
|
|
const commit = async (queries, rollback) => {
|
|
let results = [];
|
|
await query("START TRANSACTION");
|
|
for (let i = 0;i < queries.length; i++) {
|
|
let result = await query.apply({ rollback }, queries[i](results[results.length - 1], results));
|
|
results.push(result);
|
|
}
|
|
await query("COMMIT");
|
|
return results;
|
|
};
|
|
const cfg = typeof params === "object" && !Array.isArray(params) ? params : {};
|
|
MYSQL = cfg.library || require_mysql();
|
|
PromiseLibrary = cfg.promise || Promise;
|
|
manageConns = cfg.manageConns === false ? false : true;
|
|
cap = Number.isInteger(cfg.cap) ? cfg.cap : 100;
|
|
base = Number.isInteger(cfg.base) ? cfg.base : 2;
|
|
maxRetries = Number.isInteger(cfg.maxRetries) ? cfg.maxRetries : 50;
|
|
backoff = typeof cfg.backoff === "function" ? cfg.backoff : cfg.backoff && ["full", "decorrelated"].includes(cfg.backoff.toLowerCase()) ? cfg.backoff.toLowerCase() : "full";
|
|
connUtilization = !isNaN(cfg.connUtilization) ? cfg.connUtilization : 0.8;
|
|
zombieMinTimeout = Number.isInteger(cfg.zombieMinTimeout) ? cfg.zombieMinTimeout : 3;
|
|
zombieMaxTimeout = Number.isInteger(cfg.zombieMaxTimeout) ? cfg.zombieMaxTimeout : 60 * 15;
|
|
maxConnsFreq = Number.isInteger(cfg.maxConnsFreq) ? cfg.maxConnsFreq : 15 * 1000;
|
|
usedConnsFreq = Number.isInteger(cfg.usedConnsFreq) ? cfg.usedConnsFreq : 0;
|
|
onConnect = typeof cfg.onConnect === "function" ? cfg.onConnect : () => {
|
|
};
|
|
onConnectError = typeof cfg.onConnectError === "function" ? cfg.onConnectError : () => {
|
|
};
|
|
onRetry = typeof cfg.onRetry === "function" ? cfg.onRetry : () => {
|
|
};
|
|
onClose = typeof cfg.onClose === "function" ? cfg.onClose : () => {
|
|
};
|
|
onError = typeof cfg.onError === "function" ? cfg.onError : () => {
|
|
};
|
|
onKill = typeof cfg.onKill === "function" ? cfg.onKill : () => {
|
|
};
|
|
onKillError = typeof cfg.onKillError === "function" ? cfg.onKillError : () => {
|
|
};
|
|
let connCfg = {};
|
|
if (typeof cfg.config === "object" && !Array.isArray(cfg.config)) {
|
|
connCfg = cfg.config;
|
|
} else if (typeof params === "string") {
|
|
connCfg = params;
|
|
}
|
|
let escape = MYSQL.escape;
|
|
let escapeId = MYSQL.escapeId;
|
|
let format = MYSQL.format;
|
|
config(connCfg);
|
|
return {
|
|
connect,
|
|
config,
|
|
query,
|
|
end,
|
|
escape,
|
|
escapeId,
|
|
format,
|
|
quit,
|
|
transaction,
|
|
getCounter,
|
|
getClient,
|
|
getConfig,
|
|
getErrorCount
|
|
};
|
|
};
|
|
});
|
|
|
|
// package-shared/utils/backend/grabDbSSL.ts
|
|
import fs2 from "fs";
|
|
function grabDbSSL() {
|
|
const SSL_DIR = process.env.DSQL_SSL_DIR;
|
|
if (!SSL_DIR?.match(/./)) {
|
|
return;
|
|
}
|
|
const caFilePath = `${SSL_DIR}/ca-cert.pem`;
|
|
if (!fs2.existsSync(caFilePath)) {
|
|
console.log(`${caFilePath} does not exist`);
|
|
return;
|
|
}
|
|
return {
|
|
ca: fs2.readFileSync(`${SSL_DIR}/ca-cert.pem`)
|
|
};
|
|
}
|
|
var init_grabDbSSL = () => {
|
|
};
|
|
|
|
// package-shared/utils/backend/global-db/DSQL_USER_DB_HANDLER.ts
|
|
import fs3 from "fs";
|
|
function DSQL_USER_DB_HANDLER({
|
|
paradigm,
|
|
database,
|
|
queryString,
|
|
queryValues
|
|
}) {
|
|
try {
|
|
return new Promise((resolve, reject) => {
|
|
const fullAccess = paradigm?.match(/full.access|^fa$/i) ? true : false;
|
|
try {
|
|
let runQuery = function(results) {
|
|
DSQL_USER.end();
|
|
resolve(JSON.parse(JSON.stringify(results)));
|
|
}, queryError = function(err) {
|
|
DSQL_USER.end();
|
|
resolve({
|
|
error: err.message,
|
|
queryStringGenerated: queryString,
|
|
queryValuesGenerated: queryValues,
|
|
sql: err.sql
|
|
});
|
|
};
|
|
if (fullAccess) {
|
|
DSQL_USER = import_serverless_mysql.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_FULL_ACCESS_USERNAME,
|
|
password: process.env.DSQL_DB_FULL_ACCESS_PASSWORD,
|
|
database,
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
} else {
|
|
DSQL_USER = import_serverless_mysql.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_READ_ONLY_USERNAME,
|
|
password: process.env.DSQL_DB_READ_ONLY_PASSWORD,
|
|
database,
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
}
|
|
if (queryValues && Array.isArray(queryValues) && queryValues[0]) {
|
|
DSQL_USER.query(queryString, queryValues).then(runQuery).catch(queryError);
|
|
} else {
|
|
DSQL_USER.query(queryString).then(runQuery).catch(queryError);
|
|
}
|
|
} catch (error) {
|
|
fs3.appendFileSync("./.tmp/dbErrorLogs.txt", error.message + "\n" + Date() + "\n\n\n", "utf8");
|
|
resolve({
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
var import_serverless_mysql, DSQL_USER;
|
|
var init_DSQL_USER_DB_HANDLER = __esm(() => {
|
|
import_serverless_mysql = __toESM(require_serverless_mysql(), 1);
|
|
init_grabDbSSL();
|
|
DSQL_USER = import_serverless_mysql.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_READ_ONLY_USERNAME,
|
|
password: process.env.DSQL_DB_READ_ONLY_PASSWORD,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
module_DSQL_USER_DB_HANDLER.exports = DSQL_USER_DB_HANDLER;
|
|
});
|
|
|
|
// package-shared/utils/backend/global-db/LOCAL_DB_HANDLER.ts
|
|
async function LOCAL_DB_HANDLER(...args) {
|
|
const MASTER = import_serverless_mysql2.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_USERNAME,
|
|
password: process.env.DSQL_DB_PASSWORD,
|
|
database: process.env.DSQL_DB_NAME,
|
|
port: process.env.DSQL_DB_PORT ? Number(process.env.DSQL_DB_PORT) : undefined,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
},
|
|
onConnect: () => {
|
|
console.log("Connection Successful!");
|
|
},
|
|
onConnectError: (err) => {
|
|
console.log("Connection Error", err.message);
|
|
},
|
|
onError: (err) => {
|
|
console.log("Client Error", err.message);
|
|
}
|
|
});
|
|
console.log("Querying ...");
|
|
try {
|
|
const results = await MASTER.query(...args);
|
|
await MASTER.end();
|
|
return JSON.parse(JSON.stringify(results));
|
|
} catch (error) {
|
|
console.log("DB Error =>", error.message);
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
var import_serverless_mysql2;
|
|
var init_LOCAL_DB_HANDLER = __esm(() => {
|
|
import_serverless_mysql2 = __toESM(require_serverless_mysql(), 1);
|
|
init_grabDbSSL();
|
|
});
|
|
|
|
// package-shared/functions/dsql/decrypt.ts
|
|
var exports_decrypt = {};
|
|
__export(exports_decrypt, {
|
|
default: () => decrypt
|
|
});
|
|
import { scryptSync, createDecipheriv } from "crypto";
|
|
import { Buffer as Buffer2 } from "buffer";
|
|
function decrypt({
|
|
encryptedString,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
}) {
|
|
if (!encryptedString?.match(/./)) {
|
|
console.log("Encrypted string is invalid");
|
|
return encryptedString;
|
|
}
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
const finalKeyLen = process.env.DSQL_ENCRYPTION_KEY_LENGTH ? Number(process.env.DSQL_ENCRYPTION_KEY_LENGTH) : 24;
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
console.log("Decrption key is invalid");
|
|
return encryptedString;
|
|
}
|
|
if (!finalEncryptionSalt?.match(/.{8,}/)) {
|
|
console.log("Decrption salt is invalid");
|
|
return encryptedString;
|
|
}
|
|
const algorithm = "aes-192-cbc";
|
|
let key = scryptSync(finalEncryptionKey, finalEncryptionSalt, finalKeyLen);
|
|
let iv = Buffer2.alloc(16, 0);
|
|
const decipher = createDecipheriv(algorithm, key, iv);
|
|
try {
|
|
let decrypted = decipher.update(encryptedString, "hex", "utf8");
|
|
decrypted += decipher.final("utf8");
|
|
return decrypted;
|
|
} catch (error) {
|
|
console.log("Error in decrypting =>", error.message);
|
|
return encryptedString;
|
|
}
|
|
}
|
|
var init_decrypt = () => {
|
|
};
|
|
|
|
// package-shared/functions/backend/defaultFieldsRegexp.ts
|
|
var defaultFieldsRegexp, defaultFieldsRegexp_default;
|
|
var init_defaultFieldsRegexp = __esm(() => {
|
|
defaultFieldsRegexp = /^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
|
|
defaultFieldsRegexp_default = defaultFieldsRegexp;
|
|
});
|
|
|
|
// package-shared/functions/backend/parseDbResults.ts
|
|
async function parseDbResults({
|
|
unparsedResults,
|
|
tableSchema
|
|
}) {
|
|
let parsedResults = [];
|
|
try {
|
|
for (let pr = 0;pr < unparsedResults.length; pr++) {
|
|
let result = unparsedResults[pr];
|
|
let resultFieldNames = Object.keys(result);
|
|
for (let i = 0;i < resultFieldNames.length; i++) {
|
|
const resultFieldName = resultFieldNames[i];
|
|
let resultFieldSchema = tableSchema?.fields[i];
|
|
if (resultFieldName?.match(defaultFieldsRegexp_default)) {
|
|
continue;
|
|
}
|
|
let value = result[resultFieldName];
|
|
if (typeof value !== "number" && !value) {
|
|
continue;
|
|
}
|
|
if (resultFieldSchema?.encrypted) {
|
|
if (value?.match(/./)) {
|
|
result[resultFieldName] = decrypt({
|
|
encryptedString: value
|
|
});
|
|
}
|
|
}
|
|
}
|
|
parsedResults.push(result);
|
|
}
|
|
return parsedResults;
|
|
} catch (error) {
|
|
console.log("ERROR in parseDbResults Function =>", error.message);
|
|
return unparsedResults;
|
|
}
|
|
}
|
|
var init_parseDbResults = __esm(() => {
|
|
init_decrypt();
|
|
init_defaultFieldsRegexp();
|
|
});
|
|
|
|
// node_modules/entities/lib/generated/decode-data-html.js
|
|
var require_decode_data_html = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = new Uint16Array('\u1D41<\xD5\u0131\u028A\u049D\u057B\u05D0\u0675\u06DE\u07A2\u07D6\u080F\u0A4A\u0A91\u0DA1\u0E6D\u0F09\u0F26\u10CA\u1228\u12E1\u1415\u149D\u14C3\u14DF\u1525\0\0\0\0\0\0\u156B\u16CD\u198D\u1C12\u1DDD\u1F7E\u2060\u21B0\u228D\u23C0\u23FB\u2442\u2824\u2912\u2D08\u2E48\u2FCE\u3016\u32BA\u3639\u37AC\u38FE\u3A28\u3A71\u3AE0\u3B2E\u0800EMabcfglmnoprstu\\bfms\x7F\x84\x8B\x90\x95\x98\xA6\xB3\xB9\xC8\xCFlig\u803B\xC6\u40C6P\u803B&\u4026cute\u803B\xC1\u40C1reve;\u4102\u0100iyx}rc\u803B\xC2\u40C2;\u4410r;\uC000\uD835\uDD04rave\u803B\xC0\u40C0pha;\u4391acr;\u4100d;\u6A53\u0100gp\x9D\xA1on;\u4104f;\uC000\uD835\uDD38plyFunction;\u6061ing\u803B\xC5\u40C5\u0100cs\xBE\xC3r;\uC000\uD835\uDC9Cign;\u6254ilde\u803B\xC3\u40C3ml\u803B\xC4\u40C4\u0400aceforsu\xE5\xFB\xFE\u0117\u011C\u0122\u0127\u012A\u0100cr\xEA\xF2kslash;\u6216\u0176\xF6\xF8;\u6AE7ed;\u6306y;\u4411\u0180crt\u0105\u010B\u0114ause;\u6235noullis;\u612Ca;\u4392r;\uC000\uD835\uDD05pf;\uC000\uD835\uDD39eve;\u42D8c\xF2\u0113mpeq;\u624E\u0700HOacdefhilorsu\u014D\u0151\u0156\u0180\u019E\u01A2\u01B5\u01B7\u01BA\u01DC\u0215\u0273\u0278\u027Ecy;\u4427PY\u803B\xA9\u40A9\u0180cpy\u015D\u0162\u017Aute;\u4106\u0100;i\u0167\u0168\u62D2talDifferentialD;\u6145leys;\u612D\u0200aeio\u0189\u018E\u0194\u0198ron;\u410Cdil\u803B\xC7\u40C7rc;\u4108nint;\u6230ot;\u410A\u0100dn\u01A7\u01ADilla;\u40B8terDot;\u40B7\xF2\u017Fi;\u43A7rcle\u0200DMPT\u01C7\u01CB\u01D1\u01D6ot;\u6299inus;\u6296lus;\u6295imes;\u6297o\u0100cs\u01E2\u01F8kwiseContourIntegral;\u6232eCurly\u0100DQ\u0203\u020FoubleQuote;\u601Duote;\u6019\u0200lnpu\u021E\u0228\u0247\u0255on\u0100;e\u0225\u0226\u6237;\u6A74\u0180git\u022F\u0236\u023Aruent;\u6261nt;\u622FourIntegral;\u622E\u0100fr\u024C\u024E;\u6102oduct;\u6210nterClockwiseContourIntegral;\u6233oss;\u6A2Fcr;\uC000\uD835\uDC9Ep\u0100;C\u0284\u0285\u62D3ap;\u624D\u0580DJSZacefios\u02A0\u02AC\u02B0\u02B4\u02B8\u02CB\u02D7\u02E1\u02E6\u0333\u048D\u0100;o\u0179\u02A5trahd;\u6911cy;\u4402cy;\u4405cy;\u440F\u0180grs\u02BF\u02C4\u02C7ger;\u6021r;\u61A1hv;\u6AE4\u0100ay\u02D0\u02D5ron;\u410E;\u4414l\u0100;t\u02DD\u02DE\u6207a;\u4394r;\uC000\uD835\uDD07\u0100af\u02EB\u0327\u0100cm\u02F0\u0322ritical\u0200ADGT\u0300\u0306\u0316\u031Ccute;\u40B4o\u0174\u030B\u030D;\u42D9bleAcute;\u42DDrave;\u4060ilde;\u42DCond;\u62C4ferentialD;\u6146\u0470\u033D\0\0\0\u0342\u0354\0\u0405f;\uC000\uD835\uDD3B\u0180;DE\u0348\u0349\u034D\u40A8ot;\u60DCqual;\u6250ble\u0300CDLRUV\u0363\u0372\u0382\u03CF\u03E2\u03F8ontourIntegra\xEC\u0239o\u0274\u0379\0\0\u037B\xBB\u0349nArrow;\u61D3\u0100eo\u0387\u03A4ft\u0180ART\u0390\u0396\u03A1rrow;\u61D0ightArrow;\u61D4e\xE5\u02CAng\u0100LR\u03AB\u03C4eft\u0100AR\u03B3\u03B9rrow;\u67F8ightArrow;\u67FAightArrow;\u67F9ight\u0100AT\u03D8\u03DErrow;\u61D2ee;\u62A8p\u0241\u03E9\0\0\u03EFrrow;\u61D1ownArrow;\u61D5erticalBar;\u6225n\u0300ABLRTa\u0412\u042A\u0430\u045E\u047F\u037Crrow\u0180;BU\u041D\u041E\u0422\u6193ar;\u6913pArrow;\u61F5reve;\u4311eft\u02D2\u043A\0\u0446\0\u0450ightVector;\u6950eeVector;\u695Eector\u0100;B\u0459\u045A\u61BDar;\u6956ight\u01D4\u0467\0\u0471eeVector;\u695Fector\u0100;B\u047A\u047B\u61C1ar;\u6957ee\u0100;A\u0486\u0487\u62A4rrow;\u61A7\u0100ct\u0492\u0497r;\uC000\uD835\uDC9Frok;\u4110\u0800NTacdfglmopqstux\u04BD\u04C0\u04C4\u04CB\u04DE\u04E2\u04E7\u04EE\u04F5\u0521\u052F\u0536\u0552\u055D\u0560\u0565G;\u414AH\u803B\xD0\u40D0cute\u803B\xC9\u40C9\u0180aiy\u04D2\u04D7\u04DCron;\u411Arc\u803B\xCA\u40CA;\u442Dot;\u4116r;\uC000\uD835\uDD08rave\u803B\xC8\u40C8ement;\u6208\u0100ap\u04FA\u04FEcr;\u4112ty\u0253\u0506\0\0\u0512mallSquare;\u65FBerySmallSquare;\u65AB\u0100gp\u0526\u052Aon;\u4118f;\uC000\uD835\uDD3Csilon;\u4395u\u0100ai\u053C\u0549l\u0100;T\u0542\u0543\u6A75ilde;\u6242librium;\u61CC\u0100ci\u0557\u055Ar;\u6130m;\u6A73a;\u4397ml\u803B\xCB\u40CB\u0100ip\u056A\u056Fsts;\u6203onentialE;\u6147\u0280cfios\u0585\u0588\u058D\u05B2\u05CCy;\u4424r;\uC000\uD835\uDD09lled\u0253\u0597\0\0\u05A3mallSquare;\u65FCerySmallSquare;\u65AA\u0370\u05BA\0\u05BF\0\0\u05C4f;\uC000\uD835\uDD3DAll;\u6200riertrf;\u6131c\xF2\u05CB\u0600JTabcdfgorst\u05E8\u05EC\u05EF\u05FA\u0600\u0612\u0616\u061B\u061D\u0623\u066C\u0672cy;\u4403\u803B>\u403Emma\u0100;d\u05F7\u05F8\u4393;\u43DCreve;\u411E\u0180eiy\u0607\u060C\u0610dil;\u4122rc;\u411C;\u4413ot;\u4120r;\uC000\uD835\uDD0A;\u62D9pf;\uC000\uD835\uDD3Eeater\u0300EFGLST\u0635\u0644\u064E\u0656\u065B\u0666qual\u0100;L\u063E\u063F\u6265ess;\u62DBullEqual;\u6267reater;\u6AA2ess;\u6277lantEqual;\u6A7Eilde;\u6273cr;\uC000\uD835\uDCA2;\u626B\u0400Aacfiosu\u0685\u068B\u0696\u069B\u069E\u06AA\u06BE\u06CARDcy;\u442A\u0100ct\u0690\u0694ek;\u42C7;\u405Eirc;\u4124r;\u610ClbertSpace;\u610B\u01F0\u06AF\0\u06B2f;\u610DizontalLine;\u6500\u0100ct\u06C3\u06C5\xF2\u06A9rok;\u4126mp\u0144\u06D0\u06D8ownHum\xF0\u012Fqual;\u624F\u0700EJOacdfgmnostu\u06FA\u06FE\u0703\u0707\u070E\u071A\u071E\u0721\u0728\u0744\u0778\u078B\u078F\u0795cy;\u4415lig;\u4132cy;\u4401cute\u803B\xCD\u40CD\u0100iy\u0713\u0718rc\u803B\xCE\u40CE;\u4418ot;\u4130r;\u6111rave\u803B\xCC\u40CC\u0180;ap\u0720\u072F\u073F\u0100cg\u0734\u0737r;\u412AinaryI;\u6148lie\xF3\u03DD\u01F4\u0749\0\u0762\u0100;e\u074D\u074E\u622C\u0100gr\u0753\u0758ral;\u622Bsection;\u62C2isible\u0100CT\u076C\u0772omma;\u6063imes;\u6062\u0180gpt\u077F\u0783\u0788on;\u412Ef;\uC000\uD835\uDD40a;\u4399cr;\u6110ilde;\u4128\u01EB\u079A\0\u079Ecy;\u4406l\u803B\xCF\u40CF\u0280cfosu\u07AC\u07B7\u07BC\u07C2\u07D0\u0100iy\u07B1\u07B5rc;\u4134;\u4419r;\uC000\uD835\uDD0Dpf;\uC000\uD835\uDD41\u01E3\u07C7\0\u07CCr;\uC000\uD835\uDCA5rcy;\u4408kcy;\u4404\u0380HJacfos\u07E4\u07E8\u07EC\u07F1\u07FD\u0802\u0808cy;\u4425cy;\u440Cppa;\u439A\u0100ey\u07F6\u07FBdil;\u4136;\u441Ar;\uC000\uD835\uDD0Epf;\uC000\uD835\uDD42cr;\uC000\uD835\uDCA6\u0580JTaceflmost\u0825\u0829\u082C\u0850\u0863\u09B3\u09B8\u09C7\u09CD\u0A37\u0A47cy;\u4409\u803B<\u403C\u0280cmnpr\u0837\u083C\u0841\u0844\u084Dute;\u4139bda;\u439Bg;\u67EAlacetrf;\u6112r;\u619E\u0180aey\u0857\u085C\u0861ron;\u413Ddil;\u413B;\u441B\u0100fs\u0868\u0970t\u0500ACDFRTUVar\u087E\u08A9\u08B1\u08E0\u08E6\u08FC\u092F\u095B\u0390\u096A\u0100nr\u0883\u088FgleBracket;\u67E8row\u0180;BR\u0899\u089A\u089E\u6190ar;\u61E4ightArrow;\u61C6eiling;\u6308o\u01F5\u08B7\0\u08C3bleBracket;\u67E6n\u01D4\u08C8\0\u08D2eeVector;\u6961ector\u0100;B\u08DB\u08DC\u61C3ar;\u6959loor;\u630Aight\u0100AV\u08EF\u08F5rrow;\u6194ector;\u694E\u0100er\u0901\u0917e\u0180;AV\u0909\u090A\u0910\u62A3rrow;\u61A4ector;\u695Aiangle\u0180;BE\u0924\u0925\u0929\u62B2ar;\u69CFqual;\u62B4p\u0180DTV\u0937\u0942\u094CownVector;\u6951eeVector;\u6960ector\u0100;B\u0956\u0957\u61BFar;\u6958ector\u0100;B\u0965\u0966\u61BCar;\u6952ight\xE1\u039Cs\u0300EFGLST\u097E\u098B\u0995\u099D\u09A2\u09ADqualGreater;\u62DAullEqual;\u6266reater;\u6276ess;\u6AA1lantEqual;\u6A7Dilde;\u6272r;\uC000\uD835\uDD0F\u0100;e\u09BD\u09BE\u62D8ftarrow;\u61DAidot;\u413F\u0180npw\u09D4\u0A16\u0A1Bg\u0200LRlr\u09DE\u09F7\u0A02\u0A10eft\u0100AR\u09E6\u09ECrrow;\u67F5ightArrow;\u67F7ightArrow;\u67F6eft\u0100ar\u03B3\u0A0Aight\xE1\u03BFight\xE1\u03CAf;\uC000\uD835\uDD43er\u0100LR\u0A22\u0A2CeftArrow;\u6199ightArrow;\u6198\u0180cht\u0A3E\u0A40\u0A42\xF2\u084C;\u61B0rok;\u4141;\u626A\u0400acefiosu\u0A5A\u0A5D\u0A60\u0A77\u0A7C\u0A85\u0A8B\u0A8Ep;\u6905y;\u441C\u0100dl\u0A65\u0A6FiumSpace;\u605Flintrf;\u6133r;\uC000\uD835\uDD10nusPlus;\u6213pf;\uC000\uD835\uDD44c\xF2\u0A76;\u439C\u0480Jacefostu\u0AA3\u0AA7\u0AAD\u0AC0\u0B14\u0B19\u0D91\u0D97\u0D9Ecy;\u440Acute;\u4143\u0180aey\u0AB4\u0AB9\u0ABEron;\u4147dil;\u4145;\u441D\u0180gsw\u0AC7\u0AF0\u0B0Eative\u0180MTV\u0AD3\u0ADF\u0AE8ediumSpace;\u600Bhi\u0100cn\u0AE6\u0AD8\xEB\u0AD9eryThi\xEE\u0AD9ted\u0100GL\u0AF8\u0B06reaterGreate\xF2\u0673essLes\xF3\u0A48Line;\u400Ar;\uC000\uD835\uDD11\u0200Bnpt\u0B22\u0B28\u0B37\u0B3Areak;\u6060BreakingSpace;\u40A0f;\u6115\u0680;CDEGHLNPRSTV\u0B55\u0B56\u0B6A\u0B7C\u0BA1\u0BEB\u0C04\u0C5E\u0C84\u0CA6\u0CD8\u0D61\u0D85\u6AEC\u0100ou\u0B5B\u0B64ngruent;\u6262pCap;\u626DoubleVerticalBar;\u6226\u0180lqx\u0B83\u0B8A\u0B9Bement;\u6209ual\u0100;T\u0B92\u0B93\u6260ilde;\uC000\u2242\u0338ists;\u6204reater\u0380;EFGLST\u0BB6\u0BB7\u0BBD\u0BC9\u0BD3\u0BD8\u0BE5\u626Fqual;\u6271ullEqual;\uC000\u2267\u0338reater;\uC000\u226B\u0338ess;\u6279lantEqual;\uC000\u2A7E\u0338ilde;\u6275ump\u0144\u0BF2\u0BFDownHump;\uC000\u224E\u0338qual;\uC000\u224F\u0338e\u0100fs\u0C0A\u0C27tTriangle\u0180;BE\u0C1A\u0C1B\u0C21\u62EAar;\uC000\u29CF\u0338qual;\u62ECs\u0300;EGLST\u0C35\u0C36\u0C3C\u0C44\u0C4B\u0C58\u626Equal;\u6270reater;\u6278ess;\uC000\u226A\u0338lantEqual;\uC000\u2A7D\u0338ilde;\u6274ested\u0100GL\u0C68\u0C79reaterGreater;\uC000\u2AA2\u0338essLess;\uC000\u2AA1\u0338recedes\u0180;ES\u0C92\u0C93\u0C9B\u6280qual;\uC000\u2AAF\u0338lantEqual;\u62E0\u0100ei\u0CAB\u0CB9verseElement;\u620CghtTriangle\u0180;BE\u0CCB\u0CCC\u0CD2\u62EBar;\uC000\u29D0\u0338qual;\u62ED\u0100qu\u0CDD\u0D0CuareSu\u0100bp\u0CE8\u0CF9set\u0100;E\u0CF0\u0CF3\uC000\u228F\u0338qual;\u62E2erset\u0100;E\u0D03\u0D06\uC000\u2290\u0338qual;\u62E3\u0180bcp\u0D13\u0D24\u0D4Eset\u0100;E\u0D1B\u0D1E\uC000\u2282\u20D2qual;\u6288ceeds\u0200;EST\u0D32\u0D33\u0D3B\u0D46\u6281qual;\uC000\u2AB0\u0338lantEqual;\u62E1ilde;\uC000\u227F\u0338erset\u0100;E\u0D58\u0D5B\uC000\u2283\u20D2qual;\u6289ilde\u0200;EFT\u0D6E\u0D6F\u0D75\u0D7F\u6241qual;\u6244ullEqual;\u6247ilde;\u6249erticalBar;\u6224cr;\uC000\uD835\uDCA9ilde\u803B\xD1\u40D1;\u439D\u0700Eacdfgmoprstuv\u0DBD\u0DC2\u0DC9\u0DD5\u0DDB\u0DE0\u0DE7\u0DFC\u0E02\u0E20\u0E22\u0E32\u0E3F\u0E44lig;\u4152cute\u803B\xD3\u40D3\u0100iy\u0DCE\u0DD3rc\u803B\xD4\u40D4;\u441Eblac;\u4150r;\uC000\uD835\uDD12rave\u803B\xD2\u40D2\u0180aei\u0DEE\u0DF2\u0DF6cr;\u414Cga;\u43A9cron;\u439Fpf;\uC000\uD835\uDD46enCurly\u0100DQ\u0E0E\u0E1AoubleQuote;\u601Cuote;\u6018;\u6A54\u0100cl\u0E27\u0E2Cr;\uC000\uD835\uDCAAash\u803B\xD8\u40D8i\u016C\u0E37\u0E3Cde\u803B\xD5\u40D5es;\u6A37ml\u803B\xD6\u40D6er\u0100BP\u0E4B\u0E60\u0100ar\u0E50\u0E53r;\u603Eac\u0100ek\u0E5A\u0E5C;\u63DEet;\u63B4arenthesis;\u63DC\u0480acfhilors\u0E7F\u0E87\u0E8A\u0E8F\u0E92\u0E94\u0E9D\u0EB0\u0EFCrtialD;\u6202y;\u441Fr;\uC000\uD835\uDD13i;\u43A6;\u43A0usMinus;\u40B1\u0100ip\u0EA2\u0EADncareplan\xE5\u069Df;\u6119\u0200;eio\u0EB9\u0EBA\u0EE0\u0EE4\u6ABBcedes\u0200;EST\u0EC8\u0EC9\u0ECF\u0EDA\u627Aqual;\u6AAFlantEqual;\u627Cilde;\u627Eme;\u6033\u0100dp\u0EE9\u0EEEuct;\u620Fortion\u0100;a\u0225\u0EF9l;\u621D\u0100ci\u0F01\u0F06r;\uC000\uD835\uDCAB;\u43A8\u0200Ufos\u0F11\u0F16\u0F1B\u0F1FOT\u803B"\u4022r;\uC000\uD835\uDD14pf;\u611Acr;\uC000\uD835\uDCAC\u0600BEacefhiorsu\u0F3E\u0F43\u0F47\u0F60\u0F73\u0FA7\u0FAA\u0FAD\u1096\u10A9\u10B4\u10BEarr;\u6910G\u803B\xAE\u40AE\u0180cnr\u0F4E\u0F53\u0F56ute;\u4154g;\u67EBr\u0100;t\u0F5C\u0F5D\u61A0l;\u6916\u0180aey\u0F67\u0F6C\u0F71ron;\u4158dil;\u4156;\u4420\u0100;v\u0F78\u0F79\u611Cerse\u0100EU\u0F82\u0F99\u0100lq\u0F87\u0F8Eement;\u620Builibrium;\u61CBpEquilibrium;\u696Fr\xBB\u0F79o;\u43A1ght\u0400ACDFTUVa\u0FC1\u0FEB\u0FF3\u1022\u1028\u105B\u1087\u03D8\u0100nr\u0FC6\u0FD2gleBracket;\u67E9row\u0180;BL\u0FDC\u0FDD\u0FE1\u6192ar;\u61E5eftArrow;\u61C4eiling;\u6309o\u01F5\u0FF9\0\u1005bleBracket;\u67E7n\u01D4\u100A\0\u1014eeVector;\u695Dector\u0100;B\u101D\u101E\u61C2ar;\u6955loor;\u630B\u0100er\u102D\u1043e\u0180;AV\u1035\u1036\u103C\u62A2rrow;\u61A6ector;\u695Biangle\u0180;BE\u1050\u1051\u1055\u62B3ar;\u69D0qual;\u62B5p\u0180DTV\u1063\u106E\u1078ownVector;\u694FeeVector;\u695Cector\u0100;B\u1082\u1083\u61BEar;\u6954ector\u0100;B\u1091\u1092\u61C0ar;\u6953\u0100pu\u109B\u109Ef;\u611DndImplies;\u6970ightarrow;\u61DB\u0100ch\u10B9\u10BCr;\u611B;\u61B1leDelayed;\u69F4\u0680HOacfhimoqstu\u10E4\u10F1\u10F7\u10FD\u1119\u111E\u1151\u1156\u1161\u1167\u11B5\u11BB\u11BF\u0100Cc\u10E9\u10EEHcy;\u4429y;\u4428FTcy;\u442Ccute;\u415A\u0280;aeiy\u1108\u1109\u110E\u1113\u1117\u6ABCron;\u4160dil;\u415Erc;\u415C;\u4421r;\uC000\uD835\uDD16ort\u0200DLRU\u112A\u1134\u113E\u1149ownArrow\xBB\u041EeftArrow\xBB\u089AightArrow\xBB\u0FDDpArrow;\u6191gma;\u43A3allCircle;\u6218pf;\uC000\uD835\uDD4A\u0272\u116D\0\0\u1170t;\u621Aare\u0200;ISU\u117B\u117C\u1189\u11AF\u65A1ntersection;\u6293u\u0100bp\u118F\u119Eset\u0100;E\u1197\u1198\u628Fqual;\u6291erset\u0100;E\u11A8\u11A9\u6290qual;\u6292nion;\u6294cr;\uC000\uD835\uDCAEar;\u62C6\u0200bcmp\u11C8\u11DB\u1209\u120B\u0100;s\u11CD\u11CE\u62D0et\u0100;E\u11CD\u11D5qual;\u6286\u0100ch\u11E0\u1205eeds\u0200;EST\u11ED\u11EE\u11F4\u11FF\u627Bqual;\u6AB0lantEqual;\u627Dilde;\u627FTh\xE1\u0F8C;\u6211\u0180;es\u1212\u1213\u1223\u62D1rset\u0100;E\u121C\u121D\u6283qual;\u6287et\xBB\u1213\u0580HRSacfhiors\u123E\u1244\u1249\u1255\u125E\u1271\u1276\u129F\u12C2\u12C8\u12D1ORN\u803B\xDE\u40DEADE;\u6122\u0100Hc\u124E\u1252cy;\u440By;\u4426\u0100bu\u125A\u125C;\u4009;\u43A4\u0180aey\u1265\u126A\u126Fron;\u4164dil;\u4162;\u4422r;\uC000\uD835\uDD17\u0100ei\u127B\u1289\u01F2\u1280\0\u1287efore;\u6234a;\u4398\u0100cn\u128E\u1298kSpace;\uC000\u205F\u200ASpace;\u6009lde\u0200;EFT\u12AB\u12AC\u12B2\u12BC\u623Cqual;\u6243ullEqual;\u6245ilde;\u6248pf;\uC000\uD835\uDD4BipleDot;\u60DB\u0100ct\u12D6\u12DBr;\uC000\uD835\uDCAFrok;\u4166\u0AE1\u12F7\u130E\u131A\u1326\0\u132C\u1331\0\0\0\0\0\u1338\u133D\u1377\u1385\0\u13FF\u1404\u140A\u1410\u0100cr\u12FB\u1301ute\u803B\xDA\u40DAr\u0100;o\u1307\u1308\u619Fcir;\u6949r\u01E3\u1313\0\u1316y;\u440Eve;\u416C\u0100iy\u131E\u1323rc\u803B\xDB\u40DB;\u4423blac;\u4170r;\uC000\uD835\uDD18rave\u803B\xD9\u40D9acr;\u416A\u0100di\u1341\u1369er\u0100BP\u1348\u135D\u0100ar\u134D\u1350r;\u405Fac\u0100ek\u1357\u1359;\u63DFet;\u63B5arenthesis;\u63DDon\u0100;P\u1370\u1371\u62C3lus;\u628E\u0100gp\u137B\u137Fon;\u4172f;\uC000\uD835\uDD4C\u0400ADETadps\u1395\u13AE\u13B8\u13C4\u03E8\u13D2\u13D7\u13F3rrow\u0180;BD\u1150\u13A0\u13A4ar;\u6912ownArrow;\u61C5ownArrow;\u6195quilibrium;\u696Eee\u0100;A\u13CB\u13CC\u62A5rrow;\u61A5own\xE1\u03F3er\u0100LR\u13DE\u13E8eftArrow;\u6196ightArrow;\u6197i\u0100;l\u13F9\u13FA\u43D2on;\u43A5ing;\u416Ecr;\uC000\uD835\uDCB0ilde;\u4168ml\u803B\xDC\u40DC\u0480Dbcdefosv\u1427\u142C\u1430\u1433\u143E\u1485\u148A\u1490\u1496ash;\u62ABar;\u6AEBy;\u4412ash\u0100;l\u143B\u143C\u62A9;\u6AE6\u0100er\u1443\u1445;\u62C1\u0180bty\u144C\u1450\u147Aar;\u6016\u0100;i\u144F\u1455cal\u0200BLST\u1461\u1465\u146A\u1474ar;\u6223ine;\u407Ceparator;\u6758ilde;\u6240ThinSpace;\u600Ar;\uC000\uD835\uDD19pf;\uC000\uD835\uDD4Dcr;\uC000\uD835\uDCB1dash;\u62AA\u0280cefos\u14A7\u14AC\u14B1\u14B6\u14BCirc;\u4174dge;\u62C0r;\uC000\uD835\uDD1Apf;\uC000\uD835\uDD4Ecr;\uC000\uD835\uDCB2\u0200fios\u14CB\u14D0\u14D2\u14D8r;\uC000\uD835\uDD1B;\u439Epf;\uC000\uD835\uDD4Fcr;\uC000\uD835\uDCB3\u0480AIUacfosu\u14F1\u14F5\u14F9\u14FD\u1504\u150F\u1514\u151A\u1520cy;\u442Fcy;\u4407cy;\u442Ecute\u803B\xDD\u40DD\u0100iy\u1509\u150Drc;\u4176;\u442Br;\uC000\uD835\uDD1Cpf;\uC000\uD835\uDD50cr;\uC000\uD835\uDCB4ml;\u4178\u0400Hacdefos\u1535\u1539\u153F\u154B\u154F\u155D\u1560\u1564cy;\u4416cute;\u4179\u0100ay\u1544\u1549ron;\u417D;\u4417ot;\u417B\u01F2\u1554\0\u155BoWidt\xE8\u0AD9a;\u4396r;\u6128pf;\u6124cr;\uC000\uD835\uDCB5\u0BE1\u1583\u158A\u1590\0\u15B0\u15B6\u15BF\0\0\0\0\u15C6\u15DB\u15EB\u165F\u166D\0\u1695\u169B\u16B2\u16B9\0\u16BEcute\u803B\xE1\u40E1reve;\u4103\u0300;Ediuy\u159C\u159D\u15A1\u15A3\u15A8\u15AD\u623E;\uC000\u223E\u0333;\u623Frc\u803B\xE2\u40E2te\u80BB\xB4\u0306;\u4430lig\u803B\xE6\u40E6\u0100;r\xB2\u15BA;\uC000\uD835\uDD1Erave\u803B\xE0\u40E0\u0100ep\u15CA\u15D6\u0100fp\u15CF\u15D4sym;\u6135\xE8\u15D3ha;\u43B1\u0100ap\u15DFc\u0100cl\u15E4\u15E7r;\u4101g;\u6A3F\u0264\u15F0\0\0\u160A\u0280;adsv\u15FA\u15FB\u15FF\u1601\u1607\u6227nd;\u6A55;\u6A5Clope;\u6A58;\u6A5A\u0380;elmrsz\u1618\u1619\u161B\u161E\u163F\u164F\u1659\u6220;\u69A4e\xBB\u1619sd\u0100;a\u1625\u1626\u6221\u0461\u1630\u1632\u1634\u1636\u1638\u163A\u163C\u163E;\u69A8;\u69A9;\u69AA;\u69AB;\u69AC;\u69AD;\u69AE;\u69AFt\u0100;v\u1645\u1646\u621Fb\u0100;d\u164C\u164D\u62BE;\u699D\u0100pt\u1654\u1657h;\u6222\xBB\xB9arr;\u637C\u0100gp\u1663\u1667on;\u4105f;\uC000\uD835\uDD52\u0380;Eaeiop\u12C1\u167B\u167D\u1682\u1684\u1687\u168A;\u6A70cir;\u6A6F;\u624Ad;\u624Bs;\u4027rox\u0100;e\u12C1\u1692\xF1\u1683ing\u803B\xE5\u40E5\u0180cty\u16A1\u16A6\u16A8r;\uC000\uD835\uDCB6;\u402Amp\u0100;e\u12C1\u16AF\xF1\u0288ilde\u803B\xE3\u40E3ml\u803B\xE4\u40E4\u0100ci\u16C2\u16C8onin\xF4\u0272nt;\u6A11\u0800Nabcdefiklnoprsu\u16ED\u16F1\u1730\u173C\u1743\u1748\u1778\u177D\u17E0\u17E6\u1839\u1850\u170D\u193D\u1948\u1970ot;\u6AED\u0100cr\u16F6\u171Ek\u0200ceps\u1700\u1705\u170D\u1713ong;\u624Cpsilon;\u43F6rime;\u6035im\u0100;e\u171A\u171B\u623Dq;\u62CD\u0176\u1722\u1726ee;\u62BDed\u0100;g\u172C\u172D\u6305e\xBB\u172Drk\u0100;t\u135C\u1737brk;\u63B6\u0100oy\u1701\u1741;\u4431quo;\u601E\u0280cmprt\u1753\u175B\u1761\u1764\u1768aus\u0100;e\u010A\u0109ptyv;\u69B0s\xE9\u170Cno\xF5\u0113\u0180ahw\u176F\u1771\u1773;\u43B2;\u6136een;\u626Cr;\uC000\uD835\uDD1Fg\u0380costuvw\u178D\u179D\u17B3\u17C1\u17D5\u17DB\u17DE\u0180aiu\u1794\u1796\u179A\xF0\u0760rc;\u65EFp\xBB\u1371\u0180dpt\u17A4\u17A8\u17ADot;\u6A00lus;\u6A01imes;\u6A02\u0271\u17B9\0\0\u17BEcup;\u6A06ar;\u6605riangle\u0100du\u17CD\u17D2own;\u65BDp;\u65B3plus;\u6A04e\xE5\u1444\xE5\u14ADarow;\u690D\u0180ako\u17ED\u1826\u1835\u0100cn\u17F2\u1823k\u0180lst\u17FA\u05AB\u1802ozenge;\u69EBriangle\u0200;dlr\u1812\u1813\u1818\u181D\u65B4own;\u65BEeft;\u65C2ight;\u65B8k;\u6423\u01B1\u182B\0\u1833\u01B2\u182F\0\u1831;\u6592;\u65914;\u6593ck;\u6588\u0100eo\u183E\u184D\u0100;q\u1843\u1846\uC000=\u20E5uiv;\uC000\u2261\u20E5t;\u6310\u0200ptwx\u1859\u185E\u1867\u186Cf;\uC000\uD835\uDD53\u0100;t\u13CB\u1863om\xBB\u13CCtie;\u62C8\u0600DHUVbdhmptuv\u1885\u1896\u18AA\u18BB\u18D7\u18DB\u18EC\u18FF\u1905\u190A\u1910\u1921\u0200LRlr\u188E\u1890\u1892\u1894;\u6557;\u6554;\u6556;\u6553\u0280;DUdu\u18A1\u18A2\u18A4\u18A6\u18A8\u6550;\u6566;\u6569;\u6564;\u6567\u0200LRlr\u18B3\u18B5\u18B7\u18B9;\u655D;\u655A;\u655C;\u6559\u0380;HLRhlr\u18CA\u18CB\u18CD\u18CF\u18D1\u18D3\u18D5\u6551;\u656C;\u6563;\u6560;\u656B;\u6562;\u655Fox;\u69C9\u0200LRlr\u18E4\u18E6\u18E8\u18EA;\u6555;\u6552;\u6510;\u650C\u0280;DUdu\u06BD\u18F7\u18F9\u18FB\u18FD;\u6565;\u6568;\u652C;\u6534inus;\u629Flus;\u629Eimes;\u62A0\u0200LRlr\u1919\u191B\u191D\u191F;\u655B;\u6558;\u6518;\u6514\u0380;HLRhlr\u1930\u1931\u1933\u1935\u1937\u1939\u193B\u6502;\u656A;\u6561;\u655E;\u653C;\u6524;\u651C\u0100ev\u0123\u1942bar\u803B\xA6\u40A6\u0200ceio\u1951\u1956\u195A\u1960r;\uC000\uD835\uDCB7mi;\u604Fm\u0100;e\u171A\u171Cl\u0180;bh\u1968\u1969\u196B\u405C;\u69C5sub;\u67C8\u016C\u1974\u197El\u0100;e\u1979\u197A\u6022t\xBB\u197Ap\u0180;Ee\u012F\u1985\u1987;\u6AAE\u0100;q\u06DC\u06DB\u0CE1\u19A7\0\u19E8\u1A11\u1A15\u1A32\0\u1A37\u1A50\0\0\u1AB4\0\0\u1AC1\0\0\u1B21\u1B2E\u1B4D\u1B52\0\u1BFD\0\u1C0C\u0180cpr\u19AD\u19B2\u19DDute;\u4107\u0300;abcds\u19BF\u19C0\u19C4\u19CA\u19D5\u19D9\u6229nd;\u6A44rcup;\u6A49\u0100au\u19CF\u19D2p;\u6A4Bp;\u6A47ot;\u6A40;\uC000\u2229\uFE00\u0100eo\u19E2\u19E5t;\u6041\xEE\u0693\u0200aeiu\u19F0\u19FB\u1A01\u1A05\u01F0\u19F5\0\u19F8s;\u6A4Don;\u410Ddil\u803B\xE7\u40E7rc;\u4109ps\u0100;s\u1A0C\u1A0D\u6A4Cm;\u6A50ot;\u410B\u0180dmn\u1A1B\u1A20\u1A26il\u80BB\xB8\u01ADptyv;\u69B2t\u8100\xA2;e\u1A2D\u1A2E\u40A2r\xE4\u01B2r;\uC000\uD835\uDD20\u0180cei\u1A3D\u1A40\u1A4Dy;\u4447ck\u0100;m\u1A47\u1A48\u6713ark\xBB\u1A48;\u43C7r\u0380;Ecefms\u1A5F\u1A60\u1A62\u1A6B\u1AA4\u1AAA\u1AAE\u65CB;\u69C3\u0180;el\u1A69\u1A6A\u1A6D\u42C6q;\u6257e\u0261\u1A74\0\0\u1A88rrow\u0100lr\u1A7C\u1A81eft;\u61BAight;\u61BB\u0280RSacd\u1A92\u1A94\u1A96\u1A9A\u1A9F\xBB\u0F47;\u64C8st;\u629Birc;\u629Aash;\u629Dnint;\u6A10id;\u6AEFcir;\u69C2ubs\u0100;u\u1ABB\u1ABC\u6663it\xBB\u1ABC\u02EC\u1AC7\u1AD4\u1AFA\0\u1B0Aon\u0100;e\u1ACD\u1ACE\u403A\u0100;q\xC7\xC6\u026D\u1AD9\0\0\u1AE2a\u0100;t\u1ADE\u1ADF\u402C;\u4040\u0180;fl\u1AE8\u1AE9\u1AEB\u6201\xEE\u1160e\u0100mx\u1AF1\u1AF6ent\xBB\u1AE9e\xF3\u024D\u01E7\u1AFE\0\u1B07\u0100;d\u12BB\u1B02ot;\u6A6Dn\xF4\u0246\u0180fry\u1B10\u1B14\u1B17;\uC000\uD835\uDD54o\xE4\u0254\u8100\xA9;s\u0155\u1B1Dr;\u6117\u0100ao\u1B25\u1B29rr;\u61B5ss;\u6717\u0100cu\u1B32\u1B37r;\uC000\uD835\uDCB8\u0100bp\u1B3C\u1B44\u0100;e\u1B41\u1B42\u6ACF;\u6AD1\u0100;e\u1B49\u1B4A\u6AD0;\u6AD2dot;\u62EF\u0380delprvw\u1B60\u1B6C\u1B77\u1B82\u1BAC\u1BD4\u1BF9arr\u0100lr\u1B68\u1B6A;\u6938;\u6935\u0270\u1B72\0\0\u1B75r;\u62DEc;\u62DFarr\u0100;p\u1B7F\u1B80\u61B6;\u693D\u0300;bcdos\u1B8F\u1B90\u1B96\u1BA1\u1BA5\u1BA8\u622Arcap;\u6A48\u0100au\u1B9B\u1B9Ep;\u6A46p;\u6A4Aot;\u628Dr;\u6A45;\uC000\u222A\uFE00\u0200alrv\u1BB5\u1BBF\u1BDE\u1BE3rr\u0100;m\u1BBC\u1BBD\u61B7;\u693Cy\u0180evw\u1BC7\u1BD4\u1BD8q\u0270\u1BCE\0\0\u1BD2re\xE3\u1B73u\xE3\u1B75ee;\u62CEedge;\u62CFen\u803B\xA4\u40A4earrow\u0100lr\u1BEE\u1BF3eft\xBB\u1B80ight\xBB\u1BBDe\xE4\u1BDD\u0100ci\u1C01\u1C07onin\xF4\u01F7nt;\u6231lcty;\u632D\u0980AHabcdefhijlorstuwz\u1C38\u1C3B\u1C3F\u1C5D\u1C69\u1C75\u1C8A\u1C9E\u1CAC\u1CB7\u1CFB\u1CFF\u1D0D\u1D7B\u1D91\u1DAB\u1DBB\u1DC6\u1DCDr\xF2\u0381ar;\u6965\u0200glrs\u1C48\u1C4D\u1C52\u1C54ger;\u6020eth;\u6138\xF2\u1133h\u0100;v\u1C5A\u1C5B\u6010\xBB\u090A\u016B\u1C61\u1C67arow;\u690Fa\xE3\u0315\u0100ay\u1C6E\u1C73ron;\u410F;\u4434\u0180;ao\u0332\u1C7C\u1C84\u0100gr\u02BF\u1C81r;\u61CAtseq;\u6A77\u0180glm\u1C91\u1C94\u1C98\u803B\xB0\u40B0ta;\u43B4ptyv;\u69B1\u0100ir\u1CA3\u1CA8sht;\u697F;\uC000\uD835\uDD21ar\u0100lr\u1CB3\u1CB5\xBB\u08DC\xBB\u101E\u0280aegsv\u1CC2\u0378\u1CD6\u1CDC\u1CE0m\u0180;os\u0326\u1CCA\u1CD4nd\u0100;s\u0326\u1CD1uit;\u6666amma;\u43DDin;\u62F2\u0180;io\u1CE7\u1CE8\u1CF8\u40F7de\u8100\xF7;o\u1CE7\u1CF0ntimes;\u62C7n\xF8\u1CF7cy;\u4452c\u026F\u1D06\0\0\u1D0Arn;\u631Eop;\u630D\u0280lptuw\u1D18\u1D1D\u1D22\u1D49\u1D55lar;\u4024f;\uC000\uD835\uDD55\u0280;emps\u030B\u1D2D\u1D37\u1D3D\u1D42q\u0100;d\u0352\u1D33ot;\u6251inus;\u6238lus;\u6214quare;\u62A1blebarwedg\xE5\xFAn\u0180adh\u112E\u1D5D\u1D67ownarrow\xF3\u1C83arpoon\u0100lr\u1D72\u1D76ef\xF4\u1CB4igh\xF4\u1CB6\u0162\u1D7F\u1D85karo\xF7\u0F42\u026F\u1D8A\0\0\u1D8Ern;\u631Fop;\u630C\u0180cot\u1D98\u1DA3\u1DA6\u0100ry\u1D9D\u1DA1;\uC000\uD835\uDCB9;\u4455l;\u69F6rok;\u4111\u0100dr\u1DB0\u1DB4ot;\u62F1i\u0100;f\u1DBA\u1816\u65BF\u0100ah\u1DC0\u1DC3r\xF2\u0429a\xF2\u0FA6angle;\u69A6\u0100ci\u1DD2\u1DD5y;\u445Fgrarr;\u67FF\u0900Dacdefglmnopqrstux\u1E01\u1E09\u1E19\u1E38\u0578\u1E3C\u1E49\u1E61\u1E7E\u1EA5\u1EAF\u1EBD\u1EE1\u1F2A\u1F37\u1F44\u1F4E\u1F5A\u0100Do\u1E06\u1D34o\xF4\u1C89\u0100cs\u1E0E\u1E14ute\u803B\xE9\u40E9ter;\u6A6E\u0200aioy\u1E22\u1E27\u1E31\u1E36ron;\u411Br\u0100;c\u1E2D\u1E2E\u6256\u803B\xEA\u40EAlon;\u6255;\u444Dot;\u4117\u0100Dr\u1E41\u1E45ot;\u6252;\uC000\uD835\uDD22\u0180;rs\u1E50\u1E51\u1E57\u6A9Aave\u803B\xE8\u40E8\u0100;d\u1E5C\u1E5D\u6A96ot;\u6A98\u0200;ils\u1E6A\u1E6B\u1E72\u1E74\u6A99nters;\u63E7;\u6113\u0100;d\u1E79\u1E7A\u6A95ot;\u6A97\u0180aps\u1E85\u1E89\u1E97cr;\u4113ty\u0180;sv\u1E92\u1E93\u1E95\u6205et\xBB\u1E93p\u01001;\u1E9D\u1EA4\u0133\u1EA1\u1EA3;\u6004;\u6005\u6003\u0100gs\u1EAA\u1EAC;\u414Bp;\u6002\u0100gp\u1EB4\u1EB8on;\u4119f;\uC000\uD835\uDD56\u0180als\u1EC4\u1ECE\u1ED2r\u0100;s\u1ECA\u1ECB\u62D5l;\u69E3us;\u6A71i\u0180;lv\u1EDA\u1EDB\u1EDF\u43B5on\xBB\u1EDB;\u43F5\u0200csuv\u1EEA\u1EF3\u1F0B\u1F23\u0100io\u1EEF\u1E31rc\xBB\u1E2E\u0269\u1EF9\0\0\u1EFB\xED\u0548ant\u0100gl\u1F02\u1F06tr\xBB\u1E5Dess\xBB\u1E7A\u0180aei\u1F12\u1F16\u1F1Als;\u403Dst;\u625Fv\u0100;D\u0235\u1F20D;\u6A78parsl;\u69E5\u0100Da\u1F2F\u1F33ot;\u6253rr;\u6971\u0180cdi\u1F3E\u1F41\u1EF8r;\u612Fo\xF4\u0352\u0100ah\u1F49\u1F4B;\u43B7\u803B\xF0\u40F0\u0100mr\u1F53\u1F57l\u803B\xEB\u40EBo;\u60AC\u0180cip\u1F61\u1F64\u1F67l;\u4021s\xF4\u056E\u0100eo\u1F6C\u1F74ctatio\xEE\u0559nential\xE5\u0579\u09E1\u1F92\0\u1F9E\0\u1FA1\u1FA7\0\0\u1FC6\u1FCC\0\u1FD3\0\u1FE6\u1FEA\u2000\0\u2008\u205Allingdotse\xF1\u1E44y;\u4444male;\u6640\u0180ilr\u1FAD\u1FB3\u1FC1lig;\u8000\uFB03\u0269\u1FB9\0\0\u1FBDg;\u8000\uFB00ig;\u8000\uFB04;\uC000\uD835\uDD23lig;\u8000\uFB01lig;\uC000fj\u0180alt\u1FD9\u1FDC\u1FE1t;\u666Dig;\u8000\uFB02ns;\u65B1of;\u4192\u01F0\u1FEE\0\u1FF3f;\uC000\uD835\uDD57\u0100ak\u05BF\u1FF7\u0100;v\u1FFC\u1FFD\u62D4;\u6AD9artint;\u6A0D\u0100ao\u200C\u2055\u0100cs\u2011\u2052\u03B1\u201A\u2030\u2038\u2045\u2048\0\u2050\u03B2\u2022\u2025\u2027\u202A\u202C\0\u202E\u803B\xBD\u40BD;\u6153\u803B\xBC\u40BC;\u6155;\u6159;\u615B\u01B3\u2034\0\u2036;\u6154;\u6156\u02B4\u203E\u2041\0\0\u2043\u803B\xBE\u40BE;\u6157;\u615C5;\u6158\u01B6\u204C\0\u204E;\u615A;\u615D8;\u615El;\u6044wn;\u6322cr;\uC000\uD835\uDCBB\u0880Eabcdefgijlnorstv\u2082\u2089\u209F\u20A5\u20B0\u20B4\u20F0\u20F5\u20FA\u20FF\u2103\u2112\u2138\u0317\u213E\u2152\u219E\u0100;l\u064D\u2087;\u6A8C\u0180cmp\u2090\u2095\u209Dute;\u41F5ma\u0100;d\u209C\u1CDA\u43B3;\u6A86reve;\u411F\u0100iy\u20AA\u20AErc;\u411D;\u4433ot;\u4121\u0200;lqs\u063E\u0642\u20BD\u20C9\u0180;qs\u063E\u064C\u20C4lan\xF4\u0665\u0200;cdl\u0665\u20D2\u20D5\u20E5c;\u6AA9ot\u0100;o\u20DC\u20DD\u6A80\u0100;l\u20E2\u20E3\u6A82;\u6A84\u0100;e\u20EA\u20ED\uC000\u22DB\uFE00s;\u6A94r;\uC000\uD835\uDD24\u0100;g\u0673\u061Bmel;\u6137cy;\u4453\u0200;Eaj\u065A\u210C\u210E\u2110;\u6A92;\u6AA5;\u6AA4\u0200Eaes\u211B\u211D\u2129\u2134;\u6269p\u0100;p\u2123\u2124\u6A8Arox\xBB\u2124\u0100;q\u212E\u212F\u6A88\u0100;q\u212E\u211Bim;\u62E7pf;\uC000\uD835\uDD58\u0100ci\u2143\u2146r;\u610Am\u0180;el\u066B\u214E\u2150;\u6A8E;\u6A90\u8300>;cdlqr\u05EE\u2160\u216A\u216E\u2173\u2179\u0100ci\u2165\u2167;\u6AA7r;\u6A7Aot;\u62D7Par;\u6995uest;\u6A7C\u0280adels\u2184\u216A\u2190\u0656\u219B\u01F0\u2189\0\u218Epro\xF8\u209Er;\u6978q\u0100lq\u063F\u2196les\xF3\u2088i\xED\u066B\u0100en\u21A3\u21ADrtneqq;\uC000\u2269\uFE00\xC5\u21AA\u0500Aabcefkosy\u21C4\u21C7\u21F1\u21F5\u21FA\u2218\u221D\u222F\u2268\u227Dr\xF2\u03A0\u0200ilmr\u21D0\u21D4\u21D7\u21DBrs\xF0\u1484f\xBB\u2024il\xF4\u06A9\u0100dr\u21E0\u21E4cy;\u444A\u0180;cw\u08F4\u21EB\u21EFir;\u6948;\u61ADar;\u610Firc;\u4125\u0180alr\u2201\u220E\u2213rts\u0100;u\u2209\u220A\u6665it\xBB\u220Alip;\u6026con;\u62B9r;\uC000\uD835\uDD25s\u0100ew\u2223\u2229arow;\u6925arow;\u6926\u0280amopr\u223A\u223E\u2243\u225E\u2263rr;\u61FFtht;\u623Bk\u0100lr\u2249\u2253eftarrow;\u61A9ightarrow;\u61AAf;\uC000\uD835\uDD59bar;\u6015\u0180clt\u226F\u2274\u2278r;\uC000\uD835\uDCBDas\xE8\u21F4rok;\u4127\u0100bp\u2282\u2287ull;\u6043hen\xBB\u1C5B\u0AE1\u22A3\0\u22AA\0\u22B8\u22C5\u22CE\0\u22D5\u22F3\0\0\u22F8\u2322\u2367\u2362\u237F\0\u2386\u23AA\u23B4cute\u803B\xED\u40ED\u0180;iy\u0771\u22B0\u22B5rc\u803B\xEE\u40EE;\u4438\u0100cx\u22BC\u22BFy;\u4435cl\u803B\xA1\u40A1\u0100fr\u039F\u22C9;\uC000\uD835\uDD26rave\u803B\xEC\u40EC\u0200;ino\u073E\u22DD\u22E9\u22EE\u0100in\u22E2\u22E6nt;\u6A0Ct;\u622Dfin;\u69DCta;\u6129lig;\u4133\u0180aop\u22FE\u231A\u231D\u0180cgt\u2305\u2308\u2317r;\u412B\u0180elp\u071F\u230F\u2313in\xE5\u078Ear\xF4\u0720h;\u4131f;\u62B7ed;\u41B5\u0280;cfot\u04F4\u232C\u2331\u233D\u2341are;\u6105in\u0100;t\u2338\u2339\u621Eie;\u69DDdo\xF4\u2319\u0280;celp\u0757\u234C\u2350\u235B\u2361al;\u62BA\u0100gr\u2355\u2359er\xF3\u1563\xE3\u234Darhk;\u6A17rod;\u6A3C\u0200cgpt\u236F\u2372\u2376\u237By;\u4451on;\u412Ff;\uC000\uD835\uDD5Aa;\u43B9uest\u803B\xBF\u40BF\u0100ci\u238A\u238Fr;\uC000\uD835\uDCBEn\u0280;Edsv\u04F4\u239B\u239D\u23A1\u04F3;\u62F9ot;\u62F5\u0100;v\u23A6\u23A7\u62F4;\u62F3\u0100;i\u0777\u23AElde;\u4129\u01EB\u23B8\0\u23BCcy;\u4456l\u803B\xEF\u40EF\u0300cfmosu\u23CC\u23D7\u23DC\u23E1\u23E7\u23F5\u0100iy\u23D1\u23D5rc;\u4135;\u4439r;\uC000\uD835\uDD27ath;\u4237pf;\uC000\uD835\uDD5B\u01E3\u23EC\0\u23F1r;\uC000\uD835\uDCBFrcy;\u4458kcy;\u4454\u0400acfghjos\u240B\u2416\u2422\u2427\u242D\u2431\u2435\u243Bppa\u0100;v\u2413\u2414\u43BA;\u43F0\u0100ey\u241B\u2420dil;\u4137;\u443Ar;\uC000\uD835\uDD28reen;\u4138cy;\u4445cy;\u445Cpf;\uC000\uD835\uDD5Ccr;\uC000\uD835\uDCC0\u0B80ABEHabcdefghjlmnoprstuv\u2470\u2481\u2486\u248D\u2491\u250E\u253D\u255A\u2580\u264E\u265E\u2665\u2679\u267D\u269A\u26B2\u26D8\u275D\u2768\u278B\u27C0\u2801\u2812\u0180art\u2477\u247A\u247Cr\xF2\u09C6\xF2\u0395ail;\u691Barr;\u690E\u0100;g\u0994\u248B;\u6A8Bar;\u6962\u0963\u24A5\0\u24AA\0\u24B1\0\0\0\0\0\u24B5\u24BA\0\u24C6\u24C8\u24CD\0\u24F9ute;\u413Amptyv;\u69B4ra\xEE\u084Cbda;\u43BBg\u0180;dl\u088E\u24C1\u24C3;\u6991\xE5\u088E;\u6A85uo\u803B\xAB\u40ABr\u0400;bfhlpst\u0899\u24DE\u24E6\u24E9\u24EB\u24EE\u24F1\u24F5\u0100;f\u089D\u24E3s;\u691Fs;\u691D\xEB\u2252p;\u61ABl;\u6939im;\u6973l;\u61A2\u0180;ae\u24FF\u2500\u2504\u6AABil;\u6919\u0100;s\u2509\u250A\u6AAD;\uC000\u2AAD\uFE00\u0180abr\u2515\u2519\u251Drr;\u690Crk;\u6772\u0100ak\u2522\u252Cc\u0100ek\u2528\u252A;\u407B;\u405B\u0100es\u2531\u2533;\u698Bl\u0100du\u2539\u253B;\u698F;\u698D\u0200aeuy\u2546\u254B\u2556\u2558ron;\u413E\u0100di\u2550\u2554il;\u413C\xEC\u08B0\xE2\u2529;\u443B\u0200cqrs\u2563\u2566\u256D\u257Da;\u6936uo\u0100;r\u0E19\u1746\u0100du\u2572\u2577har;\u6967shar;\u694Bh;\u61B2\u0280;fgqs\u258B\u258C\u0989\u25F3\u25FF\u6264t\u0280ahlrt\u2598\u25A4\u25B7\u25C2\u25E8rrow\u0100;t\u0899\u25A1a\xE9\u24F6arpoon\u0100du\u25AF\u25B4own\xBB\u045Ap\xBB\u0966eftarrows;\u61C7ight\u0180ahs\u25CD\u25D6\u25DErrow\u0100;s\u08F4\u08A7arpoon\xF3\u0F98quigarro\xF7\u21F0hreetimes;\u62CB\u0180;qs\u258B\u0993\u25FAlan\xF4\u09AC\u0280;cdgs\u09AC\u260A\u260D\u261D\u2628c;\u6AA8ot\u0100;o\u2614\u2615\u6A7F\u0100;r\u261A\u261B\u6A81;\u6A83\u0100;e\u2622\u2625\uC000\u22DA\uFE00s;\u6A93\u0280adegs\u2633\u2639\u263D\u2649\u264Bppro\xF8\u24C6ot;\u62D6q\u0100gq\u2643\u2645\xF4\u0989gt\xF2\u248C\xF4\u099Bi\xED\u09B2\u0180ilr\u2655\u08E1\u265Asht;\u697C;\uC000\uD835\uDD29\u0100;E\u099C\u2663;\u6A91\u0161\u2669\u2676r\u0100du\u25B2\u266E\u0100;l\u0965\u2673;\u696Alk;\u6584cy;\u4459\u0280;acht\u0A48\u2688\u268B\u2691\u2696r\xF2\u25C1orne\xF2\u1D08ard;\u696Bri;\u65FA\u0100io\u269F\u26A4dot;\u4140ust\u0100;a\u26AC\u26AD\u63B0che\xBB\u26AD\u0200Eaes\u26BB\u26BD\u26C9\u26D4;\u6268p\u0100;p\u26C3\u26C4\u6A89rox\xBB\u26C4\u0100;q\u26CE\u26CF\u6A87\u0100;q\u26CE\u26BBim;\u62E6\u0400abnoptwz\u26E9\u26F4\u26F7\u271A\u272F\u2741\u2747\u2750\u0100nr\u26EE\u26F1g;\u67ECr;\u61FDr\xEB\u08C1g\u0180lmr\u26FF\u270D\u2714eft\u0100ar\u09E6\u2707ight\xE1\u09F2apsto;\u67FCight\xE1\u09FDparrow\u0100lr\u2725\u2729ef\xF4\u24EDight;\u61AC\u0180afl\u2736\u2739\u273Dr;\u6985;\uC000\uD835\uDD5Dus;\u6A2Dimes;\u6A34\u0161\u274B\u274Fst;\u6217\xE1\u134E\u0180;ef\u2757\u2758\u1800\u65CAnge\xBB\u2758ar\u0100;l\u2764\u2765\u4028t;\u6993\u0280achmt\u2773\u2776\u277C\u2785\u2787r\xF2\u08A8orne\xF2\u1D8Car\u0100;d\u0F98\u2783;\u696D;\u600Eri;\u62BF\u0300achiqt\u2798\u279D\u0A40\u27A2\u27AE\u27BBquo;\u6039r;\uC000\uD835\uDCC1m\u0180;eg\u09B2\u27AA\u27AC;\u6A8D;\u6A8F\u0100bu\u252A\u27B3o\u0100;r\u0E1F\u27B9;\u601Arok;\u4142\u8400<;cdhilqr\u082B\u27D2\u2639\u27DC\u27E0\u27E5\u27EA\u27F0\u0100ci\u27D7\u27D9;\u6AA6r;\u6A79re\xE5\u25F2mes;\u62C9arr;\u6976uest;\u6A7B\u0100Pi\u27F5\u27F9ar;\u6996\u0180;ef\u2800\u092D\u181B\u65C3r\u0100du\u2807\u280Dshar;\u694Ahar;\u6966\u0100en\u2817\u2821rtneqq;\uC000\u2268\uFE00\xC5\u281E\u0700Dacdefhilnopsu\u2840\u2845\u2882\u288E\u2893\u28A0\u28A5\u28A8\u28DA\u28E2\u28E4\u0A83\u28F3\u2902Dot;\u623A\u0200clpr\u284E\u2852\u2863\u287Dr\u803B\xAF\u40AF\u0100et\u2857\u2859;\u6642\u0100;e\u285E\u285F\u6720se\xBB\u285F\u0100;s\u103B\u2868to\u0200;dlu\u103B\u2873\u2877\u287Bow\xEE\u048Cef\xF4\u090F\xF0\u13D1ker;\u65AE\u0100oy\u2887\u288Cmma;\u6A29;\u443Cash;\u6014asuredangle\xBB\u1626r;\uC000\uD835\uDD2Ao;\u6127\u0180cdn\u28AF\u28B4\u28C9ro\u803B\xB5\u40B5\u0200;acd\u1464\u28BD\u28C0\u28C4s\xF4\u16A7ir;\u6AF0ot\u80BB\xB7\u01B5us\u0180;bd\u28D2\u1903\u28D3\u6212\u0100;u\u1D3C\u28D8;\u6A2A\u0163\u28DE\u28E1p;\u6ADB\xF2\u2212\xF0\u0A81\u0100dp\u28E9\u28EEels;\u62A7f;\uC000\uD835\uDD5E\u0100ct\u28F8\u28FDr;\uC000\uD835\uDCC2pos\xBB\u159D\u0180;lm\u2909\u290A\u290D\u43BCtimap;\u62B8\u0C00GLRVabcdefghijlmoprstuvw\u2942\u2953\u297E\u2989\u2998\u29DA\u29E9\u2A15\u2A1A\u2A58\u2A5D\u2A83\u2A95\u2AA4\u2AA8\u2B04\u2B07\u2B44\u2B7F\u2BAE\u2C34\u2C67\u2C7C\u2CE9\u0100gt\u2947\u294B;\uC000\u22D9\u0338\u0100;v\u2950\u0BCF\uC000\u226B\u20D2\u0180elt\u295A\u2972\u2976ft\u0100ar\u2961\u2967rrow;\u61CDightarrow;\u61CE;\uC000\u22D8\u0338\u0100;v\u297B\u0C47\uC000\u226A\u20D2ightarrow;\u61CF\u0100Dd\u298E\u2993ash;\u62AFash;\u62AE\u0280bcnpt\u29A3\u29A7\u29AC\u29B1\u29CCla\xBB\u02DEute;\u4144g;\uC000\u2220\u20D2\u0280;Eiop\u0D84\u29BC\u29C0\u29C5\u29C8;\uC000\u2A70\u0338d;\uC000\u224B\u0338s;\u4149ro\xF8\u0D84ur\u0100;a\u29D3\u29D4\u666El\u0100;s\u29D3\u0B38\u01F3\u29DF\0\u29E3p\u80BB\xA0\u0B37mp\u0100;e\u0BF9\u0C00\u0280aeouy\u29F4\u29FE\u2A03\u2A10\u2A13\u01F0\u29F9\0\u29FB;\u6A43on;\u4148dil;\u4146ng\u0100;d\u0D7E\u2A0Aot;\uC000\u2A6D\u0338p;\u6A42;\u443Dash;\u6013\u0380;Aadqsx\u0B92\u2A29\u2A2D\u2A3B\u2A41\u2A45\u2A50rr;\u61D7r\u0100hr\u2A33\u2A36k;\u6924\u0100;o\u13F2\u13F0ot;\uC000\u2250\u0338ui\xF6\u0B63\u0100ei\u2A4A\u2A4Ear;\u6928\xED\u0B98ist\u0100;s\u0BA0\u0B9Fr;\uC000\uD835\uDD2B\u0200Eest\u0BC5\u2A66\u2A79\u2A7C\u0180;qs\u0BBC\u2A6D\u0BE1\u0180;qs\u0BBC\u0BC5\u2A74lan\xF4\u0BE2i\xED\u0BEA\u0100;r\u0BB6\u2A81\xBB\u0BB7\u0180Aap\u2A8A\u2A8D\u2A91r\xF2\u2971rr;\u61AEar;\u6AF2\u0180;sv\u0F8D\u2A9C\u0F8C\u0100;d\u2AA1\u2AA2\u62FC;\u62FAcy;\u445A\u0380AEadest\u2AB7\u2ABA\u2ABE\u2AC2\u2AC5\u2AF6\u2AF9r\xF2\u2966;\uC000\u2266\u0338rr;\u619Ar;\u6025\u0200;fqs\u0C3B\u2ACE\u2AE3\u2AEFt\u0100ar\u2AD4\u2AD9rro\xF7\u2AC1ightarro\xF7\u2A90\u0180;qs\u0C3B\u2ABA\u2AEAlan\xF4\u0C55\u0100;s\u0C55\u2AF4\xBB\u0C36i\xED\u0C5D\u0100;r\u0C35\u2AFEi\u0100;e\u0C1A\u0C25i\xE4\u0D90\u0100pt\u2B0C\u2B11f;\uC000\uD835\uDD5F\u8180\xAC;in\u2B19\u2B1A\u2B36\u40ACn\u0200;Edv\u0B89\u2B24\u2B28\u2B2E;\uC000\u22F9\u0338ot;\uC000\u22F5\u0338\u01E1\u0B89\u2B33\u2B35;\u62F7;\u62F6i\u0100;v\u0CB8\u2B3C\u01E1\u0CB8\u2B41\u2B43;\u62FE;\u62FD\u0180aor\u2B4B\u2B63\u2B69r\u0200;ast\u0B7B\u2B55\u2B5A\u2B5Flle\xEC\u0B7Bl;\uC000\u2AFD\u20E5;\uC000\u2202\u0338lint;\u6A14\u0180;ce\u0C92\u2B70\u2B73u\xE5\u0CA5\u0100;c\u0C98\u2B78\u0100;e\u0C92\u2B7D\xF1\u0C98\u0200Aait\u2B88\u2B8B\u2B9D\u2BA7r\xF2\u2988rr\u0180;cw\u2B94\u2B95\u2B99\u619B;\uC000\u2933\u0338;\uC000\u219D\u0338ghtarrow\xBB\u2B95ri\u0100;e\u0CCB\u0CD6\u0380chimpqu\u2BBD\u2BCD\u2BD9\u2B04\u0B78\u2BE4\u2BEF\u0200;cer\u0D32\u2BC6\u0D37\u2BC9u\xE5\u0D45;\uC000\uD835\uDCC3ort\u026D\u2B05\0\0\u2BD6ar\xE1\u2B56m\u0100;e\u0D6E\u2BDF\u0100;q\u0D74\u0D73su\u0100bp\u2BEB\u2BED\xE5\u0CF8\xE5\u0D0B\u0180bcp\u2BF6\u2C11\u2C19\u0200;Ees\u2BFF\u2C00\u0D22\u2C04\u6284;\uC000\u2AC5\u0338et\u0100;e\u0D1B\u2C0Bq\u0100;q\u0D23\u2C00c\u0100;e\u0D32\u2C17\xF1\u0D38\u0200;Ees\u2C22\u2C23\u0D5F\u2C27\u6285;\uC000\u2AC6\u0338et\u0100;e\u0D58\u2C2Eq\u0100;q\u0D60\u2C23\u0200gilr\u2C3D\u2C3F\u2C45\u2C47\xEC\u0BD7lde\u803B\xF1\u40F1\xE7\u0C43iangle\u0100lr\u2C52\u2C5Ceft\u0100;e\u0C1A\u2C5A\xF1\u0C26ight\u0100;e\u0CCB\u2C65\xF1\u0CD7\u0100;m\u2C6C\u2C6D\u43BD\u0180;es\u2C74\u2C75\u2C79\u4023ro;\u6116p;\u6007\u0480DHadgilrs\u2C8F\u2C94\u2C99\u2C9E\u2CA3\u2CB0\u2CB6\u2CD3\u2CE3ash;\u62ADarr;\u6904p;\uC000\u224D\u20D2ash;\u62AC\u0100et\u2CA8\u2CAC;\uC000\u2265\u20D2;\uC000>\u20D2nfin;\u69DE\u0180Aet\u2CBD\u2CC1\u2CC5rr;\u6902;\uC000\u2264\u20D2\u0100;r\u2CCA\u2CCD\uC000<\u20D2ie;\uC000\u22B4\u20D2\u0100At\u2CD8\u2CDCrr;\u6903rie;\uC000\u22B5\u20D2im;\uC000\u223C\u20D2\u0180Aan\u2CF0\u2CF4\u2D02rr;\u61D6r\u0100hr\u2CFA\u2CFDk;\u6923\u0100;o\u13E7\u13E5ear;\u6927\u1253\u1A95\0\0\0\0\0\0\0\0\0\0\0\0\0\u2D2D\0\u2D38\u2D48\u2D60\u2D65\u2D72\u2D84\u1B07\0\0\u2D8D\u2DAB\0\u2DC8\u2DCE\0\u2DDC\u2E19\u2E2B\u2E3E\u2E43\u0100cs\u2D31\u1A97ute\u803B\xF3\u40F3\u0100iy\u2D3C\u2D45r\u0100;c\u1A9E\u2D42\u803B\xF4\u40F4;\u443E\u0280abios\u1AA0\u2D52\u2D57\u01C8\u2D5Alac;\u4151v;\u6A38old;\u69BClig;\u4153\u0100cr\u2D69\u2D6Dir;\u69BF;\uC000\uD835\uDD2C\u036F\u2D79\0\0\u2D7C\0\u2D82n;\u42DBave\u803B\xF2\u40F2;\u69C1\u0100bm\u2D88\u0DF4ar;\u69B5\u0200acit\u2D95\u2D98\u2DA5\u2DA8r\xF2\u1A80\u0100ir\u2D9D\u2DA0r;\u69BEoss;\u69BBn\xE5\u0E52;\u69C0\u0180aei\u2DB1\u2DB5\u2DB9cr;\u414Dga;\u43C9\u0180cdn\u2DC0\u2DC5\u01CDron;\u43BF;\u69B6pf;\uC000\uD835\uDD60\u0180ael\u2DD4\u2DD7\u01D2r;\u69B7rp;\u69B9\u0380;adiosv\u2DEA\u2DEB\u2DEE\u2E08\u2E0D\u2E10\u2E16\u6228r\xF2\u1A86\u0200;efm\u2DF7\u2DF8\u2E02\u2E05\u6A5Dr\u0100;o\u2DFE\u2DFF\u6134f\xBB\u2DFF\u803B\xAA\u40AA\u803B\xBA\u40BAgof;\u62B6r;\u6A56lope;\u6A57;\u6A5B\u0180clo\u2E1F\u2E21\u2E27\xF2\u2E01ash\u803B\xF8\u40F8l;\u6298i\u016C\u2E2F\u2E34de\u803B\xF5\u40F5es\u0100;a\u01DB\u2E3As;\u6A36ml\u803B\xF6\u40F6bar;\u633D\u0AE1\u2E5E\0\u2E7D\0\u2E80\u2E9D\0\u2EA2\u2EB9\0\0\u2ECB\u0E9C\0\u2F13\0\0\u2F2B\u2FBC\0\u2FC8r\u0200;ast\u0403\u2E67\u2E72\u0E85\u8100\xB6;l\u2E6D\u2E6E\u40B6le\xEC\u0403\u0269\u2E78\0\0\u2E7Bm;\u6AF3;\u6AFDy;\u443Fr\u0280cimpt\u2E8B\u2E8F\u2E93\u1865\u2E97nt;\u4025od;\u402Eil;\u6030enk;\u6031r;\uC000\uD835\uDD2D\u0180imo\u2EA8\u2EB0\u2EB4\u0100;v\u2EAD\u2EAE\u43C6;\u43D5ma\xF4\u0A76ne;\u660E\u0180;tv\u2EBF\u2EC0\u2EC8\u43C0chfork\xBB\u1FFD;\u43D6\u0100au\u2ECF\u2EDFn\u0100ck\u2ED5\u2EDDk\u0100;h\u21F4\u2EDB;\u610E\xF6\u21F4s\u0480;abcdemst\u2EF3\u2EF4\u1908\u2EF9\u2EFD\u2F04\u2F06\u2F0A\u2F0E\u402Bcir;\u6A23ir;\u6A22\u0100ou\u1D40\u2F02;\u6A25;\u6A72n\u80BB\xB1\u0E9Dim;\u6A26wo;\u6A27\u0180ipu\u2F19\u2F20\u2F25ntint;\u6A15f;\uC000\uD835\uDD61nd\u803B\xA3\u40A3\u0500;Eaceinosu\u0EC8\u2F3F\u2F41\u2F44\u2F47\u2F81\u2F89\u2F92\u2F7E\u2FB6;\u6AB3p;\u6AB7u\xE5\u0ED9\u0100;c\u0ECE\u2F4C\u0300;acens\u0EC8\u2F59\u2F5F\u2F66\u2F68\u2F7Eppro\xF8\u2F43urlye\xF1\u0ED9\xF1\u0ECE\u0180aes\u2F6F\u2F76\u2F7Approx;\u6AB9qq;\u6AB5im;\u62E8i\xED\u0EDFme\u0100;s\u2F88\u0EAE\u6032\u0180Eas\u2F78\u2F90\u2F7A\xF0\u2F75\u0180dfp\u0EEC\u2F99\u2FAF\u0180als\u2FA0\u2FA5\u2FAAlar;\u632Eine;\u6312urf;\u6313\u0100;t\u0EFB\u2FB4\xEF\u0EFBrel;\u62B0\u0100ci\u2FC0\u2FC5r;\uC000\uD835\uDCC5;\u43C8ncsp;\u6008\u0300fiopsu\u2FDA\u22E2\u2FDF\u2FE5\u2FEB\u2FF1r;\uC000\uD835\uDD2Epf;\uC000\uD835\uDD62rime;\u6057cr;\uC000\uD835\uDCC6\u0180aeo\u2FF8\u3009\u3013t\u0100ei\u2FFE\u3005rnion\xF3\u06B0nt;\u6A16st\u0100;e\u3010\u3011\u403F\xF1\u1F19\xF4\u0F14\u0A80ABHabcdefhilmnoprstux\u3040\u3051\u3055\u3059\u30E0\u310E\u312B\u3147\u3162\u3172\u318E\u3206\u3215\u3224\u3229\u3258\u326E\u3272\u3290\u32B0\u32B7\u0180art\u3047\u304A\u304Cr\xF2\u10B3\xF2\u03DDail;\u691Car\xF2\u1C65ar;\u6964\u0380cdenqrt\u3068\u3075\u3078\u307F\u308F\u3094\u30CC\u0100eu\u306D\u3071;\uC000\u223D\u0331te;\u4155i\xE3\u116Emptyv;\u69B3g\u0200;del\u0FD1\u3089\u308B\u308D;\u6992;\u69A5\xE5\u0FD1uo\u803B\xBB\u40BBr\u0580;abcfhlpstw\u0FDC\u30AC\u30AF\u30B7\u30B9\u30BC\u30BE\u30C0\u30C3\u30C7\u30CAp;\u6975\u0100;f\u0FE0\u30B4s;\u6920;\u6933s;\u691E\xEB\u225D\xF0\u272El;\u6945im;\u6974l;\u61A3;\u619D\u0100ai\u30D1\u30D5il;\u691Ao\u0100;n\u30DB\u30DC\u6236al\xF3\u0F1E\u0180abr\u30E7\u30EA\u30EEr\xF2\u17E5rk;\u6773\u0100ak\u30F3\u30FDc\u0100ek\u30F9\u30FB;\u407D;\u405D\u0100es\u3102\u3104;\u698Cl\u0100du\u310A\u310C;\u698E;\u6990\u0200aeuy\u3117\u311C\u3127\u3129ron;\u4159\u0100di\u3121\u3125il;\u4157\xEC\u0FF2\xE2\u30FA;\u4440\u0200clqs\u3134\u3137\u313D\u3144a;\u6937dhar;\u6969uo\u0100;r\u020E\u020Dh;\u61B3\u0180acg\u314E\u315F\u0F44l\u0200;ips\u0F78\u3158\u315B\u109Cn\xE5\u10BBar\xF4\u0FA9t;\u65AD\u0180ilr\u3169\u1023\u316Esht;\u697D;\uC000\uD835\uDD2F\u0100ao\u3177\u3186r\u0100du\u317D\u317F\xBB\u047B\u0100;l\u1091\u3184;\u696C\u0100;v\u318B\u318C\u43C1;\u43F1\u0180gns\u3195\u31F9\u31FCht\u0300ahlrst\u31A4\u31B0\u31C2\u31D8\u31E4\u31EErrow\u0100;t\u0FDC\u31ADa\xE9\u30C8arpoon\u0100du\u31BB\u31BFow\xEE\u317Ep\xBB\u1092eft\u0100ah\u31CA\u31D0rrow\xF3\u0FEAarpoon\xF3\u0551ightarrows;\u61C9quigarro\xF7\u30CBhreetimes;\u62CCg;\u42DAingdotse\xF1\u1F32\u0180ahm\u320D\u3210\u3213r\xF2\u0FEAa\xF2\u0551;\u600Foust\u0100;a\u321E\u321F\u63B1che\xBB\u321Fmid;\u6AEE\u0200abpt\u3232\u323D\u3240\u3252\u0100nr\u3237\u323Ag;\u67EDr;\u61FEr\xEB\u1003\u0180afl\u3247\u324A\u324Er;\u6986;\uC000\uD835\uDD63us;\u6A2Eimes;\u6A35\u0100ap\u325D\u3267r\u0100;g\u3263\u3264\u4029t;\u6994olint;\u6A12ar\xF2\u31E3\u0200achq\u327B\u3280\u10BC\u3285quo;\u603Ar;\uC000\uD835\uDCC7\u0100bu\u30FB\u328Ao\u0100;r\u0214\u0213\u0180hir\u3297\u329B\u32A0re\xE5\u31F8mes;\u62CAi\u0200;efl\u32AA\u1059\u1821\u32AB\u65B9tri;\u69CEluhar;\u6968;\u611E\u0D61\u32D5\u32DB\u32DF\u332C\u3338\u3371\0\u337A\u33A4\0\0\u33EC\u33F0\0\u3428\u3448\u345A\u34AD\u34B1\u34CA\u34F1\0\u3616\0\0\u3633cute;\u415Bqu\xEF\u27BA\u0500;Eaceinpsy\u11ED\u32F3\u32F5\u32FF\u3302\u330B\u330F\u331F\u3326\u3329;\u6AB4\u01F0\u32FA\0\u32FC;\u6AB8on;\u4161u\xE5\u11FE\u0100;d\u11F3\u3307il;\u415Frc;\u415D\u0180Eas\u3316\u3318\u331B;\u6AB6p;\u6ABAim;\u62E9olint;\u6A13i\xED\u1204;\u4441ot\u0180;be\u3334\u1D47\u3335\u62C5;\u6A66\u0380Aacmstx\u3346\u334A\u3357\u335B\u335E\u3363\u336Drr;\u61D8r\u0100hr\u3350\u3352\xEB\u2228\u0100;o\u0A36\u0A34t\u803B\xA7\u40A7i;\u403Bwar;\u6929m\u0100in\u3369\xF0nu\xF3\xF1t;\u6736r\u0100;o\u3376\u2055\uC000\uD835\uDD30\u0200acoy\u3382\u3386\u3391\u33A0rp;\u666F\u0100hy\u338B\u338Fcy;\u4449;\u4448rt\u026D\u3399\0\0\u339Ci\xE4\u1464ara\xEC\u2E6F\u803B\xAD\u40AD\u0100gm\u33A8\u33B4ma\u0180;fv\u33B1\u33B2\u33B2\u43C3;\u43C2\u0400;deglnpr\u12AB\u33C5\u33C9\u33CE\u33D6\u33DE\u33E1\u33E6ot;\u6A6A\u0100;q\u12B1\u12B0\u0100;E\u33D3\u33D4\u6A9E;\u6AA0\u0100;E\u33DB\u33DC\u6A9D;\u6A9Fe;\u6246lus;\u6A24arr;\u6972ar\xF2\u113D\u0200aeit\u33F8\u3408\u340F\u3417\u0100ls\u33FD\u3404lsetm\xE9\u336Ahp;\u6A33parsl;\u69E4\u0100dl\u1463\u3414e;\u6323\u0100;e\u341C\u341D\u6AAA\u0100;s\u3422\u3423\u6AAC;\uC000\u2AAC\uFE00\u0180flp\u342E\u3433\u3442tcy;\u444C\u0100;b\u3438\u3439\u402F\u0100;a\u343E\u343F\u69C4r;\u633Ff;\uC000\uD835\uDD64a\u0100dr\u344D\u0402es\u0100;u\u3454\u3455\u6660it\xBB\u3455\u0180csu\u3460\u3479\u349F\u0100au\u3465\u346Fp\u0100;s\u1188\u346B;\uC000\u2293\uFE00p\u0100;s\u11B4\u3475;\uC000\u2294\uFE00u\u0100bp\u347F\u348F\u0180;es\u1197\u119C\u3486et\u0100;e\u1197\u348D\xF1\u119D\u0180;es\u11A8\u11AD\u3496et\u0100;e\u11A8\u349D\xF1\u11AE\u0180;af\u117B\u34A6\u05B0r\u0165\u34AB\u05B1\xBB\u117Car\xF2\u1148\u0200cemt\u34B9\u34BE\u34C2\u34C5r;\uC000\uD835\uDCC8tm\xEE\xF1i\xEC\u3415ar\xE6\u11BE\u0100ar\u34CE\u34D5r\u0100;f\u34D4\u17BF\u6606\u0100an\u34DA\u34EDight\u0100ep\u34E3\u34EApsilo\xEE\u1EE0h\xE9\u2EAFs\xBB\u2852\u0280bcmnp\u34FB\u355E\u1209\u358B\u358E\u0480;Edemnprs\u350E\u350F\u3511\u3515\u351E\u3523\u352C\u3531\u3536\u6282;\u6AC5ot;\u6ABD\u0100;d\u11DA\u351Aot;\u6AC3ult;\u6AC1\u0100Ee\u3528\u352A;\u6ACB;\u628Alus;\u6ABFarr;\u6979\u0180eiu\u353D\u3552\u3555t\u0180;en\u350E\u3545\u354Bq\u0100;q\u11DA\u350Feq\u0100;q\u352B\u3528m;\u6AC7\u0100bp\u355A\u355C;\u6AD5;\u6AD3c\u0300;acens\u11ED\u356C\u3572\u3579\u357B\u3326ppro\xF8\u32FAurlye\xF1\u11FE\xF1\u11F3\u0180aes\u3582\u3588\u331Bppro\xF8\u331Aq\xF1\u3317g;\u666A\u0680123;Edehlmnps\u35A9\u35AC\u35AF\u121C\u35B2\u35B4\u35C0\u35C9\u35D5\u35DA\u35DF\u35E8\u35ED\u803B\xB9\u40B9\u803B\xB2\u40B2\u803B\xB3\u40B3;\u6AC6\u0100os\u35B9\u35BCt;\u6ABEub;\u6AD8\u0100;d\u1222\u35C5ot;\u6AC4s\u0100ou\u35CF\u35D2l;\u67C9b;\u6AD7arr;\u697Bult;\u6AC2\u0100Ee\u35E4\u35E6;\u6ACC;\u628Blus;\u6AC0\u0180eiu\u35F4\u3609\u360Ct\u0180;en\u121C\u35FC\u3602q\u0100;q\u1222\u35B2eq\u0100;q\u35E7\u35E4m;\u6AC8\u0100bp\u3611\u3613;\u6AD4;\u6AD6\u0180Aan\u361C\u3620\u362Drr;\u61D9r\u0100hr\u3626\u3628\xEB\u222E\u0100;o\u0A2B\u0A29war;\u692Alig\u803B\xDF\u40DF\u0BE1\u3651\u365D\u3660\u12CE\u3673\u3679\0\u367E\u36C2\0\0\0\0\0\u36DB\u3703\0\u3709\u376C\0\0\0\u3787\u0272\u3656\0\0\u365Bget;\u6316;\u43C4r\xEB\u0E5F\u0180aey\u3666\u366B\u3670ron;\u4165dil;\u4163;\u4442lrec;\u6315r;\uC000\uD835\uDD31\u0200eiko\u3686\u369D\u36B5\u36BC\u01F2\u368B\0\u3691e\u01004f\u1284\u1281a\u0180;sv\u3698\u3699\u369B\u43B8ym;\u43D1\u0100cn\u36A2\u36B2k\u0100as\u36A8\u36AEppro\xF8\u12C1im\xBB\u12ACs\xF0\u129E\u0100as\u36BA\u36AE\xF0\u12C1rn\u803B\xFE\u40FE\u01EC\u031F\u36C6\u22E7es\u8180\xD7;bd\u36CF\u36D0\u36D8\u40D7\u0100;a\u190F\u36D5r;\u6A31;\u6A30\u0180eps\u36E1\u36E3\u3700\xE1\u2A4D\u0200;bcf\u0486\u36EC\u36F0\u36F4ot;\u6336ir;\u6AF1\u0100;o\u36F9\u36FC\uC000\uD835\uDD65rk;\u6ADA\xE1\u3362rime;\u6034\u0180aip\u370F\u3712\u3764d\xE5\u1248\u0380adempst\u3721\u374D\u3740\u3751\u3757\u375C\u375Fngle\u0280;dlqr\u3730\u3731\u3736\u3740\u3742\u65B5own\xBB\u1DBBeft\u0100;e\u2800\u373E\xF1\u092E;\u625Cight\u0100;e\u32AA\u374B\xF1\u105Aot;\u65ECinus;\u6A3Alus;\u6A39b;\u69CDime;\u6A3Bezium;\u63E2\u0180cht\u3772\u377D\u3781\u0100ry\u3777\u377B;\uC000\uD835\uDCC9;\u4446cy;\u445Brok;\u4167\u0100io\u378B\u378Ex\xF4\u1777head\u0100lr\u3797\u37A0eftarro\xF7\u084Fightarrow\xBB\u0F5D\u0900AHabcdfghlmoprstuw\u37D0\u37D3\u37D7\u37E4\u37F0\u37FC\u380E\u381C\u3823\u3834\u3851\u385D\u386B\u38A9\u38CC\u38D2\u38EA\u38F6r\xF2\u03EDar;\u6963\u0100cr\u37DC\u37E2ute\u803B\xFA\u40FA\xF2\u1150r\u01E3\u37EA\0\u37EDy;\u445Eve;\u416D\u0100iy\u37F5\u37FArc\u803B\xFB\u40FB;\u4443\u0180abh\u3803\u3806\u380Br\xF2\u13ADlac;\u4171a\xF2\u13C3\u0100ir\u3813\u3818sht;\u697E;\uC000\uD835\uDD32rave\u803B\xF9\u40F9\u0161\u3827\u3831r\u0100lr\u382C\u382E\xBB\u0957\xBB\u1083lk;\u6580\u0100ct\u3839\u384D\u026F\u383F\0\0\u384Arn\u0100;e\u3845\u3846\u631Cr\xBB\u3846op;\u630Fri;\u65F8\u0100al\u3856\u385Acr;\u416B\u80BB\xA8\u0349\u0100gp\u3862\u3866on;\u4173f;\uC000\uD835\uDD66\u0300adhlsu\u114B\u3878\u387D\u1372\u3891\u38A0own\xE1\u13B3arpoon\u0100lr\u3888\u388Cef\xF4\u382Digh\xF4\u382Fi\u0180;hl\u3899\u389A\u389C\u43C5\xBB\u13FAon\xBB\u389Aparrows;\u61C8\u0180cit\u38B0\u38C4\u38C8\u026F\u38B6\0\0\u38C1rn\u0100;e\u38BC\u38BD\u631Dr\xBB\u38BDop;\u630Eng;\u416Fri;\u65F9cr;\uC000\uD835\uDCCA\u0180dir\u38D9\u38DD\u38E2ot;\u62F0lde;\u4169i\u0100;f\u3730\u38E8\xBB\u1813\u0100am\u38EF\u38F2r\xF2\u38A8l\u803B\xFC\u40FCangle;\u69A7\u0780ABDacdeflnoprsz\u391C\u391F\u3929\u392D\u39B5\u39B8\u39BD\u39DF\u39E4\u39E8\u39F3\u39F9\u39FD\u3A01\u3A20r\xF2\u03F7ar\u0100;v\u3926\u3927\u6AE8;\u6AE9as\xE8\u03E1\u0100nr\u3932\u3937grt;\u699C\u0380eknprst\u34E3\u3946\u394B\u3952\u395D\u3964\u3996app\xE1\u2415othin\xE7\u1E96\u0180hir\u34EB\u2EC8\u3959op\xF4\u2FB5\u0100;h\u13B7\u3962\xEF\u318D\u0100iu\u3969\u396Dgm\xE1\u33B3\u0100bp\u3972\u3984setneq\u0100;q\u397D\u3980\uC000\u228A\uFE00;\uC000\u2ACB\uFE00setneq\u0100;q\u398F\u3992\uC000\u228B\uFE00;\uC000\u2ACC\uFE00\u0100hr\u399B\u399Fet\xE1\u369Ciangle\u0100lr\u39AA\u39AFeft\xBB\u0925ight\xBB\u1051y;\u4432ash\xBB\u1036\u0180elr\u39C4\u39D2\u39D7\u0180;be\u2DEA\u39CB\u39CFar;\u62BBq;\u625Alip;\u62EE\u0100bt\u39DC\u1468a\xF2\u1469r;\uC000\uD835\uDD33tr\xE9\u39AEsu\u0100bp\u39EF\u39F1\xBB\u0D1C\xBB\u0D59pf;\uC000\uD835\uDD67ro\xF0\u0EFBtr\xE9\u39B4\u0100cu\u3A06\u3A0Br;\uC000\uD835\uDCCB\u0100bp\u3A10\u3A18n\u0100Ee\u3980\u3A16\xBB\u397En\u0100Ee\u3992\u3A1E\xBB\u3990igzag;\u699A\u0380cefoprs\u3A36\u3A3B\u3A56\u3A5B\u3A54\u3A61\u3A6Airc;\u4175\u0100di\u3A40\u3A51\u0100bg\u3A45\u3A49ar;\u6A5Fe\u0100;q\u15FA\u3A4F;\u6259erp;\u6118r;\uC000\uD835\uDD34pf;\uC000\uD835\uDD68\u0100;e\u1479\u3A66at\xE8\u1479cr;\uC000\uD835\uDCCC\u0AE3\u178E\u3A87\0\u3A8B\0\u3A90\u3A9B\0\0\u3A9D\u3AA8\u3AAB\u3AAF\0\0\u3AC3\u3ACE\0\u3AD8\u17DC\u17DFtr\xE9\u17D1r;\uC000\uD835\uDD35\u0100Aa\u3A94\u3A97r\xF2\u03C3r\xF2\u09F6;\u43BE\u0100Aa\u3AA1\u3AA4r\xF2\u03B8r\xF2\u09EBa\xF0\u2713is;\u62FB\u0180dpt\u17A4\u3AB5\u3ABE\u0100fl\u3ABA\u17A9;\uC000\uD835\uDD69im\xE5\u17B2\u0100Aa\u3AC7\u3ACAr\xF2\u03CEr\xF2\u0A01\u0100cq\u3AD2\u17B8r;\uC000\uD835\uDCCD\u0100pt\u17D6\u3ADCr\xE9\u17D4\u0400acefiosu\u3AF0\u3AFD\u3B08\u3B0C\u3B11\u3B15\u3B1B\u3B21c\u0100uy\u3AF6\u3AFBte\u803B\xFD\u40FD;\u444F\u0100iy\u3B02\u3B06rc;\u4177;\u444Bn\u803B\xA5\u40A5r;\uC000\uD835\uDD36cy;\u4457pf;\uC000\uD835\uDD6Acr;\uC000\uD835\uDCCE\u0100cm\u3B26\u3B29y;\u444El\u803B\xFF\u40FF\u0500acdefhiosw\u3B42\u3B48\u3B54\u3B58\u3B64\u3B69\u3B6D\u3B74\u3B7A\u3B80cute;\u417A\u0100ay\u3B4D\u3B52ron;\u417E;\u4437ot;\u417C\u0100et\u3B5D\u3B61tr\xE6\u155Fa;\u43B6r;\uC000\uD835\uDD37cy;\u4436grarr;\u61DDpf;\uC000\uD835\uDD6Bcr;\uC000\uD835\uDCCF\u0100jn\u3B85\u3B87;\u600Dj;\u600C'.split("").map(function(c) {
|
|
return c.charCodeAt(0);
|
|
}));
|
|
});
|
|
|
|
// node_modules/entities/lib/generated/decode-data-xml.js
|
|
var require_decode_data_xml = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = new Uint16Array("\u0200aglq\t\x15\x18\x1B\u026D\x0F\0\0\x12p;\u4026os;\u4027t;\u403Et;\u403Cuot;\u4022".split("").map(function(c) {
|
|
return c.charCodeAt(0);
|
|
}));
|
|
});
|
|
|
|
// node_modules/entities/lib/decode_codepoint.js
|
|
var require_decode_codepoint = __commonJS((exports) => {
|
|
var _a;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.replaceCodePoint = exports.fromCodePoint = undefined;
|
|
var decodeMap = new Map([
|
|
[0, 65533],
|
|
[128, 8364],
|
|
[130, 8218],
|
|
[131, 402],
|
|
[132, 8222],
|
|
[133, 8230],
|
|
[134, 8224],
|
|
[135, 8225],
|
|
[136, 710],
|
|
[137, 8240],
|
|
[138, 352],
|
|
[139, 8249],
|
|
[140, 338],
|
|
[142, 381],
|
|
[145, 8216],
|
|
[146, 8217],
|
|
[147, 8220],
|
|
[148, 8221],
|
|
[149, 8226],
|
|
[150, 8211],
|
|
[151, 8212],
|
|
[152, 732],
|
|
[153, 8482],
|
|
[154, 353],
|
|
[155, 8250],
|
|
[156, 339],
|
|
[158, 382],
|
|
[159, 376]
|
|
]);
|
|
exports.fromCodePoint = (_a = String.fromCodePoint) !== null && _a !== undefined ? _a : function(codePoint) {
|
|
var output = "";
|
|
if (codePoint > 65535) {
|
|
codePoint -= 65536;
|
|
output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
|
|
codePoint = 56320 | codePoint & 1023;
|
|
}
|
|
output += String.fromCharCode(codePoint);
|
|
return output;
|
|
};
|
|
function replaceCodePoint(codePoint) {
|
|
var _a2;
|
|
if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
|
|
return 65533;
|
|
}
|
|
return (_a2 = decodeMap.get(codePoint)) !== null && _a2 !== undefined ? _a2 : codePoint;
|
|
}
|
|
exports.replaceCodePoint = replaceCodePoint;
|
|
function decodeCodePoint(codePoint) {
|
|
return (0, exports.fromCodePoint)(replaceCodePoint(codePoint));
|
|
}
|
|
exports.default = decodeCodePoint;
|
|
});
|
|
|
|
// node_modules/entities/lib/decode.js
|
|
var require_decode = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__importStar || function(mod) {
|
|
if (mod && mod.__esModule)
|
|
return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod)
|
|
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
|
|
__createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.decodeXML = exports.decodeHTMLStrict = exports.decodeHTMLAttribute = exports.decodeHTML = exports.determineBranch = exports.EntityDecoder = exports.DecodingMode = exports.BinTrieFlags = exports.fromCodePoint = exports.replaceCodePoint = exports.decodeCodePoint = exports.xmlDecodeTree = exports.htmlDecodeTree = undefined;
|
|
var decode_data_html_js_1 = __importDefault(require_decode_data_html());
|
|
exports.htmlDecodeTree = decode_data_html_js_1.default;
|
|
var decode_data_xml_js_1 = __importDefault(require_decode_data_xml());
|
|
exports.xmlDecodeTree = decode_data_xml_js_1.default;
|
|
var decode_codepoint_js_1 = __importStar(require_decode_codepoint());
|
|
exports.decodeCodePoint = decode_codepoint_js_1.default;
|
|
var decode_codepoint_js_2 = require_decode_codepoint();
|
|
Object.defineProperty(exports, "replaceCodePoint", { enumerable: true, get: function() {
|
|
return decode_codepoint_js_2.replaceCodePoint;
|
|
} });
|
|
Object.defineProperty(exports, "fromCodePoint", { enumerable: true, get: function() {
|
|
return decode_codepoint_js_2.fromCodePoint;
|
|
} });
|
|
var CharCodes;
|
|
(function(CharCodes2) {
|
|
CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
|
|
CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
|
|
CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
|
|
CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
|
|
CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
|
|
CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
|
|
CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
|
|
CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
|
|
CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
|
|
CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
|
|
CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
|
|
CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
|
|
})(CharCodes || (CharCodes = {}));
|
|
var TO_LOWER_BIT = 32;
|
|
var BinTrieFlags;
|
|
(function(BinTrieFlags2) {
|
|
BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
|
|
BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
|
|
BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
|
|
})(BinTrieFlags = exports.BinTrieFlags || (exports.BinTrieFlags = {}));
|
|
function isNumber(code) {
|
|
return code >= CharCodes.ZERO && code <= CharCodes.NINE;
|
|
}
|
|
function isHexadecimalCharacter(code) {
|
|
return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
|
|
}
|
|
function isAsciiAlphaNumeric(code) {
|
|
return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);
|
|
}
|
|
function isEntityInAttributeInvalidEnd(code) {
|
|
return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
|
|
}
|
|
var EntityDecoderState;
|
|
(function(EntityDecoderState2) {
|
|
EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
|
|
EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
|
|
EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
|
|
EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
|
|
EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
|
|
})(EntityDecoderState || (EntityDecoderState = {}));
|
|
var DecodingMode;
|
|
(function(DecodingMode2) {
|
|
DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
|
|
DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
|
|
DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
|
|
})(DecodingMode = exports.DecodingMode || (exports.DecodingMode = {}));
|
|
var EntityDecoder = function() {
|
|
function EntityDecoder2(decodeTree, emitCodePoint, errors) {
|
|
this.decodeTree = decodeTree;
|
|
this.emitCodePoint = emitCodePoint;
|
|
this.errors = errors;
|
|
this.state = EntityDecoderState.EntityStart;
|
|
this.consumed = 1;
|
|
this.result = 0;
|
|
this.treeIndex = 0;
|
|
this.excess = 1;
|
|
this.decodeMode = DecodingMode.Strict;
|
|
}
|
|
EntityDecoder2.prototype.startEntity = function(decodeMode) {
|
|
this.decodeMode = decodeMode;
|
|
this.state = EntityDecoderState.EntityStart;
|
|
this.result = 0;
|
|
this.treeIndex = 0;
|
|
this.excess = 1;
|
|
this.consumed = 1;
|
|
};
|
|
EntityDecoder2.prototype.write = function(str, offset) {
|
|
switch (this.state) {
|
|
case EntityDecoderState.EntityStart: {
|
|
if (str.charCodeAt(offset) === CharCodes.NUM) {
|
|
this.state = EntityDecoderState.NumericStart;
|
|
this.consumed += 1;
|
|
return this.stateNumericStart(str, offset + 1);
|
|
}
|
|
this.state = EntityDecoderState.NamedEntity;
|
|
return this.stateNamedEntity(str, offset);
|
|
}
|
|
case EntityDecoderState.NumericStart: {
|
|
return this.stateNumericStart(str, offset);
|
|
}
|
|
case EntityDecoderState.NumericDecimal: {
|
|
return this.stateNumericDecimal(str, offset);
|
|
}
|
|
case EntityDecoderState.NumericHex: {
|
|
return this.stateNumericHex(str, offset);
|
|
}
|
|
case EntityDecoderState.NamedEntity: {
|
|
return this.stateNamedEntity(str, offset);
|
|
}
|
|
}
|
|
};
|
|
EntityDecoder2.prototype.stateNumericStart = function(str, offset) {
|
|
if (offset >= str.length) {
|
|
return -1;
|
|
}
|
|
if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
|
|
this.state = EntityDecoderState.NumericHex;
|
|
this.consumed += 1;
|
|
return this.stateNumericHex(str, offset + 1);
|
|
}
|
|
this.state = EntityDecoderState.NumericDecimal;
|
|
return this.stateNumericDecimal(str, offset);
|
|
};
|
|
EntityDecoder2.prototype.addToNumericResult = function(str, start, end, base) {
|
|
if (start !== end) {
|
|
var digitCount = end - start;
|
|
this.result = this.result * Math.pow(base, digitCount) + parseInt(str.substr(start, digitCount), base);
|
|
this.consumed += digitCount;
|
|
}
|
|
};
|
|
EntityDecoder2.prototype.stateNumericHex = function(str, offset) {
|
|
var startIdx = offset;
|
|
while (offset < str.length) {
|
|
var char = str.charCodeAt(offset);
|
|
if (isNumber(char) || isHexadecimalCharacter(char)) {
|
|
offset += 1;
|
|
} else {
|
|
this.addToNumericResult(str, startIdx, offset, 16);
|
|
return this.emitNumericEntity(char, 3);
|
|
}
|
|
}
|
|
this.addToNumericResult(str, startIdx, offset, 16);
|
|
return -1;
|
|
};
|
|
EntityDecoder2.prototype.stateNumericDecimal = function(str, offset) {
|
|
var startIdx = offset;
|
|
while (offset < str.length) {
|
|
var char = str.charCodeAt(offset);
|
|
if (isNumber(char)) {
|
|
offset += 1;
|
|
} else {
|
|
this.addToNumericResult(str, startIdx, offset, 10);
|
|
return this.emitNumericEntity(char, 2);
|
|
}
|
|
}
|
|
this.addToNumericResult(str, startIdx, offset, 10);
|
|
return -1;
|
|
};
|
|
EntityDecoder2.prototype.emitNumericEntity = function(lastCp, expectedLength) {
|
|
var _a;
|
|
if (this.consumed <= expectedLength) {
|
|
(_a = this.errors) === null || _a === undefined || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
|
|
return 0;
|
|
}
|
|
if (lastCp === CharCodes.SEMI) {
|
|
this.consumed += 1;
|
|
} else if (this.decodeMode === DecodingMode.Strict) {
|
|
return 0;
|
|
}
|
|
this.emitCodePoint((0, decode_codepoint_js_1.replaceCodePoint)(this.result), this.consumed);
|
|
if (this.errors) {
|
|
if (lastCp !== CharCodes.SEMI) {
|
|
this.errors.missingSemicolonAfterCharacterReference();
|
|
}
|
|
this.errors.validateNumericCharacterReference(this.result);
|
|
}
|
|
return this.consumed;
|
|
};
|
|
EntityDecoder2.prototype.stateNamedEntity = function(str, offset) {
|
|
var decodeTree = this.decodeTree;
|
|
var current = decodeTree[this.treeIndex];
|
|
var valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
|
|
for (;offset < str.length; offset++, this.excess++) {
|
|
var char = str.charCodeAt(offset);
|
|
this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
|
|
if (this.treeIndex < 0) {
|
|
return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
|
|
}
|
|
current = decodeTree[this.treeIndex];
|
|
valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
|
|
if (valueLength !== 0) {
|
|
if (char === CharCodes.SEMI) {
|
|
return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
|
|
}
|
|
if (this.decodeMode !== DecodingMode.Strict) {
|
|
this.result = this.treeIndex;
|
|
this.consumed += this.excess;
|
|
this.excess = 0;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
EntityDecoder2.prototype.emitNotTerminatedNamedEntity = function() {
|
|
var _a;
|
|
var _b = this, result = _b.result, decodeTree = _b.decodeTree;
|
|
var valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
|
|
this.emitNamedEntityData(result, valueLength, this.consumed);
|
|
(_a = this.errors) === null || _a === undefined || _a.missingSemicolonAfterCharacterReference();
|
|
return this.consumed;
|
|
};
|
|
EntityDecoder2.prototype.emitNamedEntityData = function(result, valueLength, consumed) {
|
|
var decodeTree = this.decodeTree;
|
|
this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH : decodeTree[result + 1], consumed);
|
|
if (valueLength === 3) {
|
|
this.emitCodePoint(decodeTree[result + 2], consumed);
|
|
}
|
|
return consumed;
|
|
};
|
|
EntityDecoder2.prototype.end = function() {
|
|
var _a;
|
|
switch (this.state) {
|
|
case EntityDecoderState.NamedEntity: {
|
|
return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
|
|
}
|
|
case EntityDecoderState.NumericDecimal: {
|
|
return this.emitNumericEntity(0, 2);
|
|
}
|
|
case EntityDecoderState.NumericHex: {
|
|
return this.emitNumericEntity(0, 3);
|
|
}
|
|
case EntityDecoderState.NumericStart: {
|
|
(_a = this.errors) === null || _a === undefined || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
|
|
return 0;
|
|
}
|
|
case EntityDecoderState.EntityStart: {
|
|
return 0;
|
|
}
|
|
}
|
|
};
|
|
return EntityDecoder2;
|
|
}();
|
|
exports.EntityDecoder = EntityDecoder;
|
|
function getDecoder(decodeTree) {
|
|
var ret = "";
|
|
var decoder = new EntityDecoder(decodeTree, function(str) {
|
|
return ret += (0, decode_codepoint_js_1.fromCodePoint)(str);
|
|
});
|
|
return function decodeWithTrie(str, decodeMode) {
|
|
var lastIndex = 0;
|
|
var offset = 0;
|
|
while ((offset = str.indexOf("&", offset)) >= 0) {
|
|
ret += str.slice(lastIndex, offset);
|
|
decoder.startEntity(decodeMode);
|
|
var len = decoder.write(str, offset + 1);
|
|
if (len < 0) {
|
|
lastIndex = offset + decoder.end();
|
|
break;
|
|
}
|
|
lastIndex = offset + len;
|
|
offset = len === 0 ? lastIndex + 1 : lastIndex;
|
|
}
|
|
var result = ret + str.slice(lastIndex);
|
|
ret = "";
|
|
return result;
|
|
};
|
|
}
|
|
function determineBranch(decodeTree, current, nodeIdx, char) {
|
|
var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
|
|
var jumpOffset = current & BinTrieFlags.JUMP_TABLE;
|
|
if (branchCount === 0) {
|
|
return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
|
|
}
|
|
if (jumpOffset) {
|
|
var value = char - jumpOffset;
|
|
return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIdx + value] - 1;
|
|
}
|
|
var lo = nodeIdx;
|
|
var hi = lo + branchCount - 1;
|
|
while (lo <= hi) {
|
|
var mid = lo + hi >>> 1;
|
|
var midVal = decodeTree[mid];
|
|
if (midVal < char) {
|
|
lo = mid + 1;
|
|
} else if (midVal > char) {
|
|
hi = mid - 1;
|
|
} else {
|
|
return decodeTree[mid + branchCount];
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
exports.determineBranch = determineBranch;
|
|
var htmlDecoder = getDecoder(decode_data_html_js_1.default);
|
|
var xmlDecoder = getDecoder(decode_data_xml_js_1.default);
|
|
function decodeHTML(str, mode) {
|
|
if (mode === undefined) {
|
|
mode = DecodingMode.Legacy;
|
|
}
|
|
return htmlDecoder(str, mode);
|
|
}
|
|
exports.decodeHTML = decodeHTML;
|
|
function decodeHTMLAttribute(str) {
|
|
return htmlDecoder(str, DecodingMode.Attribute);
|
|
}
|
|
exports.decodeHTMLAttribute = decodeHTMLAttribute;
|
|
function decodeHTMLStrict(str) {
|
|
return htmlDecoder(str, DecodingMode.Strict);
|
|
}
|
|
exports.decodeHTMLStrict = decodeHTMLStrict;
|
|
function decodeXML(str) {
|
|
return xmlDecoder(str, DecodingMode.Strict);
|
|
}
|
|
exports.decodeXML = decodeXML;
|
|
});
|
|
|
|
// node_modules/htmlparser2/lib/Tokenizer.js
|
|
var require_Tokenizer = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.QuoteType = undefined;
|
|
var decode_js_1 = require_decode();
|
|
var CharCodes;
|
|
(function(CharCodes2) {
|
|
CharCodes2[CharCodes2["Tab"] = 9] = "Tab";
|
|
CharCodes2[CharCodes2["NewLine"] = 10] = "NewLine";
|
|
CharCodes2[CharCodes2["FormFeed"] = 12] = "FormFeed";
|
|
CharCodes2[CharCodes2["CarriageReturn"] = 13] = "CarriageReturn";
|
|
CharCodes2[CharCodes2["Space"] = 32] = "Space";
|
|
CharCodes2[CharCodes2["ExclamationMark"] = 33] = "ExclamationMark";
|
|
CharCodes2[CharCodes2["Number"] = 35] = "Number";
|
|
CharCodes2[CharCodes2["Amp"] = 38] = "Amp";
|
|
CharCodes2[CharCodes2["SingleQuote"] = 39] = "SingleQuote";
|
|
CharCodes2[CharCodes2["DoubleQuote"] = 34] = "DoubleQuote";
|
|
CharCodes2[CharCodes2["Dash"] = 45] = "Dash";
|
|
CharCodes2[CharCodes2["Slash"] = 47] = "Slash";
|
|
CharCodes2[CharCodes2["Zero"] = 48] = "Zero";
|
|
CharCodes2[CharCodes2["Nine"] = 57] = "Nine";
|
|
CharCodes2[CharCodes2["Semi"] = 59] = "Semi";
|
|
CharCodes2[CharCodes2["Lt"] = 60] = "Lt";
|
|
CharCodes2[CharCodes2["Eq"] = 61] = "Eq";
|
|
CharCodes2[CharCodes2["Gt"] = 62] = "Gt";
|
|
CharCodes2[CharCodes2["Questionmark"] = 63] = "Questionmark";
|
|
CharCodes2[CharCodes2["UpperA"] = 65] = "UpperA";
|
|
CharCodes2[CharCodes2["LowerA"] = 97] = "LowerA";
|
|
CharCodes2[CharCodes2["UpperF"] = 70] = "UpperF";
|
|
CharCodes2[CharCodes2["LowerF"] = 102] = "LowerF";
|
|
CharCodes2[CharCodes2["UpperZ"] = 90] = "UpperZ";
|
|
CharCodes2[CharCodes2["LowerZ"] = 122] = "LowerZ";
|
|
CharCodes2[CharCodes2["LowerX"] = 120] = "LowerX";
|
|
CharCodes2[CharCodes2["OpeningSquareBracket"] = 91] = "OpeningSquareBracket";
|
|
})(CharCodes || (CharCodes = {}));
|
|
var State;
|
|
(function(State2) {
|
|
State2[State2["Text"] = 1] = "Text";
|
|
State2[State2["BeforeTagName"] = 2] = "BeforeTagName";
|
|
State2[State2["InTagName"] = 3] = "InTagName";
|
|
State2[State2["InSelfClosingTag"] = 4] = "InSelfClosingTag";
|
|
State2[State2["BeforeClosingTagName"] = 5] = "BeforeClosingTagName";
|
|
State2[State2["InClosingTagName"] = 6] = "InClosingTagName";
|
|
State2[State2["AfterClosingTagName"] = 7] = "AfterClosingTagName";
|
|
State2[State2["BeforeAttributeName"] = 8] = "BeforeAttributeName";
|
|
State2[State2["InAttributeName"] = 9] = "InAttributeName";
|
|
State2[State2["AfterAttributeName"] = 10] = "AfterAttributeName";
|
|
State2[State2["BeforeAttributeValue"] = 11] = "BeforeAttributeValue";
|
|
State2[State2["InAttributeValueDq"] = 12] = "InAttributeValueDq";
|
|
State2[State2["InAttributeValueSq"] = 13] = "InAttributeValueSq";
|
|
State2[State2["InAttributeValueNq"] = 14] = "InAttributeValueNq";
|
|
State2[State2["BeforeDeclaration"] = 15] = "BeforeDeclaration";
|
|
State2[State2["InDeclaration"] = 16] = "InDeclaration";
|
|
State2[State2["InProcessingInstruction"] = 17] = "InProcessingInstruction";
|
|
State2[State2["BeforeComment"] = 18] = "BeforeComment";
|
|
State2[State2["CDATASequence"] = 19] = "CDATASequence";
|
|
State2[State2["InSpecialComment"] = 20] = "InSpecialComment";
|
|
State2[State2["InCommentLike"] = 21] = "InCommentLike";
|
|
State2[State2["BeforeSpecialS"] = 22] = "BeforeSpecialS";
|
|
State2[State2["SpecialStartSequence"] = 23] = "SpecialStartSequence";
|
|
State2[State2["InSpecialTag"] = 24] = "InSpecialTag";
|
|
State2[State2["BeforeEntity"] = 25] = "BeforeEntity";
|
|
State2[State2["BeforeNumericEntity"] = 26] = "BeforeNumericEntity";
|
|
State2[State2["InNamedEntity"] = 27] = "InNamedEntity";
|
|
State2[State2["InNumericEntity"] = 28] = "InNumericEntity";
|
|
State2[State2["InHexEntity"] = 29] = "InHexEntity";
|
|
})(State || (State = {}));
|
|
function isWhitespace(c) {
|
|
return c === CharCodes.Space || c === CharCodes.NewLine || c === CharCodes.Tab || c === CharCodes.FormFeed || c === CharCodes.CarriageReturn;
|
|
}
|
|
function isEndOfTagSection(c) {
|
|
return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);
|
|
}
|
|
function isNumber(c) {
|
|
return c >= CharCodes.Zero && c <= CharCodes.Nine;
|
|
}
|
|
function isASCIIAlpha(c) {
|
|
return c >= CharCodes.LowerA && c <= CharCodes.LowerZ || c >= CharCodes.UpperA && c <= CharCodes.UpperZ;
|
|
}
|
|
function isHexDigit(c) {
|
|
return c >= CharCodes.UpperA && c <= CharCodes.UpperF || c >= CharCodes.LowerA && c <= CharCodes.LowerF;
|
|
}
|
|
var QuoteType;
|
|
(function(QuoteType2) {
|
|
QuoteType2[QuoteType2["NoValue"] = 0] = "NoValue";
|
|
QuoteType2[QuoteType2["Unquoted"] = 1] = "Unquoted";
|
|
QuoteType2[QuoteType2["Single"] = 2] = "Single";
|
|
QuoteType2[QuoteType2["Double"] = 3] = "Double";
|
|
})(QuoteType = exports.QuoteType || (exports.QuoteType = {}));
|
|
var Sequences = {
|
|
Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
|
|
CdataEnd: new Uint8Array([93, 93, 62]),
|
|
CommentEnd: new Uint8Array([45, 45, 62]),
|
|
ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
|
|
StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
|
|
TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101])
|
|
};
|
|
var Tokenizer = function() {
|
|
function Tokenizer2(_a, cbs) {
|
|
var _b = _a.xmlMode, xmlMode = _b === undefined ? false : _b, _c = _a.decodeEntities, decodeEntities = _c === undefined ? true : _c;
|
|
this.cbs = cbs;
|
|
this.state = State.Text;
|
|
this.buffer = "";
|
|
this.sectionStart = 0;
|
|
this.index = 0;
|
|
this.baseState = State.Text;
|
|
this.isSpecial = false;
|
|
this.running = true;
|
|
this.offset = 0;
|
|
this.currentSequence = undefined;
|
|
this.sequenceIndex = 0;
|
|
this.trieIndex = 0;
|
|
this.trieCurrent = 0;
|
|
this.entityResult = 0;
|
|
this.entityExcess = 0;
|
|
this.xmlMode = xmlMode;
|
|
this.decodeEntities = decodeEntities;
|
|
this.entityTrie = xmlMode ? decode_js_1.xmlDecodeTree : decode_js_1.htmlDecodeTree;
|
|
}
|
|
Tokenizer2.prototype.reset = function() {
|
|
this.state = State.Text;
|
|
this.buffer = "";
|
|
this.sectionStart = 0;
|
|
this.index = 0;
|
|
this.baseState = State.Text;
|
|
this.currentSequence = undefined;
|
|
this.running = true;
|
|
this.offset = 0;
|
|
};
|
|
Tokenizer2.prototype.write = function(chunk) {
|
|
this.offset += this.buffer.length;
|
|
this.buffer = chunk;
|
|
this.parse();
|
|
};
|
|
Tokenizer2.prototype.end = function() {
|
|
if (this.running)
|
|
this.finish();
|
|
};
|
|
Tokenizer2.prototype.pause = function() {
|
|
this.running = false;
|
|
};
|
|
Tokenizer2.prototype.resume = function() {
|
|
this.running = true;
|
|
if (this.index < this.buffer.length + this.offset) {
|
|
this.parse();
|
|
}
|
|
};
|
|
Tokenizer2.prototype.getIndex = function() {
|
|
return this.index;
|
|
};
|
|
Tokenizer2.prototype.getSectionStart = function() {
|
|
return this.sectionStart;
|
|
};
|
|
Tokenizer2.prototype.stateText = function(c) {
|
|
if (c === CharCodes.Lt || !this.decodeEntities && this.fastForwardTo(CharCodes.Lt)) {
|
|
if (this.index > this.sectionStart) {
|
|
this.cbs.ontext(this.sectionStart, this.index);
|
|
}
|
|
this.state = State.BeforeTagName;
|
|
this.sectionStart = this.index;
|
|
} else if (this.decodeEntities && c === CharCodes.Amp) {
|
|
this.state = State.BeforeEntity;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateSpecialStartSequence = function(c) {
|
|
var isEnd = this.sequenceIndex === this.currentSequence.length;
|
|
var isMatch = isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex];
|
|
if (!isMatch) {
|
|
this.isSpecial = false;
|
|
} else if (!isEnd) {
|
|
this.sequenceIndex++;
|
|
return;
|
|
}
|
|
this.sequenceIndex = 0;
|
|
this.state = State.InTagName;
|
|
this.stateInTagName(c);
|
|
};
|
|
Tokenizer2.prototype.stateInSpecialTag = function(c) {
|
|
if (this.sequenceIndex === this.currentSequence.length) {
|
|
if (c === CharCodes.Gt || isWhitespace(c)) {
|
|
var endOfText = this.index - this.currentSequence.length;
|
|
if (this.sectionStart < endOfText) {
|
|
var actualIndex = this.index;
|
|
this.index = endOfText;
|
|
this.cbs.ontext(this.sectionStart, endOfText);
|
|
this.index = actualIndex;
|
|
}
|
|
this.isSpecial = false;
|
|
this.sectionStart = endOfText + 2;
|
|
this.stateInClosingTagName(c);
|
|
return;
|
|
}
|
|
this.sequenceIndex = 0;
|
|
}
|
|
if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
|
|
this.sequenceIndex += 1;
|
|
} else if (this.sequenceIndex === 0) {
|
|
if (this.currentSequence === Sequences.TitleEnd) {
|
|
if (this.decodeEntities && c === CharCodes.Amp) {
|
|
this.state = State.BeforeEntity;
|
|
}
|
|
} else if (this.fastForwardTo(CharCodes.Lt)) {
|
|
this.sequenceIndex = 1;
|
|
}
|
|
} else {
|
|
this.sequenceIndex = Number(c === CharCodes.Lt);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateCDATASequence = function(c) {
|
|
if (c === Sequences.Cdata[this.sequenceIndex]) {
|
|
if (++this.sequenceIndex === Sequences.Cdata.length) {
|
|
this.state = State.InCommentLike;
|
|
this.currentSequence = Sequences.CdataEnd;
|
|
this.sequenceIndex = 0;
|
|
this.sectionStart = this.index + 1;
|
|
}
|
|
} else {
|
|
this.sequenceIndex = 0;
|
|
this.state = State.InDeclaration;
|
|
this.stateInDeclaration(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.fastForwardTo = function(c) {
|
|
while (++this.index < this.buffer.length + this.offset) {
|
|
if (this.buffer.charCodeAt(this.index - this.offset) === c) {
|
|
return true;
|
|
}
|
|
}
|
|
this.index = this.buffer.length + this.offset - 1;
|
|
return false;
|
|
};
|
|
Tokenizer2.prototype.stateInCommentLike = function(c) {
|
|
if (c === this.currentSequence[this.sequenceIndex]) {
|
|
if (++this.sequenceIndex === this.currentSequence.length) {
|
|
if (this.currentSequence === Sequences.CdataEnd) {
|
|
this.cbs.oncdata(this.sectionStart, this.index, 2);
|
|
} else {
|
|
this.cbs.oncomment(this.sectionStart, this.index, 2);
|
|
}
|
|
this.sequenceIndex = 0;
|
|
this.sectionStart = this.index + 1;
|
|
this.state = State.Text;
|
|
}
|
|
} else if (this.sequenceIndex === 0) {
|
|
if (this.fastForwardTo(this.currentSequence[0])) {
|
|
this.sequenceIndex = 1;
|
|
}
|
|
} else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
|
|
this.sequenceIndex = 0;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.isTagStartChar = function(c) {
|
|
return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);
|
|
};
|
|
Tokenizer2.prototype.startSpecial = function(sequence, offset) {
|
|
this.isSpecial = true;
|
|
this.currentSequence = sequence;
|
|
this.sequenceIndex = offset;
|
|
this.state = State.SpecialStartSequence;
|
|
};
|
|
Tokenizer2.prototype.stateBeforeTagName = function(c) {
|
|
if (c === CharCodes.ExclamationMark) {
|
|
this.state = State.BeforeDeclaration;
|
|
this.sectionStart = this.index + 1;
|
|
} else if (c === CharCodes.Questionmark) {
|
|
this.state = State.InProcessingInstruction;
|
|
this.sectionStart = this.index + 1;
|
|
} else if (this.isTagStartChar(c)) {
|
|
var lower = c | 32;
|
|
this.sectionStart = this.index;
|
|
if (!this.xmlMode && lower === Sequences.TitleEnd[2]) {
|
|
this.startSpecial(Sequences.TitleEnd, 3);
|
|
} else {
|
|
this.state = !this.xmlMode && lower === Sequences.ScriptEnd[2] ? State.BeforeSpecialS : State.InTagName;
|
|
}
|
|
} else if (c === CharCodes.Slash) {
|
|
this.state = State.BeforeClosingTagName;
|
|
} else {
|
|
this.state = State.Text;
|
|
this.stateText(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInTagName = function(c) {
|
|
if (isEndOfTagSection(c)) {
|
|
this.cbs.onopentagname(this.sectionStart, this.index);
|
|
this.sectionStart = -1;
|
|
this.state = State.BeforeAttributeName;
|
|
this.stateBeforeAttributeName(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeClosingTagName = function(c) {
|
|
if (isWhitespace(c)) {
|
|
} else if (c === CharCodes.Gt) {
|
|
this.state = State.Text;
|
|
} else {
|
|
this.state = this.isTagStartChar(c) ? State.InClosingTagName : State.InSpecialComment;
|
|
this.sectionStart = this.index;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInClosingTagName = function(c) {
|
|
if (c === CharCodes.Gt || isWhitespace(c)) {
|
|
this.cbs.onclosetag(this.sectionStart, this.index);
|
|
this.sectionStart = -1;
|
|
this.state = State.AfterClosingTagName;
|
|
this.stateAfterClosingTagName(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateAfterClosingTagName = function(c) {
|
|
if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
|
|
this.state = State.Text;
|
|
this.baseState = State.Text;
|
|
this.sectionStart = this.index + 1;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeAttributeName = function(c) {
|
|
if (c === CharCodes.Gt) {
|
|
this.cbs.onopentagend(this.index);
|
|
if (this.isSpecial) {
|
|
this.state = State.InSpecialTag;
|
|
this.sequenceIndex = 0;
|
|
} else {
|
|
this.state = State.Text;
|
|
}
|
|
this.baseState = this.state;
|
|
this.sectionStart = this.index + 1;
|
|
} else if (c === CharCodes.Slash) {
|
|
this.state = State.InSelfClosingTag;
|
|
} else if (!isWhitespace(c)) {
|
|
this.state = State.InAttributeName;
|
|
this.sectionStart = this.index;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInSelfClosingTag = function(c) {
|
|
if (c === CharCodes.Gt) {
|
|
this.cbs.onselfclosingtag(this.index);
|
|
this.state = State.Text;
|
|
this.baseState = State.Text;
|
|
this.sectionStart = this.index + 1;
|
|
this.isSpecial = false;
|
|
} else if (!isWhitespace(c)) {
|
|
this.state = State.BeforeAttributeName;
|
|
this.stateBeforeAttributeName(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInAttributeName = function(c) {
|
|
if (c === CharCodes.Eq || isEndOfTagSection(c)) {
|
|
this.cbs.onattribname(this.sectionStart, this.index);
|
|
this.sectionStart = -1;
|
|
this.state = State.AfterAttributeName;
|
|
this.stateAfterAttributeName(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateAfterAttributeName = function(c) {
|
|
if (c === CharCodes.Eq) {
|
|
this.state = State.BeforeAttributeValue;
|
|
} else if (c === CharCodes.Slash || c === CharCodes.Gt) {
|
|
this.cbs.onattribend(QuoteType.NoValue, this.index);
|
|
this.state = State.BeforeAttributeName;
|
|
this.stateBeforeAttributeName(c);
|
|
} else if (!isWhitespace(c)) {
|
|
this.cbs.onattribend(QuoteType.NoValue, this.index);
|
|
this.state = State.InAttributeName;
|
|
this.sectionStart = this.index;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeAttributeValue = function(c) {
|
|
if (c === CharCodes.DoubleQuote) {
|
|
this.state = State.InAttributeValueDq;
|
|
this.sectionStart = this.index + 1;
|
|
} else if (c === CharCodes.SingleQuote) {
|
|
this.state = State.InAttributeValueSq;
|
|
this.sectionStart = this.index + 1;
|
|
} else if (!isWhitespace(c)) {
|
|
this.sectionStart = this.index;
|
|
this.state = State.InAttributeValueNq;
|
|
this.stateInAttributeValueNoQuotes(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.handleInAttributeValue = function(c, quote) {
|
|
if (c === quote || !this.decodeEntities && this.fastForwardTo(quote)) {
|
|
this.cbs.onattribdata(this.sectionStart, this.index);
|
|
this.sectionStart = -1;
|
|
this.cbs.onattribend(quote === CharCodes.DoubleQuote ? QuoteType.Double : QuoteType.Single, this.index);
|
|
this.state = State.BeforeAttributeName;
|
|
} else if (this.decodeEntities && c === CharCodes.Amp) {
|
|
this.baseState = this.state;
|
|
this.state = State.BeforeEntity;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInAttributeValueDoubleQuotes = function(c) {
|
|
this.handleInAttributeValue(c, CharCodes.DoubleQuote);
|
|
};
|
|
Tokenizer2.prototype.stateInAttributeValueSingleQuotes = function(c) {
|
|
this.handleInAttributeValue(c, CharCodes.SingleQuote);
|
|
};
|
|
Tokenizer2.prototype.stateInAttributeValueNoQuotes = function(c) {
|
|
if (isWhitespace(c) || c === CharCodes.Gt) {
|
|
this.cbs.onattribdata(this.sectionStart, this.index);
|
|
this.sectionStart = -1;
|
|
this.cbs.onattribend(QuoteType.Unquoted, this.index);
|
|
this.state = State.BeforeAttributeName;
|
|
this.stateBeforeAttributeName(c);
|
|
} else if (this.decodeEntities && c === CharCodes.Amp) {
|
|
this.baseState = this.state;
|
|
this.state = State.BeforeEntity;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeDeclaration = function(c) {
|
|
if (c === CharCodes.OpeningSquareBracket) {
|
|
this.state = State.CDATASequence;
|
|
this.sequenceIndex = 0;
|
|
} else {
|
|
this.state = c === CharCodes.Dash ? State.BeforeComment : State.InDeclaration;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInDeclaration = function(c) {
|
|
if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
|
|
this.cbs.ondeclaration(this.sectionStart, this.index);
|
|
this.state = State.Text;
|
|
this.sectionStart = this.index + 1;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInProcessingInstruction = function(c) {
|
|
if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
|
|
this.cbs.onprocessinginstruction(this.sectionStart, this.index);
|
|
this.state = State.Text;
|
|
this.sectionStart = this.index + 1;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeComment = function(c) {
|
|
if (c === CharCodes.Dash) {
|
|
this.state = State.InCommentLike;
|
|
this.currentSequence = Sequences.CommentEnd;
|
|
this.sequenceIndex = 2;
|
|
this.sectionStart = this.index + 1;
|
|
} else {
|
|
this.state = State.InDeclaration;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInSpecialComment = function(c) {
|
|
if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
|
|
this.cbs.oncomment(this.sectionStart, this.index, 0);
|
|
this.state = State.Text;
|
|
this.sectionStart = this.index + 1;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeSpecialS = function(c) {
|
|
var lower = c | 32;
|
|
if (lower === Sequences.ScriptEnd[3]) {
|
|
this.startSpecial(Sequences.ScriptEnd, 4);
|
|
} else if (lower === Sequences.StyleEnd[3]) {
|
|
this.startSpecial(Sequences.StyleEnd, 4);
|
|
} else {
|
|
this.state = State.InTagName;
|
|
this.stateInTagName(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeEntity = function(c) {
|
|
this.entityExcess = 1;
|
|
this.entityResult = 0;
|
|
if (c === CharCodes.Number) {
|
|
this.state = State.BeforeNumericEntity;
|
|
} else if (c === CharCodes.Amp) {
|
|
} else {
|
|
this.trieIndex = 0;
|
|
this.trieCurrent = this.entityTrie[0];
|
|
this.state = State.InNamedEntity;
|
|
this.stateInNamedEntity(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInNamedEntity = function(c) {
|
|
this.entityExcess += 1;
|
|
this.trieIndex = (0, decode_js_1.determineBranch)(this.entityTrie, this.trieCurrent, this.trieIndex + 1, c);
|
|
if (this.trieIndex < 0) {
|
|
this.emitNamedEntity();
|
|
this.index--;
|
|
return;
|
|
}
|
|
this.trieCurrent = this.entityTrie[this.trieIndex];
|
|
var masked = this.trieCurrent & decode_js_1.BinTrieFlags.VALUE_LENGTH;
|
|
if (masked) {
|
|
var valueLength = (masked >> 14) - 1;
|
|
if (!this.allowLegacyEntity() && c !== CharCodes.Semi) {
|
|
this.trieIndex += valueLength;
|
|
} else {
|
|
var entityStart = this.index - this.entityExcess + 1;
|
|
if (entityStart > this.sectionStart) {
|
|
this.emitPartial(this.sectionStart, entityStart);
|
|
}
|
|
this.entityResult = this.trieIndex;
|
|
this.trieIndex += valueLength;
|
|
this.entityExcess = 0;
|
|
this.sectionStart = this.index + 1;
|
|
if (valueLength === 0) {
|
|
this.emitNamedEntity();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
Tokenizer2.prototype.emitNamedEntity = function() {
|
|
this.state = this.baseState;
|
|
if (this.entityResult === 0) {
|
|
return;
|
|
}
|
|
var valueLength = (this.entityTrie[this.entityResult] & decode_js_1.BinTrieFlags.VALUE_LENGTH) >> 14;
|
|
switch (valueLength) {
|
|
case 1: {
|
|
this.emitCodePoint(this.entityTrie[this.entityResult] & ~decode_js_1.BinTrieFlags.VALUE_LENGTH);
|
|
break;
|
|
}
|
|
case 2: {
|
|
this.emitCodePoint(this.entityTrie[this.entityResult + 1]);
|
|
break;
|
|
}
|
|
case 3: {
|
|
this.emitCodePoint(this.entityTrie[this.entityResult + 1]);
|
|
this.emitCodePoint(this.entityTrie[this.entityResult + 2]);
|
|
}
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateBeforeNumericEntity = function(c) {
|
|
if ((c | 32) === CharCodes.LowerX) {
|
|
this.entityExcess++;
|
|
this.state = State.InHexEntity;
|
|
} else {
|
|
this.state = State.InNumericEntity;
|
|
this.stateInNumericEntity(c);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.emitNumericEntity = function(strict) {
|
|
var entityStart = this.index - this.entityExcess - 1;
|
|
var numberStart = entityStart + 2 + Number(this.state === State.InHexEntity);
|
|
if (numberStart !== this.index) {
|
|
if (entityStart > this.sectionStart) {
|
|
this.emitPartial(this.sectionStart, entityStart);
|
|
}
|
|
this.sectionStart = this.index + Number(strict);
|
|
this.emitCodePoint((0, decode_js_1.replaceCodePoint)(this.entityResult));
|
|
}
|
|
this.state = this.baseState;
|
|
};
|
|
Tokenizer2.prototype.stateInNumericEntity = function(c) {
|
|
if (c === CharCodes.Semi) {
|
|
this.emitNumericEntity(true);
|
|
} else if (isNumber(c)) {
|
|
this.entityResult = this.entityResult * 10 + (c - CharCodes.Zero);
|
|
this.entityExcess++;
|
|
} else {
|
|
if (this.allowLegacyEntity()) {
|
|
this.emitNumericEntity(false);
|
|
} else {
|
|
this.state = this.baseState;
|
|
}
|
|
this.index--;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.stateInHexEntity = function(c) {
|
|
if (c === CharCodes.Semi) {
|
|
this.emitNumericEntity(true);
|
|
} else if (isNumber(c)) {
|
|
this.entityResult = this.entityResult * 16 + (c - CharCodes.Zero);
|
|
this.entityExcess++;
|
|
} else if (isHexDigit(c)) {
|
|
this.entityResult = this.entityResult * 16 + ((c | 32) - CharCodes.LowerA + 10);
|
|
this.entityExcess++;
|
|
} else {
|
|
if (this.allowLegacyEntity()) {
|
|
this.emitNumericEntity(false);
|
|
} else {
|
|
this.state = this.baseState;
|
|
}
|
|
this.index--;
|
|
}
|
|
};
|
|
Tokenizer2.prototype.allowLegacyEntity = function() {
|
|
return !this.xmlMode && (this.baseState === State.Text || this.baseState === State.InSpecialTag);
|
|
};
|
|
Tokenizer2.prototype.cleanup = function() {
|
|
if (this.running && this.sectionStart !== this.index) {
|
|
if (this.state === State.Text || this.state === State.InSpecialTag && this.sequenceIndex === 0) {
|
|
this.cbs.ontext(this.sectionStart, this.index);
|
|
this.sectionStart = this.index;
|
|
} else if (this.state === State.InAttributeValueDq || this.state === State.InAttributeValueSq || this.state === State.InAttributeValueNq) {
|
|
this.cbs.onattribdata(this.sectionStart, this.index);
|
|
this.sectionStart = this.index;
|
|
}
|
|
}
|
|
};
|
|
Tokenizer2.prototype.shouldContinue = function() {
|
|
return this.index < this.buffer.length + this.offset && this.running;
|
|
};
|
|
Tokenizer2.prototype.parse = function() {
|
|
while (this.shouldContinue()) {
|
|
var c = this.buffer.charCodeAt(this.index - this.offset);
|
|
switch (this.state) {
|
|
case State.Text: {
|
|
this.stateText(c);
|
|
break;
|
|
}
|
|
case State.SpecialStartSequence: {
|
|
this.stateSpecialStartSequence(c);
|
|
break;
|
|
}
|
|
case State.InSpecialTag: {
|
|
this.stateInSpecialTag(c);
|
|
break;
|
|
}
|
|
case State.CDATASequence: {
|
|
this.stateCDATASequence(c);
|
|
break;
|
|
}
|
|
case State.InAttributeValueDq: {
|
|
this.stateInAttributeValueDoubleQuotes(c);
|
|
break;
|
|
}
|
|
case State.InAttributeName: {
|
|
this.stateInAttributeName(c);
|
|
break;
|
|
}
|
|
case State.InCommentLike: {
|
|
this.stateInCommentLike(c);
|
|
break;
|
|
}
|
|
case State.InSpecialComment: {
|
|
this.stateInSpecialComment(c);
|
|
break;
|
|
}
|
|
case State.BeforeAttributeName: {
|
|
this.stateBeforeAttributeName(c);
|
|
break;
|
|
}
|
|
case State.InTagName: {
|
|
this.stateInTagName(c);
|
|
break;
|
|
}
|
|
case State.InClosingTagName: {
|
|
this.stateInClosingTagName(c);
|
|
break;
|
|
}
|
|
case State.BeforeTagName: {
|
|
this.stateBeforeTagName(c);
|
|
break;
|
|
}
|
|
case State.AfterAttributeName: {
|
|
this.stateAfterAttributeName(c);
|
|
break;
|
|
}
|
|
case State.InAttributeValueSq: {
|
|
this.stateInAttributeValueSingleQuotes(c);
|
|
break;
|
|
}
|
|
case State.BeforeAttributeValue: {
|
|
this.stateBeforeAttributeValue(c);
|
|
break;
|
|
}
|
|
case State.BeforeClosingTagName: {
|
|
this.stateBeforeClosingTagName(c);
|
|
break;
|
|
}
|
|
case State.AfterClosingTagName: {
|
|
this.stateAfterClosingTagName(c);
|
|
break;
|
|
}
|
|
case State.BeforeSpecialS: {
|
|
this.stateBeforeSpecialS(c);
|
|
break;
|
|
}
|
|
case State.InAttributeValueNq: {
|
|
this.stateInAttributeValueNoQuotes(c);
|
|
break;
|
|
}
|
|
case State.InSelfClosingTag: {
|
|
this.stateInSelfClosingTag(c);
|
|
break;
|
|
}
|
|
case State.InDeclaration: {
|
|
this.stateInDeclaration(c);
|
|
break;
|
|
}
|
|
case State.BeforeDeclaration: {
|
|
this.stateBeforeDeclaration(c);
|
|
break;
|
|
}
|
|
case State.BeforeComment: {
|
|
this.stateBeforeComment(c);
|
|
break;
|
|
}
|
|
case State.InProcessingInstruction: {
|
|
this.stateInProcessingInstruction(c);
|
|
break;
|
|
}
|
|
case State.InNamedEntity: {
|
|
this.stateInNamedEntity(c);
|
|
break;
|
|
}
|
|
case State.BeforeEntity: {
|
|
this.stateBeforeEntity(c);
|
|
break;
|
|
}
|
|
case State.InHexEntity: {
|
|
this.stateInHexEntity(c);
|
|
break;
|
|
}
|
|
case State.InNumericEntity: {
|
|
this.stateInNumericEntity(c);
|
|
break;
|
|
}
|
|
default: {
|
|
this.stateBeforeNumericEntity(c);
|
|
}
|
|
}
|
|
this.index++;
|
|
}
|
|
this.cleanup();
|
|
};
|
|
Tokenizer2.prototype.finish = function() {
|
|
if (this.state === State.InNamedEntity) {
|
|
this.emitNamedEntity();
|
|
}
|
|
if (this.sectionStart < this.index) {
|
|
this.handleTrailingData();
|
|
}
|
|
this.cbs.onend();
|
|
};
|
|
Tokenizer2.prototype.handleTrailingData = function() {
|
|
var endIndex = this.buffer.length + this.offset;
|
|
if (this.state === State.InCommentLike) {
|
|
if (this.currentSequence === Sequences.CdataEnd) {
|
|
this.cbs.oncdata(this.sectionStart, endIndex, 0);
|
|
} else {
|
|
this.cbs.oncomment(this.sectionStart, endIndex, 0);
|
|
}
|
|
} else if (this.state === State.InNumericEntity && this.allowLegacyEntity()) {
|
|
this.emitNumericEntity(false);
|
|
} else if (this.state === State.InHexEntity && this.allowLegacyEntity()) {
|
|
this.emitNumericEntity(false);
|
|
} else if (this.state === State.InTagName || this.state === State.BeforeAttributeName || this.state === State.BeforeAttributeValue || this.state === State.AfterAttributeName || this.state === State.InAttributeName || this.state === State.InAttributeValueSq || this.state === State.InAttributeValueDq || this.state === State.InAttributeValueNq || this.state === State.InClosingTagName) {
|
|
} else {
|
|
this.cbs.ontext(this.sectionStart, endIndex);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.emitPartial = function(start, endIndex) {
|
|
if (this.baseState !== State.Text && this.baseState !== State.InSpecialTag) {
|
|
this.cbs.onattribdata(start, endIndex);
|
|
} else {
|
|
this.cbs.ontext(start, endIndex);
|
|
}
|
|
};
|
|
Tokenizer2.prototype.emitCodePoint = function(cp) {
|
|
if (this.baseState !== State.Text && this.baseState !== State.InSpecialTag) {
|
|
this.cbs.onattribentity(cp);
|
|
} else {
|
|
this.cbs.ontextentity(cp);
|
|
}
|
|
};
|
|
return Tokenizer2;
|
|
}();
|
|
exports.default = Tokenizer;
|
|
});
|
|
|
|
// node_modules/htmlparser2/lib/Parser.js
|
|
var require_Parser2 = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__importStar || function(mod) {
|
|
if (mod && mod.__esModule)
|
|
return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod)
|
|
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
|
|
__createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Parser = undefined;
|
|
var Tokenizer_js_1 = __importStar(require_Tokenizer());
|
|
var decode_js_1 = require_decode();
|
|
var formTags = new Set([
|
|
"input",
|
|
"option",
|
|
"optgroup",
|
|
"select",
|
|
"button",
|
|
"datalist",
|
|
"textarea"
|
|
]);
|
|
var pTag = new Set(["p"]);
|
|
var tableSectionTags = new Set(["thead", "tbody"]);
|
|
var ddtTags = new Set(["dd", "dt"]);
|
|
var rtpTags = new Set(["rt", "rp"]);
|
|
var openImpliesClose = new Map([
|
|
["tr", new Set(["tr", "th", "td"])],
|
|
["th", new Set(["th"])],
|
|
["td", new Set(["thead", "th", "td"])],
|
|
["body", new Set(["head", "link", "script"])],
|
|
["li", new Set(["li"])],
|
|
["p", pTag],
|
|
["h1", pTag],
|
|
["h2", pTag],
|
|
["h3", pTag],
|
|
["h4", pTag],
|
|
["h5", pTag],
|
|
["h6", pTag],
|
|
["select", formTags],
|
|
["input", formTags],
|
|
["output", formTags],
|
|
["button", formTags],
|
|
["datalist", formTags],
|
|
["textarea", formTags],
|
|
["option", new Set(["option"])],
|
|
["optgroup", new Set(["optgroup", "option"])],
|
|
["dd", ddtTags],
|
|
["dt", ddtTags],
|
|
["address", pTag],
|
|
["article", pTag],
|
|
["aside", pTag],
|
|
["blockquote", pTag],
|
|
["details", pTag],
|
|
["div", pTag],
|
|
["dl", pTag],
|
|
["fieldset", pTag],
|
|
["figcaption", pTag],
|
|
["figure", pTag],
|
|
["footer", pTag],
|
|
["form", pTag],
|
|
["header", pTag],
|
|
["hr", pTag],
|
|
["main", pTag],
|
|
["nav", pTag],
|
|
["ol", pTag],
|
|
["pre", pTag],
|
|
["section", pTag],
|
|
["table", pTag],
|
|
["ul", pTag],
|
|
["rt", rtpTags],
|
|
["rp", rtpTags],
|
|
["tbody", tableSectionTags],
|
|
["tfoot", tableSectionTags]
|
|
]);
|
|
var voidElements = new Set([
|
|
"area",
|
|
"base",
|
|
"basefont",
|
|
"br",
|
|
"col",
|
|
"command",
|
|
"embed",
|
|
"frame",
|
|
"hr",
|
|
"img",
|
|
"input",
|
|
"isindex",
|
|
"keygen",
|
|
"link",
|
|
"meta",
|
|
"param",
|
|
"source",
|
|
"track",
|
|
"wbr"
|
|
]);
|
|
var foreignContextElements = new Set(["math", "svg"]);
|
|
var htmlIntegrationElements = new Set([
|
|
"mi",
|
|
"mo",
|
|
"mn",
|
|
"ms",
|
|
"mtext",
|
|
"annotation-xml",
|
|
"foreignobject",
|
|
"desc",
|
|
"title"
|
|
]);
|
|
var reNameEnd = /\s|\//;
|
|
var Parser = function() {
|
|
function Parser2(cbs, options) {
|
|
if (options === undefined) {
|
|
options = {};
|
|
}
|
|
var _a, _b, _c, _d, _e;
|
|
this.options = options;
|
|
this.startIndex = 0;
|
|
this.endIndex = 0;
|
|
this.openTagStart = 0;
|
|
this.tagname = "";
|
|
this.attribname = "";
|
|
this.attribvalue = "";
|
|
this.attribs = null;
|
|
this.stack = [];
|
|
this.foreignContext = [];
|
|
this.buffers = [];
|
|
this.bufferOffset = 0;
|
|
this.writeIndex = 0;
|
|
this.ended = false;
|
|
this.cbs = cbs !== null && cbs !== undefined ? cbs : {};
|
|
this.lowerCaseTagNames = (_a = options.lowerCaseTags) !== null && _a !== undefined ? _a : !options.xmlMode;
|
|
this.lowerCaseAttributeNames = (_b = options.lowerCaseAttributeNames) !== null && _b !== undefined ? _b : !options.xmlMode;
|
|
this.tokenizer = new ((_c = options.Tokenizer) !== null && _c !== undefined ? _c : Tokenizer_js_1.default)(this.options, this);
|
|
(_e = (_d = this.cbs).onparserinit) === null || _e === undefined || _e.call(_d, this);
|
|
}
|
|
Parser2.prototype.ontext = function(start, endIndex) {
|
|
var _a, _b;
|
|
var data = this.getSlice(start, endIndex);
|
|
this.endIndex = endIndex - 1;
|
|
(_b = (_a = this.cbs).ontext) === null || _b === undefined || _b.call(_a, data);
|
|
this.startIndex = endIndex;
|
|
};
|
|
Parser2.prototype.ontextentity = function(cp) {
|
|
var _a, _b;
|
|
var index = this.tokenizer.getSectionStart();
|
|
this.endIndex = index - 1;
|
|
(_b = (_a = this.cbs).ontext) === null || _b === undefined || _b.call(_a, (0, decode_js_1.fromCodePoint)(cp));
|
|
this.startIndex = index;
|
|
};
|
|
Parser2.prototype.isVoidElement = function(name) {
|
|
return !this.options.xmlMode && voidElements.has(name);
|
|
};
|
|
Parser2.prototype.onopentagname = function(start, endIndex) {
|
|
this.endIndex = endIndex;
|
|
var name = this.getSlice(start, endIndex);
|
|
if (this.lowerCaseTagNames) {
|
|
name = name.toLowerCase();
|
|
}
|
|
this.emitOpenTag(name);
|
|
};
|
|
Parser2.prototype.emitOpenTag = function(name) {
|
|
var _a, _b, _c, _d;
|
|
this.openTagStart = this.startIndex;
|
|
this.tagname = name;
|
|
var impliesClose = !this.options.xmlMode && openImpliesClose.get(name);
|
|
if (impliesClose) {
|
|
while (this.stack.length > 0 && impliesClose.has(this.stack[this.stack.length - 1])) {
|
|
var element = this.stack.pop();
|
|
(_b = (_a = this.cbs).onclosetag) === null || _b === undefined || _b.call(_a, element, true);
|
|
}
|
|
}
|
|
if (!this.isVoidElement(name)) {
|
|
this.stack.push(name);
|
|
if (foreignContextElements.has(name)) {
|
|
this.foreignContext.push(true);
|
|
} else if (htmlIntegrationElements.has(name)) {
|
|
this.foreignContext.push(false);
|
|
}
|
|
}
|
|
(_d = (_c = this.cbs).onopentagname) === null || _d === undefined || _d.call(_c, name);
|
|
if (this.cbs.onopentag)
|
|
this.attribs = {};
|
|
};
|
|
Parser2.prototype.endOpenTag = function(isImplied) {
|
|
var _a, _b;
|
|
this.startIndex = this.openTagStart;
|
|
if (this.attribs) {
|
|
(_b = (_a = this.cbs).onopentag) === null || _b === undefined || _b.call(_a, this.tagname, this.attribs, isImplied);
|
|
this.attribs = null;
|
|
}
|
|
if (this.cbs.onclosetag && this.isVoidElement(this.tagname)) {
|
|
this.cbs.onclosetag(this.tagname, true);
|
|
}
|
|
this.tagname = "";
|
|
};
|
|
Parser2.prototype.onopentagend = function(endIndex) {
|
|
this.endIndex = endIndex;
|
|
this.endOpenTag(false);
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.onclosetag = function(start, endIndex) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
this.endIndex = endIndex;
|
|
var name = this.getSlice(start, endIndex);
|
|
if (this.lowerCaseTagNames) {
|
|
name = name.toLowerCase();
|
|
}
|
|
if (foreignContextElements.has(name) || htmlIntegrationElements.has(name)) {
|
|
this.foreignContext.pop();
|
|
}
|
|
if (!this.isVoidElement(name)) {
|
|
var pos = this.stack.lastIndexOf(name);
|
|
if (pos !== -1) {
|
|
if (this.cbs.onclosetag) {
|
|
var count = this.stack.length - pos;
|
|
while (count--) {
|
|
this.cbs.onclosetag(this.stack.pop(), count !== 0);
|
|
}
|
|
} else
|
|
this.stack.length = pos;
|
|
} else if (!this.options.xmlMode && name === "p") {
|
|
this.emitOpenTag("p");
|
|
this.closeCurrentTag(true);
|
|
}
|
|
} else if (!this.options.xmlMode && name === "br") {
|
|
(_b = (_a = this.cbs).onopentagname) === null || _b === undefined || _b.call(_a, "br");
|
|
(_d = (_c = this.cbs).onopentag) === null || _d === undefined || _d.call(_c, "br", {}, true);
|
|
(_f = (_e = this.cbs).onclosetag) === null || _f === undefined || _f.call(_e, "br", false);
|
|
}
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.onselfclosingtag = function(endIndex) {
|
|
this.endIndex = endIndex;
|
|
if (this.options.xmlMode || this.options.recognizeSelfClosing || this.foreignContext[this.foreignContext.length - 1]) {
|
|
this.closeCurrentTag(false);
|
|
this.startIndex = endIndex + 1;
|
|
} else {
|
|
this.onopentagend(endIndex);
|
|
}
|
|
};
|
|
Parser2.prototype.closeCurrentTag = function(isOpenImplied) {
|
|
var _a, _b;
|
|
var name = this.tagname;
|
|
this.endOpenTag(isOpenImplied);
|
|
if (this.stack[this.stack.length - 1] === name) {
|
|
(_b = (_a = this.cbs).onclosetag) === null || _b === undefined || _b.call(_a, name, !isOpenImplied);
|
|
this.stack.pop();
|
|
}
|
|
};
|
|
Parser2.prototype.onattribname = function(start, endIndex) {
|
|
this.startIndex = start;
|
|
var name = this.getSlice(start, endIndex);
|
|
this.attribname = this.lowerCaseAttributeNames ? name.toLowerCase() : name;
|
|
};
|
|
Parser2.prototype.onattribdata = function(start, endIndex) {
|
|
this.attribvalue += this.getSlice(start, endIndex);
|
|
};
|
|
Parser2.prototype.onattribentity = function(cp) {
|
|
this.attribvalue += (0, decode_js_1.fromCodePoint)(cp);
|
|
};
|
|
Parser2.prototype.onattribend = function(quote, endIndex) {
|
|
var _a, _b;
|
|
this.endIndex = endIndex;
|
|
(_b = (_a = this.cbs).onattribute) === null || _b === undefined || _b.call(_a, this.attribname, this.attribvalue, quote === Tokenizer_js_1.QuoteType.Double ? '"' : quote === Tokenizer_js_1.QuoteType.Single ? "'" : quote === Tokenizer_js_1.QuoteType.NoValue ? undefined : null);
|
|
if (this.attribs && !Object.prototype.hasOwnProperty.call(this.attribs, this.attribname)) {
|
|
this.attribs[this.attribname] = this.attribvalue;
|
|
}
|
|
this.attribvalue = "";
|
|
};
|
|
Parser2.prototype.getInstructionName = function(value) {
|
|
var index = value.search(reNameEnd);
|
|
var name = index < 0 ? value : value.substr(0, index);
|
|
if (this.lowerCaseTagNames) {
|
|
name = name.toLowerCase();
|
|
}
|
|
return name;
|
|
};
|
|
Parser2.prototype.ondeclaration = function(start, endIndex) {
|
|
this.endIndex = endIndex;
|
|
var value = this.getSlice(start, endIndex);
|
|
if (this.cbs.onprocessinginstruction) {
|
|
var name = this.getInstructionName(value);
|
|
this.cbs.onprocessinginstruction("!".concat(name), "!".concat(value));
|
|
}
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.onprocessinginstruction = function(start, endIndex) {
|
|
this.endIndex = endIndex;
|
|
var value = this.getSlice(start, endIndex);
|
|
if (this.cbs.onprocessinginstruction) {
|
|
var name = this.getInstructionName(value);
|
|
this.cbs.onprocessinginstruction("?".concat(name), "?".concat(value));
|
|
}
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.oncomment = function(start, endIndex, offset) {
|
|
var _a, _b, _c, _d;
|
|
this.endIndex = endIndex;
|
|
(_b = (_a = this.cbs).oncomment) === null || _b === undefined || _b.call(_a, this.getSlice(start, endIndex - offset));
|
|
(_d = (_c = this.cbs).oncommentend) === null || _d === undefined || _d.call(_c);
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.oncdata = function(start, endIndex, offset) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
|
|
this.endIndex = endIndex;
|
|
var value = this.getSlice(start, endIndex - offset);
|
|
if (this.options.xmlMode || this.options.recognizeCDATA) {
|
|
(_b = (_a = this.cbs).oncdatastart) === null || _b === undefined || _b.call(_a);
|
|
(_d = (_c = this.cbs).ontext) === null || _d === undefined || _d.call(_c, value);
|
|
(_f = (_e = this.cbs).oncdataend) === null || _f === undefined || _f.call(_e);
|
|
} else {
|
|
(_h = (_g = this.cbs).oncomment) === null || _h === undefined || _h.call(_g, "[CDATA[".concat(value, "]]"));
|
|
(_k = (_j = this.cbs).oncommentend) === null || _k === undefined || _k.call(_j);
|
|
}
|
|
this.startIndex = endIndex + 1;
|
|
};
|
|
Parser2.prototype.onend = function() {
|
|
var _a, _b;
|
|
if (this.cbs.onclosetag) {
|
|
this.endIndex = this.startIndex;
|
|
for (var index = this.stack.length;index > 0; this.cbs.onclosetag(this.stack[--index], true))
|
|
;
|
|
}
|
|
(_b = (_a = this.cbs).onend) === null || _b === undefined || _b.call(_a);
|
|
};
|
|
Parser2.prototype.reset = function() {
|
|
var _a, _b, _c, _d;
|
|
(_b = (_a = this.cbs).onreset) === null || _b === undefined || _b.call(_a);
|
|
this.tokenizer.reset();
|
|
this.tagname = "";
|
|
this.attribname = "";
|
|
this.attribs = null;
|
|
this.stack.length = 0;
|
|
this.startIndex = 0;
|
|
this.endIndex = 0;
|
|
(_d = (_c = this.cbs).onparserinit) === null || _d === undefined || _d.call(_c, this);
|
|
this.buffers.length = 0;
|
|
this.bufferOffset = 0;
|
|
this.writeIndex = 0;
|
|
this.ended = false;
|
|
};
|
|
Parser2.prototype.parseComplete = function(data) {
|
|
this.reset();
|
|
this.end(data);
|
|
};
|
|
Parser2.prototype.getSlice = function(start, end) {
|
|
while (start - this.bufferOffset >= this.buffers[0].length) {
|
|
this.shiftBuffer();
|
|
}
|
|
var slice = this.buffers[0].slice(start - this.bufferOffset, end - this.bufferOffset);
|
|
while (end - this.bufferOffset > this.buffers[0].length) {
|
|
this.shiftBuffer();
|
|
slice += this.buffers[0].slice(0, end - this.bufferOffset);
|
|
}
|
|
return slice;
|
|
};
|
|
Parser2.prototype.shiftBuffer = function() {
|
|
this.bufferOffset += this.buffers[0].length;
|
|
this.writeIndex--;
|
|
this.buffers.shift();
|
|
};
|
|
Parser2.prototype.write = function(chunk) {
|
|
var _a, _b;
|
|
if (this.ended) {
|
|
(_b = (_a = this.cbs).onerror) === null || _b === undefined || _b.call(_a, new Error(".write() after done!"));
|
|
return;
|
|
}
|
|
this.buffers.push(chunk);
|
|
if (this.tokenizer.running) {
|
|
this.tokenizer.write(chunk);
|
|
this.writeIndex++;
|
|
}
|
|
};
|
|
Parser2.prototype.end = function(chunk) {
|
|
var _a, _b;
|
|
if (this.ended) {
|
|
(_b = (_a = this.cbs).onerror) === null || _b === undefined || _b.call(_a, new Error(".end() after done!"));
|
|
return;
|
|
}
|
|
if (chunk)
|
|
this.write(chunk);
|
|
this.ended = true;
|
|
this.tokenizer.end();
|
|
};
|
|
Parser2.prototype.pause = function() {
|
|
this.tokenizer.pause();
|
|
};
|
|
Parser2.prototype.resume = function() {
|
|
this.tokenizer.resume();
|
|
while (this.tokenizer.running && this.writeIndex < this.buffers.length) {
|
|
this.tokenizer.write(this.buffers[this.writeIndex++]);
|
|
}
|
|
if (this.ended)
|
|
this.tokenizer.end();
|
|
};
|
|
Parser2.prototype.parseChunk = function(chunk) {
|
|
this.write(chunk);
|
|
};
|
|
Parser2.prototype.done = function(chunk) {
|
|
this.end(chunk);
|
|
};
|
|
return Parser2;
|
|
}();
|
|
exports.Parser = Parser;
|
|
});
|
|
|
|
// node_modules/domelementtype/lib/index.js
|
|
var require_lib = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = undefined;
|
|
var ElementType;
|
|
(function(ElementType2) {
|
|
ElementType2["Root"] = "root";
|
|
ElementType2["Text"] = "text";
|
|
ElementType2["Directive"] = "directive";
|
|
ElementType2["Comment"] = "comment";
|
|
ElementType2["Script"] = "script";
|
|
ElementType2["Style"] = "style";
|
|
ElementType2["Tag"] = "tag";
|
|
ElementType2["CDATA"] = "cdata";
|
|
ElementType2["Doctype"] = "doctype";
|
|
})(ElementType = exports.ElementType || (exports.ElementType = {}));
|
|
function isTag(elem) {
|
|
return elem.type === ElementType.Tag || elem.type === ElementType.Script || elem.type === ElementType.Style;
|
|
}
|
|
exports.isTag = isTag;
|
|
exports.Root = ElementType.Root;
|
|
exports.Text = ElementType.Text;
|
|
exports.Directive = ElementType.Directive;
|
|
exports.Comment = ElementType.Comment;
|
|
exports.Script = ElementType.Script;
|
|
exports.Style = ElementType.Style;
|
|
exports.Tag = ElementType.Tag;
|
|
exports.CDATA = ElementType.CDATA;
|
|
exports.Doctype = ElementType.Doctype;
|
|
});
|
|
|
|
// node_modules/domhandler/lib/node.js
|
|
var require_node2 = __commonJS((exports) => {
|
|
var __extends = exports && exports.__extends || function() {
|
|
var extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
|
|
d2.__proto__ = b2;
|
|
} || function(d2, b2) {
|
|
for (var p in b2)
|
|
if (Object.prototype.hasOwnProperty.call(b2, p))
|
|
d2[p] = b2[p];
|
|
};
|
|
return extendStatics(d, b);
|
|
};
|
|
return function(d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() {
|
|
this.constructor = d;
|
|
}
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __);
|
|
};
|
|
}();
|
|
var __assign = exports && exports.__assign || function() {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length;i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.cloneNode = exports.hasChildren = exports.isDocument = exports.isDirective = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = exports.Element = exports.Document = exports.CDATA = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = undefined;
|
|
var domelementtype_1 = require_lib();
|
|
var Node = function() {
|
|
function Node2() {
|
|
this.parent = null;
|
|
this.prev = null;
|
|
this.next = null;
|
|
this.startIndex = null;
|
|
this.endIndex = null;
|
|
}
|
|
Object.defineProperty(Node2.prototype, "parentNode", {
|
|
get: function() {
|
|
return this.parent;
|
|
},
|
|
set: function(parent) {
|
|
this.parent = parent;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Node2.prototype, "previousSibling", {
|
|
get: function() {
|
|
return this.prev;
|
|
},
|
|
set: function(prev) {
|
|
this.prev = prev;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Node2.prototype, "nextSibling", {
|
|
get: function() {
|
|
return this.next;
|
|
},
|
|
set: function(next) {
|
|
this.next = next;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Node2.prototype.cloneNode = function(recursive) {
|
|
if (recursive === undefined) {
|
|
recursive = false;
|
|
}
|
|
return cloneNode(this, recursive);
|
|
};
|
|
return Node2;
|
|
}();
|
|
exports.Node = Node;
|
|
var DataNode = function(_super) {
|
|
__extends(DataNode2, _super);
|
|
function DataNode2(data) {
|
|
var _this = _super.call(this) || this;
|
|
_this.data = data;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(DataNode2.prototype, "nodeValue", {
|
|
get: function() {
|
|
return this.data;
|
|
},
|
|
set: function(data) {
|
|
this.data = data;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return DataNode2;
|
|
}(Node);
|
|
exports.DataNode = DataNode;
|
|
var Text = function(_super) {
|
|
__extends(Text2, _super);
|
|
function Text2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.type = domelementtype_1.ElementType.Text;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(Text2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 3;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Text2;
|
|
}(DataNode);
|
|
exports.Text = Text;
|
|
var Comment = function(_super) {
|
|
__extends(Comment2, _super);
|
|
function Comment2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.type = domelementtype_1.ElementType.Comment;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(Comment2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 8;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Comment2;
|
|
}(DataNode);
|
|
exports.Comment = Comment;
|
|
var ProcessingInstruction = function(_super) {
|
|
__extends(ProcessingInstruction2, _super);
|
|
function ProcessingInstruction2(name, data) {
|
|
var _this = _super.call(this, data) || this;
|
|
_this.name = name;
|
|
_this.type = domelementtype_1.ElementType.Directive;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(ProcessingInstruction2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 1;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return ProcessingInstruction2;
|
|
}(DataNode);
|
|
exports.ProcessingInstruction = ProcessingInstruction;
|
|
var NodeWithChildren = function(_super) {
|
|
__extends(NodeWithChildren2, _super);
|
|
function NodeWithChildren2(children) {
|
|
var _this = _super.call(this) || this;
|
|
_this.children = children;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(NodeWithChildren2.prototype, "firstChild", {
|
|
get: function() {
|
|
var _a;
|
|
return (_a = this.children[0]) !== null && _a !== undefined ? _a : null;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(NodeWithChildren2.prototype, "lastChild", {
|
|
get: function() {
|
|
return this.children.length > 0 ? this.children[this.children.length - 1] : null;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(NodeWithChildren2.prototype, "childNodes", {
|
|
get: function() {
|
|
return this.children;
|
|
},
|
|
set: function(children) {
|
|
this.children = children;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return NodeWithChildren2;
|
|
}(Node);
|
|
exports.NodeWithChildren = NodeWithChildren;
|
|
var CDATA = function(_super) {
|
|
__extends(CDATA2, _super);
|
|
function CDATA2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.type = domelementtype_1.ElementType.CDATA;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(CDATA2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 4;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return CDATA2;
|
|
}(NodeWithChildren);
|
|
exports.CDATA = CDATA;
|
|
var Document = function(_super) {
|
|
__extends(Document2, _super);
|
|
function Document2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.type = domelementtype_1.ElementType.Root;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(Document2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 9;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Document2;
|
|
}(NodeWithChildren);
|
|
exports.Document = Document;
|
|
var Element = function(_super) {
|
|
__extends(Element2, _super);
|
|
function Element2(name, attribs, children, type) {
|
|
if (children === undefined) {
|
|
children = [];
|
|
}
|
|
if (type === undefined) {
|
|
type = name === "script" ? domelementtype_1.ElementType.Script : name === "style" ? domelementtype_1.ElementType.Style : domelementtype_1.ElementType.Tag;
|
|
}
|
|
var _this = _super.call(this, children) || this;
|
|
_this.name = name;
|
|
_this.attribs = attribs;
|
|
_this.type = type;
|
|
return _this;
|
|
}
|
|
Object.defineProperty(Element2.prototype, "nodeType", {
|
|
get: function() {
|
|
return 1;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Element2.prototype, "tagName", {
|
|
get: function() {
|
|
return this.name;
|
|
},
|
|
set: function(name) {
|
|
this.name = name;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Element2.prototype, "attributes", {
|
|
get: function() {
|
|
var _this = this;
|
|
return Object.keys(this.attribs).map(function(name) {
|
|
var _a, _b;
|
|
return {
|
|
name,
|
|
value: _this.attribs[name],
|
|
namespace: (_a = _this["x-attribsNamespace"]) === null || _a === undefined ? undefined : _a[name],
|
|
prefix: (_b = _this["x-attribsPrefix"]) === null || _b === undefined ? undefined : _b[name]
|
|
};
|
|
});
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Element2;
|
|
}(NodeWithChildren);
|
|
exports.Element = Element;
|
|
function isTag(node) {
|
|
return (0, domelementtype_1.isTag)(node);
|
|
}
|
|
exports.isTag = isTag;
|
|
function isCDATA(node) {
|
|
return node.type === domelementtype_1.ElementType.CDATA;
|
|
}
|
|
exports.isCDATA = isCDATA;
|
|
function isText(node) {
|
|
return node.type === domelementtype_1.ElementType.Text;
|
|
}
|
|
exports.isText = isText;
|
|
function isComment(node) {
|
|
return node.type === domelementtype_1.ElementType.Comment;
|
|
}
|
|
exports.isComment = isComment;
|
|
function isDirective(node) {
|
|
return node.type === domelementtype_1.ElementType.Directive;
|
|
}
|
|
exports.isDirective = isDirective;
|
|
function isDocument(node) {
|
|
return node.type === domelementtype_1.ElementType.Root;
|
|
}
|
|
exports.isDocument = isDocument;
|
|
function hasChildren(node) {
|
|
return Object.prototype.hasOwnProperty.call(node, "children");
|
|
}
|
|
exports.hasChildren = hasChildren;
|
|
function cloneNode(node, recursive) {
|
|
if (recursive === undefined) {
|
|
recursive = false;
|
|
}
|
|
var result;
|
|
if (isText(node)) {
|
|
result = new Text(node.data);
|
|
} else if (isComment(node)) {
|
|
result = new Comment(node.data);
|
|
} else if (isTag(node)) {
|
|
var children = recursive ? cloneChildren(node.children) : [];
|
|
var clone_1 = new Element(node.name, __assign({}, node.attribs), children);
|
|
children.forEach(function(child) {
|
|
return child.parent = clone_1;
|
|
});
|
|
if (node.namespace != null) {
|
|
clone_1.namespace = node.namespace;
|
|
}
|
|
if (node["x-attribsNamespace"]) {
|
|
clone_1["x-attribsNamespace"] = __assign({}, node["x-attribsNamespace"]);
|
|
}
|
|
if (node["x-attribsPrefix"]) {
|
|
clone_1["x-attribsPrefix"] = __assign({}, node["x-attribsPrefix"]);
|
|
}
|
|
result = clone_1;
|
|
} else if (isCDATA(node)) {
|
|
var children = recursive ? cloneChildren(node.children) : [];
|
|
var clone_2 = new CDATA(children);
|
|
children.forEach(function(child) {
|
|
return child.parent = clone_2;
|
|
});
|
|
result = clone_2;
|
|
} else if (isDocument(node)) {
|
|
var children = recursive ? cloneChildren(node.children) : [];
|
|
var clone_3 = new Document(children);
|
|
children.forEach(function(child) {
|
|
return child.parent = clone_3;
|
|
});
|
|
if (node["x-mode"]) {
|
|
clone_3["x-mode"] = node["x-mode"];
|
|
}
|
|
result = clone_3;
|
|
} else if (isDirective(node)) {
|
|
var instruction = new ProcessingInstruction(node.name, node.data);
|
|
if (node["x-name"] != null) {
|
|
instruction["x-name"] = node["x-name"];
|
|
instruction["x-publicId"] = node["x-publicId"];
|
|
instruction["x-systemId"] = node["x-systemId"];
|
|
}
|
|
result = instruction;
|
|
} else {
|
|
throw new Error("Not implemented yet: ".concat(node.type));
|
|
}
|
|
result.startIndex = node.startIndex;
|
|
result.endIndex = node.endIndex;
|
|
if (node.sourceCodeLocation != null) {
|
|
result.sourceCodeLocation = node.sourceCodeLocation;
|
|
}
|
|
return result;
|
|
}
|
|
exports.cloneNode = cloneNode;
|
|
function cloneChildren(childs) {
|
|
var children = childs.map(function(child) {
|
|
return cloneNode(child, true);
|
|
});
|
|
for (var i = 1;i < children.length; i++) {
|
|
children[i].prev = children[i - 1];
|
|
children[i - 1].next = children[i];
|
|
}
|
|
return children;
|
|
}
|
|
});
|
|
|
|
// node_modules/domhandler/lib/index.js
|
|
var require_lib2 = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
|
|
for (var p in m)
|
|
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
|
|
__createBinding(exports2, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DomHandler = undefined;
|
|
var domelementtype_1 = require_lib();
|
|
var node_js_1 = require_node2();
|
|
__exportStar(require_node2(), exports);
|
|
var defaultOpts = {
|
|
withStartIndices: false,
|
|
withEndIndices: false,
|
|
xmlMode: false
|
|
};
|
|
var DomHandler = function() {
|
|
function DomHandler2(callback, options, elementCB) {
|
|
this.dom = [];
|
|
this.root = new node_js_1.Document(this.dom);
|
|
this.done = false;
|
|
this.tagStack = [this.root];
|
|
this.lastNode = null;
|
|
this.parser = null;
|
|
if (typeof options === "function") {
|
|
elementCB = options;
|
|
options = defaultOpts;
|
|
}
|
|
if (typeof callback === "object") {
|
|
options = callback;
|
|
callback = undefined;
|
|
}
|
|
this.callback = callback !== null && callback !== undefined ? callback : null;
|
|
this.options = options !== null && options !== undefined ? options : defaultOpts;
|
|
this.elementCB = elementCB !== null && elementCB !== undefined ? elementCB : null;
|
|
}
|
|
DomHandler2.prototype.onparserinit = function(parser) {
|
|
this.parser = parser;
|
|
};
|
|
DomHandler2.prototype.onreset = function() {
|
|
this.dom = [];
|
|
this.root = new node_js_1.Document(this.dom);
|
|
this.done = false;
|
|
this.tagStack = [this.root];
|
|
this.lastNode = null;
|
|
this.parser = null;
|
|
};
|
|
DomHandler2.prototype.onend = function() {
|
|
if (this.done)
|
|
return;
|
|
this.done = true;
|
|
this.parser = null;
|
|
this.handleCallback(null);
|
|
};
|
|
DomHandler2.prototype.onerror = function(error) {
|
|
this.handleCallback(error);
|
|
};
|
|
DomHandler2.prototype.onclosetag = function() {
|
|
this.lastNode = null;
|
|
var elem = this.tagStack.pop();
|
|
if (this.options.withEndIndices) {
|
|
elem.endIndex = this.parser.endIndex;
|
|
}
|
|
if (this.elementCB)
|
|
this.elementCB(elem);
|
|
};
|
|
DomHandler2.prototype.onopentag = function(name, attribs) {
|
|
var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;
|
|
var element = new node_js_1.Element(name, attribs, undefined, type);
|
|
this.addNode(element);
|
|
this.tagStack.push(element);
|
|
};
|
|
DomHandler2.prototype.ontext = function(data) {
|
|
var lastNode = this.lastNode;
|
|
if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {
|
|
lastNode.data += data;
|
|
if (this.options.withEndIndices) {
|
|
lastNode.endIndex = this.parser.endIndex;
|
|
}
|
|
} else {
|
|
var node = new node_js_1.Text(data);
|
|
this.addNode(node);
|
|
this.lastNode = node;
|
|
}
|
|
};
|
|
DomHandler2.prototype.oncomment = function(data) {
|
|
if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {
|
|
this.lastNode.data += data;
|
|
return;
|
|
}
|
|
var node = new node_js_1.Comment(data);
|
|
this.addNode(node);
|
|
this.lastNode = node;
|
|
};
|
|
DomHandler2.prototype.oncommentend = function() {
|
|
this.lastNode = null;
|
|
};
|
|
DomHandler2.prototype.oncdatastart = function() {
|
|
var text = new node_js_1.Text("");
|
|
var node = new node_js_1.CDATA([text]);
|
|
this.addNode(node);
|
|
text.parent = node;
|
|
this.lastNode = text;
|
|
};
|
|
DomHandler2.prototype.oncdataend = function() {
|
|
this.lastNode = null;
|
|
};
|
|
DomHandler2.prototype.onprocessinginstruction = function(name, data) {
|
|
var node = new node_js_1.ProcessingInstruction(name, data);
|
|
this.addNode(node);
|
|
};
|
|
DomHandler2.prototype.handleCallback = function(error) {
|
|
if (typeof this.callback === "function") {
|
|
this.callback(error, this.dom);
|
|
} else if (error) {
|
|
throw error;
|
|
}
|
|
};
|
|
DomHandler2.prototype.addNode = function(node) {
|
|
var parent = this.tagStack[this.tagStack.length - 1];
|
|
var previousSibling = parent.children[parent.children.length - 1];
|
|
if (this.options.withStartIndices) {
|
|
node.startIndex = this.parser.startIndex;
|
|
}
|
|
if (this.options.withEndIndices) {
|
|
node.endIndex = this.parser.endIndex;
|
|
}
|
|
parent.children.push(node);
|
|
if (previousSibling) {
|
|
node.prev = previousSibling;
|
|
previousSibling.next = node;
|
|
}
|
|
node.parent = parent;
|
|
this.lastNode = null;
|
|
};
|
|
return DomHandler2;
|
|
}();
|
|
exports.DomHandler = DomHandler;
|
|
exports.default = DomHandler;
|
|
});
|
|
|
|
// node_modules/entities/lib/generated/encode-html.js
|
|
var require_encode_html = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
function restoreDiff(arr) {
|
|
for (var i = 1;i < arr.length; i++) {
|
|
arr[i][0] += arr[i - 1][0] + 1;
|
|
}
|
|
return arr;
|
|
}
|
|
exports.default = new Map(/* @__PURE__ */ restoreDiff([[9, "	"], [0, "
"], [22, "!"], [0, """], [0, "#"], [0, "$"], [0, "%"], [0, "&"], [0, "'"], [0, "("], [0, ")"], [0, "*"], [0, "+"], [0, ","], [1, "."], [0, "/"], [10, ":"], [0, ";"], [0, { v: "<", n: 8402, o: "<⃒" }], [0, { v: "=", n: 8421, o: "=⃥" }], [0, { v: ">", n: 8402, o: ">⃒" }], [0, "?"], [0, "@"], [26, "["], [0, "\"], [0, "]"], [0, "^"], [0, "_"], [0, "`"], [5, { n: 106, o: "fj" }], [20, "{"], [0, "|"], [0, "}"], [34, " "], [0, "¡"], [0, "¢"], [0, "£"], [0, "¤"], [0, "¥"], [0, "¦"], [0, "§"], [0, "¨"], [0, "©"], [0, "ª"], [0, "«"], [0, "¬"], [0, "­"], [0, "®"], [0, "¯"], [0, "°"], [0, "±"], [0, "²"], [0, "³"], [0, "´"], [0, "µ"], [0, "¶"], [0, "·"], [0, "¸"], [0, "¹"], [0, "º"], [0, "»"], [0, "¼"], [0, "½"], [0, "¾"], [0, "¿"], [0, "À"], [0, "Á"], [0, "Â"], [0, "Ã"], [0, "Ä"], [0, "Å"], [0, "Æ"], [0, "Ç"], [0, "È"], [0, "É"], [0, "Ê"], [0, "Ë"], [0, "Ì"], [0, "Í"], [0, "Î"], [0, "Ï"], [0, "Ð"], [0, "Ñ"], [0, "Ò"], [0, "Ó"], [0, "Ô"], [0, "Õ"], [0, "Ö"], [0, "×"], [0, "Ø"], [0, "Ù"], [0, "Ú"], [0, "Û"], [0, "Ü"], [0, "Ý"], [0, "Þ"], [0, "ß"], [0, "à"], [0, "á"], [0, "â"], [0, "ã"], [0, "ä"], [0, "å"], [0, "æ"], [0, "ç"], [0, "è"], [0, "é"], [0, "ê"], [0, "ë"], [0, "ì"], [0, "í"], [0, "î"], [0, "ï"], [0, "ð"], [0, "ñ"], [0, "ò"], [0, "ó"], [0, "ô"], [0, "õ"], [0, "ö"], [0, "÷"], [0, "ø"], [0, "ù"], [0, "ú"], [0, "û"], [0, "ü"], [0, "ý"], [0, "þ"], [0, "ÿ"], [0, "Ā"], [0, "ā"], [0, "Ă"], [0, "ă"], [0, "Ą"], [0, "ą"], [0, "Ć"], [0, "ć"], [0, "Ĉ"], [0, "ĉ"], [0, "Ċ"], [0, "ċ"], [0, "Č"], [0, "č"], [0, "Ď"], [0, "ď"], [0, "Đ"], [0, "đ"], [0, "Ē"], [0, "ē"], [2, "Ė"], [0, "ė"], [0, "Ę"], [0, "ę"], [0, "Ě"], [0, "ě"], [0, "Ĝ"], [0, "ĝ"], [0, "Ğ"], [0, "ğ"], [0, "Ġ"], [0, "ġ"], [0, "Ģ"], [1, "Ĥ"], [0, "ĥ"], [0, "Ħ"], [0, "ħ"], [0, "Ĩ"], [0, "ĩ"], [0, "Ī"], [0, "ī"], [2, "Į"], [0, "į"], [0, "İ"], [0, "ı"], [0, "IJ"], [0, "ij"], [0, "Ĵ"], [0, "ĵ"], [0, "Ķ"], [0, "ķ"], [0, "ĸ"], [0, "Ĺ"], [0, "ĺ"], [0, "Ļ"], [0, "ļ"], [0, "Ľ"], [0, "ľ"], [0, "Ŀ"], [0, "ŀ"], [0, "Ł"], [0, "ł"], [0, "Ń"], [0, "ń"], [0, "Ņ"], [0, "ņ"], [0, "Ň"], [0, "ň"], [0, "ʼn"], [0, "Ŋ"], [0, "ŋ"], [0, "Ō"], [0, "ō"], [2, "Ő"], [0, "ő"], [0, "Œ"], [0, "œ"], [0, "Ŕ"], [0, "ŕ"], [0, "Ŗ"], [0, "ŗ"], [0, "Ř"], [0, "ř"], [0, "Ś"], [0, "ś"], [0, "Ŝ"], [0, "ŝ"], [0, "Ş"], [0, "ş"], [0, "Š"], [0, "š"], [0, "Ţ"], [0, "ţ"], [0, "Ť"], [0, "ť"], [0, "Ŧ"], [0, "ŧ"], [0, "Ũ"], [0, "ũ"], [0, "Ū"], [0, "ū"], [0, "Ŭ"], [0, "ŭ"], [0, "Ů"], [0, "ů"], [0, "Ű"], [0, "ű"], [0, "Ų"], [0, "ų"], [0, "Ŵ"], [0, "ŵ"], [0, "Ŷ"], [0, "ŷ"], [0, "Ÿ"], [0, "Ź"], [0, "ź"], [0, "Ż"], [0, "ż"], [0, "Ž"], [0, "ž"], [19, "ƒ"], [34, "Ƶ"], [63, "ǵ"], [65, "ȷ"], [142, "ˆ"], [0, "ˇ"], [16, "˘"], [0, "˙"], [0, "˚"], [0, "˛"], [0, "˜"], [0, "˝"], [51, "̑"], [127, "Α"], [0, "Β"], [0, "Γ"], [0, "Δ"], [0, "Ε"], [0, "Ζ"], [0, "Η"], [0, "Θ"], [0, "Ι"], [0, "Κ"], [0, "Λ"], [0, "Μ"], [0, "Ν"], [0, "Ξ"], [0, "Ο"], [0, "Π"], [0, "Ρ"], [1, "Σ"], [0, "Τ"], [0, "Υ"], [0, "Φ"], [0, "Χ"], [0, "Ψ"], [0, "Ω"], [7, "α"], [0, "β"], [0, "γ"], [0, "δ"], [0, "ε"], [0, "ζ"], [0, "η"], [0, "θ"], [0, "ι"], [0, "κ"], [0, "λ"], [0, "μ"], [0, "ν"], [0, "ξ"], [0, "ο"], [0, "π"], [0, "ρ"], [0, "ς"], [0, "σ"], [0, "τ"], [0, "υ"], [0, "φ"], [0, "χ"], [0, "ψ"], [0, "ω"], [7, "ϑ"], [0, "ϒ"], [2, "ϕ"], [0, "ϖ"], [5, "Ϝ"], [0, "ϝ"], [18, "ϰ"], [0, "ϱ"], [3, "ϵ"], [0, "϶"], [10, "Ё"], [0, "Ђ"], [0, "Ѓ"], [0, "Є"], [0, "Ѕ"], [0, "І"], [0, "Ї"], [0, "Ј"], [0, "Љ"], [0, "Њ"], [0, "Ћ"], [0, "Ќ"], [1, "Ў"], [0, "Џ"], [0, "А"], [0, "Б"], [0, "В"], [0, "Г"], [0, "Д"], [0, "Е"], [0, "Ж"], [0, "З"], [0, "И"], [0, "Й"], [0, "К"], [0, "Л"], [0, "М"], [0, "Н"], [0, "О"], [0, "П"], [0, "Р"], [0, "С"], [0, "Т"], [0, "У"], [0, "Ф"], [0, "Х"], [0, "Ц"], [0, "Ч"], [0, "Ш"], [0, "Щ"], [0, "Ъ"], [0, "Ы"], [0, "Ь"], [0, "Э"], [0, "Ю"], [0, "Я"], [0, "а"], [0, "б"], [0, "в"], [0, "г"], [0, "д"], [0, "е"], [0, "ж"], [0, "з"], [0, "и"], [0, "й"], [0, "к"], [0, "л"], [0, "м"], [0, "н"], [0, "о"], [0, "п"], [0, "р"], [0, "с"], [0, "т"], [0, "у"], [0, "ф"], [0, "х"], [0, "ц"], [0, "ч"], [0, "ш"], [0, "щ"], [0, "ъ"], [0, "ы"], [0, "ь"], [0, "э"], [0, "ю"], [0, "я"], [1, "ё"], [0, "ђ"], [0, "ѓ"], [0, "є"], [0, "ѕ"], [0, "і"], [0, "ї"], [0, "ј"], [0, "љ"], [0, "њ"], [0, "ћ"], [0, "ќ"], [1, "ў"], [0, "џ"], [7074, " "], [0, " "], [0, " "], [0, " "], [1, " "], [0, " "], [0, " "], [0, " "], [0, "​"], [0, "‌"], [0, "‍"], [0, "‎"], [0, "‏"], [0, "‐"], [2, "–"], [0, "—"], [0, "―"], [0, "‖"], [1, "‘"], [0, "’"], [0, "‚"], [1, "“"], [0, "”"], [0, "„"], [1, "†"], [0, "‡"], [0, "•"], [2, "‥"], [0, "…"], [9, "‰"], [0, "‱"], [0, "′"], [0, "″"], [0, "‴"], [0, "‵"], [3, "‹"], [0, "›"], [3, "‾"], [2, "⁁"], [1, "⁃"], [0, "⁄"], [10, "⁏"], [7, "⁗"], [7, { v: " ", n: 8202, o: "  " }], [0, "⁠"], [0, "⁡"], [0, "⁢"], [0, "⁣"], [72, "€"], [46, "⃛"], [0, "⃜"], [37, "ℂ"], [2, "℅"], [4, "ℊ"], [0, "ℋ"], [0, "ℌ"], [0, "ℍ"], [0, "ℎ"], [0, "ℏ"], [0, "ℐ"], [0, "ℑ"], [0, "ℒ"], [0, "ℓ"], [1, "ℕ"], [0, "№"], [0, "℗"], [0, "℘"], [0, "ℙ"], [0, "ℚ"], [0, "ℛ"], [0, "ℜ"], [0, "ℝ"], [0, "℞"], [3, "™"], [1, "ℤ"], [2, "℧"], [0, "ℨ"], [0, "℩"], [2, "ℬ"], [0, "ℭ"], [1, "ℯ"], [0, "ℰ"], [0, "ℱ"], [1, "ℳ"], [0, "ℴ"], [0, "ℵ"], [0, "ℶ"], [0, "ℷ"], [0, "ℸ"], [12, "ⅅ"], [0, "ⅆ"], [0, "ⅇ"], [0, "ⅈ"], [10, "⅓"], [0, "⅔"], [0, "⅕"], [0, "⅖"], [0, "⅗"], [0, "⅘"], [0, "⅙"], [0, "⅚"], [0, "⅛"], [0, "⅜"], [0, "⅝"], [0, "⅞"], [49, "←"], [0, "↑"], [0, "→"], [0, "↓"], [0, "↔"], [0, "↕"], [0, "↖"], [0, "↗"], [0, "↘"], [0, "↙"], [0, "↚"], [0, "↛"], [1, { v: "↝", n: 824, o: "↝̸" }], [0, "↞"], [0, "↟"], [0, "↠"], [0, "↡"], [0, "↢"], [0, "↣"], [0, "↤"], [0, "↥"], [0, "↦"], [0, "↧"], [1, "↩"], [0, "↪"], [0, "↫"], [0, "↬"], [0, "↭"], [0, "↮"], [1, "↰"], [0, "↱"], [0, "↲"], [0, "↳"], [1, "↵"], [0, "↶"], [0, "↷"], [2, "↺"], [0, "↻"], [0, "↼"], [0, "↽"], [0, "↾"], [0, "↿"], [0, "⇀"], [0, "⇁"], [0, "⇂"], [0, "⇃"], [0, "⇄"], [0, "⇅"], [0, "⇆"], [0, "⇇"], [0, "⇈"], [0, "⇉"], [0, "⇊"], [0, "⇋"], [0, "⇌"], [0, "⇍"], [0, "⇎"], [0, "⇏"], [0, "⇐"], [0, "⇑"], [0, "⇒"], [0, "⇓"], [0, "⇔"], [0, "⇕"], [0, "⇖"], [0, "⇗"], [0, "⇘"], [0, "⇙"], [0, "⇚"], [0, "⇛"], [1, "⇝"], [6, "⇤"], [0, "⇥"], [15, "⇵"], [7, "⇽"], [0, "⇾"], [0, "⇿"], [0, "∀"], [0, "∁"], [0, { v: "∂", n: 824, o: "∂̸" }], [0, "∃"], [0, "∄"], [0, "∅"], [1, "∇"], [0, "∈"], [0, "∉"], [1, "∋"], [0, "∌"], [2, "∏"], [0, "∐"], [0, "∑"], [0, "−"], [0, "∓"], [0, "∔"], [1, "∖"], [0, "∗"], [0, "∘"], [1, "√"], [2, "∝"], [0, "∞"], [0, "∟"], [0, { v: "∠", n: 8402, o: "∠⃒" }], [0, "∡"], [0, "∢"], [0, "∣"], [0, "∤"], [0, "∥"], [0, "∦"], [0, "∧"], [0, "∨"], [0, { v: "∩", n: 65024, o: "∩︀" }], [0, { v: "∪", n: 65024, o: "∪︀" }], [0, "∫"], [0, "∬"], [0, "∭"], [0, "∮"], [0, "∯"], [0, "∰"], [0, "∱"], [0, "∲"], [0, "∳"], [0, "∴"], [0, "∵"], [0, "∶"], [0, "∷"], [0, "∸"], [1, "∺"], [0, "∻"], [0, { v: "∼", n: 8402, o: "∼⃒" }], [0, { v: "∽", n: 817, o: "∽̱" }], [0, { v: "∾", n: 819, o: "∾̳" }], [0, "∿"], [0, "≀"], [0, "≁"], [0, { v: "≂", n: 824, o: "≂̸" }], [0, "≃"], [0, "≄"], [0, "≅"], [0, "≆"], [0, "≇"], [0, "≈"], [0, "≉"], [0, "≊"], [0, { v: "≋", n: 824, o: "≋̸" }], [0, "≌"], [0, { v: "≍", n: 8402, o: "≍⃒" }], [0, { v: "≎", n: 824, o: "≎̸" }], [0, { v: "≏", n: 824, o: "≏̸" }], [0, { v: "≐", n: 824, o: "≐̸" }], [0, "≑"], [0, "≒"], [0, "≓"], [0, "≔"], [0, "≕"], [0, "≖"], [0, "≗"], [1, "≙"], [0, "≚"], [1, "≜"], [2, "≟"], [0, "≠"], [0, { v: "≡", n: 8421, o: "≡⃥" }], [0, "≢"], [1, { v: "≤", n: 8402, o: "≤⃒" }], [0, { v: "≥", n: 8402, o: "≥⃒" }], [0, { v: "≦", n: 824, o: "≦̸" }], [0, { v: "≧", n: 824, o: "≧̸" }], [0, { v: "≨", n: 65024, o: "≨︀" }], [0, { v: "≩", n: 65024, o: "≩︀" }], [0, { v: "≪", n: new Map(/* @__PURE__ */ restoreDiff([[824, "≪̸"], [7577, "≪⃒"]])) }], [0, { v: "≫", n: new Map(/* @__PURE__ */ restoreDiff([[824, "≫̸"], [7577, "≫⃒"]])) }], [0, "≬"], [0, "≭"], [0, "≮"], [0, "≯"], [0, "≰"], [0, "≱"], [0, "≲"], [0, "≳"], [0, "≴"], [0, "≵"], [0, "≶"], [0, "≷"], [0, "≸"], [0, "≹"], [0, "≺"], [0, "≻"], [0, "≼"], [0, "≽"], [0, "≾"], [0, { v: "≿", n: 824, o: "≿̸" }], [0, "⊀"], [0, "⊁"], [0, { v: "⊂", n: 8402, o: "⊂⃒" }], [0, { v: "⊃", n: 8402, o: "⊃⃒" }], [0, "⊄"], [0, "⊅"], [0, "⊆"], [0, "⊇"], [0, "⊈"], [0, "⊉"], [0, { v: "⊊", n: 65024, o: "⊊︀" }], [0, { v: "⊋", n: 65024, o: "⊋︀" }], [1, "⊍"], [0, "⊎"], [0, { v: "⊏", n: 824, o: "⊏̸" }], [0, { v: "⊐", n: 824, o: "⊐̸" }], [0, "⊑"], [0, "⊒"], [0, { v: "⊓", n: 65024, o: "⊓︀" }], [0, { v: "⊔", n: 65024, o: "⊔︀" }], [0, "⊕"], [0, "⊖"], [0, "⊗"], [0, "⊘"], [0, "⊙"], [0, "⊚"], [0, "⊛"], [1, "⊝"], [0, "⊞"], [0, "⊟"], [0, "⊠"], [0, "⊡"], [0, "⊢"], [0, "⊣"], [0, "⊤"], [0, "⊥"], [1, "⊧"], [0, "⊨"], [0, "⊩"], [0, "⊪"], [0, "⊫"], [0, "⊬"], [0, "⊭"], [0, "⊮"], [0, "⊯"], [0, "⊰"], [1, "⊲"], [0, "⊳"], [0, { v: "⊴", n: 8402, o: "⊴⃒" }], [0, { v: "⊵", n: 8402, o: "⊵⃒" }], [0, "⊶"], [0, "⊷"], [0, "⊸"], [0, "⊹"], [0, "⊺"], [0, "⊻"], [1, "⊽"], [0, "⊾"], [0, "⊿"], [0, "⋀"], [0, "⋁"], [0, "⋂"], [0, "⋃"], [0, "⋄"], [0, "⋅"], [0, "⋆"], [0, "⋇"], [0, "⋈"], [0, "⋉"], [0, "⋊"], [0, "⋋"], [0, "⋌"], [0, "⋍"], [0, "⋎"], [0, "⋏"], [0, "⋐"], [0, "⋑"], [0, "⋒"], [0, "⋓"], [0, "⋔"], [0, "⋕"], [0, "⋖"], [0, "⋗"], [0, { v: "⋘", n: 824, o: "⋘̸" }], [0, { v: "⋙", n: 824, o: "⋙̸" }], [0, { v: "⋚", n: 65024, o: "⋚︀" }], [0, { v: "⋛", n: 65024, o: "⋛︀" }], [2, "⋞"], [0, "⋟"], [0, "⋠"], [0, "⋡"], [0, "⋢"], [0, "⋣"], [2, "⋦"], [0, "⋧"], [0, "⋨"], [0, "⋩"], [0, "⋪"], [0, "⋫"], [0, "⋬"], [0, "⋭"], [0, "⋮"], [0, "⋯"], [0, "⋰"], [0, "⋱"], [0, "⋲"], [0, "⋳"], [0, "⋴"], [0, { v: "⋵", n: 824, o: "⋵̸" }], [0, "⋶"], [0, "⋷"], [1, { v: "⋹", n: 824, o: "⋹̸" }], [0, "⋺"], [0, "⋻"], [0, "⋼"], [0, "⋽"], [0, "⋾"], [6, "⌅"], [0, "⌆"], [1, "⌈"], [0, "⌉"], [0, "⌊"], [0, "⌋"], [0, "⌌"], [0, "⌍"], [0, "⌎"], [0, "⌏"], [0, "⌐"], [1, "⌒"], [0, "⌓"], [1, "⌕"], [0, "⌖"], [5, "⌜"], [0, "⌝"], [0, "⌞"], [0, "⌟"], [2, "⌢"], [0, "⌣"], [9, "⌭"], [0, "⌮"], [7, "⌶"], [6, "⌽"], [1, "⌿"], [60, "⍼"], [51, "⎰"], [0, "⎱"], [2, "⎴"], [0, "⎵"], [0, "⎶"], [37, "⏜"], [0, "⏝"], [0, "⏞"], [0, "⏟"], [2, "⏢"], [4, "⏧"], [59, "␣"], [164, "Ⓢ"], [55, "─"], [1, "│"], [9, "┌"], [3, "┐"], [3, "└"], [3, "┘"], [3, "├"], [7, "┤"], [7, "┬"], [7, "┴"], [7, "┼"], [19, "═"], [0, "║"], [0, "╒"], [0, "╓"], [0, "╔"], [0, "╕"], [0, "╖"], [0, "╗"], [0, "╘"], [0, "╙"], [0, "╚"], [0, "╛"], [0, "╜"], [0, "╝"], [0, "╞"], [0, "╟"], [0, "╠"], [0, "╡"], [0, "╢"], [0, "╣"], [0, "╤"], [0, "╥"], [0, "╦"], [0, "╧"], [0, "╨"], [0, "╩"], [0, "╪"], [0, "╫"], [0, "╬"], [19, "▀"], [3, "▄"], [3, "█"], [8, "░"], [0, "▒"], [0, "▓"], [13, "□"], [8, "▪"], [0, "▫"], [1, "▭"], [0, "▮"], [2, "▱"], [1, "△"], [0, "▴"], [0, "▵"], [2, "▸"], [0, "▹"], [3, "▽"], [0, "▾"], [0, "▿"], [2, "◂"], [0, "◃"], [6, "◊"], [0, "○"], [32, "◬"], [2, "◯"], [8, "◸"], [0, "◹"], [0, "◺"], [0, "◻"], [0, "◼"], [8, "★"], [0, "☆"], [7, "☎"], [49, "♀"], [1, "♂"], [29, "♠"], [2, "♣"], [1, "♥"], [0, "♦"], [3, "♪"], [2, "♭"], [0, "♮"], [0, "♯"], [163, "✓"], [3, "✗"], [8, "✠"], [21, "✶"], [33, "❘"], [25, "❲"], [0, "❳"], [84, "⟈"], [0, "⟉"], [28, "⟦"], [0, "⟧"], [0, "⟨"], [0, "⟩"], [0, "⟪"], [0, "⟫"], [0, "⟬"], [0, "⟭"], [7, "⟵"], [0, "⟶"], [0, "⟷"], [0, "⟸"], [0, "⟹"], [0, "⟺"], [1, "⟼"], [2, "⟿"], [258, "⤂"], [0, "⤃"], [0, "⤄"], [0, "⤅"], [6, "⤌"], [0, "⤍"], [0, "⤎"], [0, "⤏"], [0, "⤐"], [0, "⤑"], [0, "⤒"], [0, "⤓"], [2, "⤖"], [2, "⤙"], [0, "⤚"], [0, "⤛"], [0, "⤜"], [0, "⤝"], [0, "⤞"], [0, "⤟"], [0, "⤠"], [2, "⤣"], [0, "⤤"], [0, "⤥"], [0, "⤦"], [0, "⤧"], [0, "⤨"], [0, "⤩"], [0, "⤪"], [8, { v: "⤳", n: 824, o: "⤳̸" }], [1, "⤵"], [0, "⤶"], [0, "⤷"], [0, "⤸"], [0, "⤹"], [2, "⤼"], [0, "⤽"], [7, "⥅"], [2, "⥈"], [0, "⥉"], [0, "⥊"], [0, "⥋"], [2, "⥎"], [0, "⥏"], [0, "⥐"], [0, "⥑"], [0, "⥒"], [0, "⥓"], [0, "⥔"], [0, "⥕"], [0, "⥖"], [0, "⥗"], [0, "⥘"], [0, "⥙"], [0, "⥚"], [0, "⥛"], [0, "⥜"], [0, "⥝"], [0, "⥞"], [0, "⥟"], [0, "⥠"], [0, "⥡"], [0, "⥢"], [0, "⥣"], [0, "⥤"], [0, "⥥"], [0, "⥦"], [0, "⥧"], [0, "⥨"], [0, "⥩"], [0, "⥪"], [0, "⥫"], [0, "⥬"], [0, "⥭"], [0, "⥮"], [0, "⥯"], [0, "⥰"], [0, "⥱"], [0, "⥲"], [0, "⥳"], [0, "⥴"], [0, "⥵"], [0, "⥶"], [1, "⥸"], [0, "⥹"], [1, "⥻"], [0, "⥼"], [0, "⥽"], [0, "⥾"], [0, "⥿"], [5, "⦅"], [0, "⦆"], [4, "⦋"], [0, "⦌"], [0, "⦍"], [0, "⦎"], [0, "⦏"], [0, "⦐"], [0, "⦑"], [0, "⦒"], [0, "⦓"], [0, "⦔"], [0, "⦕"], [0, "⦖"], [3, "⦚"], [1, "⦜"], [0, "⦝"], [6, "⦤"], [0, "⦥"], [0, "⦦"], [0, "⦧"], [0, "⦨"], [0, "⦩"], [0, "⦪"], [0, "⦫"], [0, "⦬"], [0, "⦭"], [0, "⦮"], [0, "⦯"], [0, "⦰"], [0, "⦱"], [0, "⦲"], [0, "⦳"], [0, "⦴"], [0, "⦵"], [0, "⦶"], [0, "⦷"], [1, "⦹"], [1, "⦻"], [0, "⦼"], [1, "⦾"], [0, "⦿"], [0, "⧀"], [0, "⧁"], [0, "⧂"], [0, "⧃"], [0, "⧄"], [0, "⧅"], [3, "⧉"], [3, "⧍"], [0, "⧎"], [0, { v: "⧏", n: 824, o: "⧏̸" }], [0, { v: "⧐", n: 824, o: "⧐̸" }], [11, "⧜"], [0, "⧝"], [0, "⧞"], [4, "⧣"], [0, "⧤"], [0, "⧥"], [5, "⧫"], [8, "⧴"], [1, "⧶"], [9, "⨀"], [0, "⨁"], [0, "⨂"], [1, "⨄"], [1, "⨆"], [5, "⨌"], [0, "⨍"], [2, "⨐"], [0, "⨑"], [0, "⨒"], [0, "⨓"], [0, "⨔"], [0, "⨕"], [0, "⨖"], [0, "⨗"], [10, "⨢"], [0, "⨣"], [0, "⨤"], [0, "⨥"], [0, "⨦"], [0, "⨧"], [1, "⨩"], [0, "⨪"], [2, "⨭"], [0, "⨮"], [0, "⨯"], [0, "⨰"], [0, "⨱"], [1, "⨳"], [0, "⨴"], [0, "⨵"], [0, "⨶"], [0, "⨷"], [0, "⨸"], [0, "⨹"], [0, "⨺"], [0, "⨻"], [0, "⨼"], [2, "⨿"], [0, "⩀"], [1, "⩂"], [0, "⩃"], [0, "⩄"], [0, "⩅"], [0, "⩆"], [0, "⩇"], [0, "⩈"], [0, "⩉"], [0, "⩊"], [0, "⩋"], [0, "⩌"], [0, "⩍"], [2, "⩐"], [2, "⩓"], [0, "⩔"], [0, "⩕"], [0, "⩖"], [0, "⩗"], [0, "⩘"], [1, "⩚"], [0, "⩛"], [0, "⩜"], [0, "⩝"], [1, "⩟"], [6, "⩦"], [3, "⩪"], [2, { v: "⩭", n: 824, o: "⩭̸" }], [0, "⩮"], [0, "⩯"], [0, { v: "⩰", n: 824, o: "⩰̸" }], [0, "⩱"], [0, "⩲"], [0, "⩳"], [0, "⩴"], [0, "⩵"], [1, "⩷"], [0, "⩸"], [0, "⩹"], [0, "⩺"], [0, "⩻"], [0, "⩼"], [0, { v: "⩽", n: 824, o: "⩽̸" }], [0, { v: "⩾", n: 824, o: "⩾̸" }], [0, "⩿"], [0, "⪀"], [0, "⪁"], [0, "⪂"], [0, "⪃"], [0, "⪄"], [0, "⪅"], [0, "⪆"], [0, "⪇"], [0, "⪈"], [0, "⪉"], [0, "⪊"], [0, "⪋"], [0, "⪌"], [0, "⪍"], [0, "⪎"], [0, "⪏"], [0, "⪐"], [0, "⪑"], [0, "⪒"], [0, "⪓"], [0, "⪔"], [0, "⪕"], [0, "⪖"], [0, "⪗"], [0, "⪘"], [0, "⪙"], [0, "⪚"], [2, "⪝"], [0, "⪞"], [0, "⪟"], [0, "⪠"], [0, { v: "⪡", n: 824, o: "⪡̸" }], [0, { v: "⪢", n: 824, o: "⪢̸" }], [1, "⪤"], [0, "⪥"], [0, "⪦"], [0, "⪧"], [0, "⪨"], [0, "⪩"], [0, "⪪"], [0, "⪫"], [0, { v: "⪬", n: 65024, o: "⪬︀" }], [0, { v: "⪭", n: 65024, o: "⪭︀" }], [0, "⪮"], [0, { v: "⪯", n: 824, o: "⪯̸" }], [0, { v: "⪰", n: 824, o: "⪰̸" }], [2, "⪳"], [0, "⪴"], [0, "⪵"], [0, "⪶"], [0, "⪷"], [0, "⪸"], [0, "⪹"], [0, "⪺"], [0, "⪻"], [0, "⪼"], [0, "⪽"], [0, "⪾"], [0, "⪿"], [0, "⫀"], [0, "⫁"], [0, "⫂"], [0, "⫃"], [0, "⫄"], [0, { v: "⫅", n: 824, o: "⫅̸" }], [0, { v: "⫆", n: 824, o: "⫆̸" }], [0, "⫇"], [0, "⫈"], [2, { v: "⫋", n: 65024, o: "⫋︀" }], [0, { v: "⫌", n: 65024, o: "⫌︀" }], [2, "⫏"], [0, "⫐"], [0, "⫑"], [0, "⫒"], [0, "⫓"], [0, "⫔"], [0, "⫕"], [0, "⫖"], [0, "⫗"], [0, "⫘"], [0, "⫙"], [0, "⫚"], [0, "⫛"], [8, "⫤"], [1, "⫦"], [0, "⫧"], [0, "⫨"], [0, "⫩"], [1, "⫫"], [0, "⫬"], [0, "⫭"], [0, "⫮"], [0, "⫯"], [0, "⫰"], [0, "⫱"], [0, "⫲"], [0, "⫳"], [9, { v: "⫽", n: 8421, o: "⫽⃥" }], [44343, { n: new Map(/* @__PURE__ */ restoreDiff([[56476, "𝒜"], [1, "𝒞"], [0, "𝒟"], [2, "𝒢"], [2, "𝒥"], [0, "𝒦"], [2, "𝒩"], [0, "𝒪"], [0, "𝒫"], [0, "𝒬"], [1, "𝒮"], [0, "𝒯"], [0, "𝒰"], [0, "𝒱"], [0, "𝒲"], [0, "𝒳"], [0, "𝒴"], [0, "𝒵"], [0, "𝒶"], [0, "𝒷"], [0, "𝒸"], [0, "𝒹"], [1, "𝒻"], [1, "𝒽"], [0, "𝒾"], [0, "𝒿"], [0, "𝓀"], [0, "𝓁"], [0, "𝓂"], [0, "𝓃"], [1, "𝓅"], [0, "𝓆"], [0, "𝓇"], [0, "𝓈"], [0, "𝓉"], [0, "𝓊"], [0, "𝓋"], [0, "𝓌"], [0, "𝓍"], [0, "𝓎"], [0, "𝓏"], [52, "𝔄"], [0, "𝔅"], [1, "𝔇"], [0, "𝔈"], [0, "𝔉"], [0, "𝔊"], [2, "𝔍"], [0, "𝔎"], [0, "𝔏"], [0, "𝔐"], [0, "𝔑"], [0, "𝔒"], [0, "𝔓"], [0, "𝔔"], [1, "𝔖"], [0, "𝔗"], [0, "𝔘"], [0, "𝔙"], [0, "𝔚"], [0, "𝔛"], [0, "𝔜"], [1, "𝔞"], [0, "𝔟"], [0, "𝔠"], [0, "𝔡"], [0, "𝔢"], [0, "𝔣"], [0, "𝔤"], [0, "𝔥"], [0, "𝔦"], [0, "𝔧"], [0, "𝔨"], [0, "𝔩"], [0, "𝔪"], [0, "𝔫"], [0, "𝔬"], [0, "𝔭"], [0, "𝔮"], [0, "𝔯"], [0, "𝔰"], [0, "𝔱"], [0, "𝔲"], [0, "𝔳"], [0, "𝔴"], [0, "𝔵"], [0, "𝔶"], [0, "𝔷"], [0, "𝔸"], [0, "𝔹"], [1, "𝔻"], [0, "𝔼"], [0, "𝔽"], [0, "𝔾"], [1, "𝕀"], [0, "𝕁"], [0, "𝕂"], [0, "𝕃"], [0, "𝕄"], [1, "𝕆"], [3, "𝕊"], [0, "𝕋"], [0, "𝕌"], [0, "𝕍"], [0, "𝕎"], [0, "𝕏"], [0, "𝕐"], [1, "𝕒"], [0, "𝕓"], [0, "𝕔"], [0, "𝕕"], [0, "𝕖"], [0, "𝕗"], [0, "𝕘"], [0, "𝕙"], [0, "𝕚"], [0, "𝕛"], [0, "𝕜"], [0, "𝕝"], [0, "𝕞"], [0, "𝕟"], [0, "𝕠"], [0, "𝕡"], [0, "𝕢"], [0, "𝕣"], [0, "𝕤"], [0, "𝕥"], [0, "𝕦"], [0, "𝕧"], [0, "𝕨"], [0, "𝕩"], [0, "𝕪"], [0, "𝕫"]])) }], [8906, "ff"], [0, "fi"], [0, "fl"], [0, "ffi"], [0, "ffl"]]));
|
|
});
|
|
|
|
// node_modules/entities/lib/escape.js
|
|
var require_escape = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.escapeText = exports.escapeAttribute = exports.escapeUTF8 = exports.escape = exports.encodeXML = exports.getCodePoint = exports.xmlReplacer = undefined;
|
|
exports.xmlReplacer = /["&'<>$\x80-\uFFFF]/g;
|
|
var xmlCodeMap = new Map([
|
|
[34, """],
|
|
[38, "&"],
|
|
[39, "'"],
|
|
[60, "<"],
|
|
[62, ">"]
|
|
]);
|
|
exports.getCodePoint = String.prototype.codePointAt != null ? function(str, index) {
|
|
return str.codePointAt(index);
|
|
} : function(c, index) {
|
|
return (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index);
|
|
};
|
|
function encodeXML(str) {
|
|
var ret = "";
|
|
var lastIdx = 0;
|
|
var match;
|
|
while ((match = exports.xmlReplacer.exec(str)) !== null) {
|
|
var i = match.index;
|
|
var char = str.charCodeAt(i);
|
|
var next = xmlCodeMap.get(char);
|
|
if (next !== undefined) {
|
|
ret += str.substring(lastIdx, i) + next;
|
|
lastIdx = i + 1;
|
|
} else {
|
|
ret += "".concat(str.substring(lastIdx, i), "&#x").concat((0, exports.getCodePoint)(str, i).toString(16), ";");
|
|
lastIdx = exports.xmlReplacer.lastIndex += Number((char & 64512) === 55296);
|
|
}
|
|
}
|
|
return ret + str.substr(lastIdx);
|
|
}
|
|
exports.encodeXML = encodeXML;
|
|
exports.escape = encodeXML;
|
|
function getEscaper(regex, map) {
|
|
return function escape(data) {
|
|
var match;
|
|
var lastIdx = 0;
|
|
var result = "";
|
|
while (match = regex.exec(data)) {
|
|
if (lastIdx !== match.index) {
|
|
result += data.substring(lastIdx, match.index);
|
|
}
|
|
result += map.get(match[0].charCodeAt(0));
|
|
lastIdx = match.index + 1;
|
|
}
|
|
return result + data.substring(lastIdx);
|
|
};
|
|
}
|
|
exports.escapeUTF8 = getEscaper(/[&<>'"]/g, xmlCodeMap);
|
|
exports.escapeAttribute = getEscaper(/["&\u00A0]/g, new Map([
|
|
[34, """],
|
|
[38, "&"],
|
|
[160, " "]
|
|
]));
|
|
exports.escapeText = getEscaper(/[&<>\u00A0]/g, new Map([
|
|
[38, "&"],
|
|
[60, "<"],
|
|
[62, ">"],
|
|
[160, " "]
|
|
]));
|
|
});
|
|
|
|
// node_modules/entities/lib/encode.js
|
|
var require_encode = __commonJS((exports) => {
|
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.encodeNonAsciiHTML = exports.encodeHTML = undefined;
|
|
var encode_html_js_1 = __importDefault(require_encode_html());
|
|
var escape_js_1 = require_escape();
|
|
var htmlReplacer = /[\t\n!-,./:-@[-`\f{-}$\x80-\uFFFF]/g;
|
|
function encodeHTML(data) {
|
|
return encodeHTMLTrieRe(htmlReplacer, data);
|
|
}
|
|
exports.encodeHTML = encodeHTML;
|
|
function encodeNonAsciiHTML(data) {
|
|
return encodeHTMLTrieRe(escape_js_1.xmlReplacer, data);
|
|
}
|
|
exports.encodeNonAsciiHTML = encodeNonAsciiHTML;
|
|
function encodeHTMLTrieRe(regExp, str) {
|
|
var ret = "";
|
|
var lastIdx = 0;
|
|
var match;
|
|
while ((match = regExp.exec(str)) !== null) {
|
|
var i = match.index;
|
|
ret += str.substring(lastIdx, i);
|
|
var char = str.charCodeAt(i);
|
|
var next = encode_html_js_1.default.get(char);
|
|
if (typeof next === "object") {
|
|
if (i + 1 < str.length) {
|
|
var nextChar = str.charCodeAt(i + 1);
|
|
var value = typeof next.n === "number" ? next.n === nextChar ? next.o : undefined : next.n.get(nextChar);
|
|
if (value !== undefined) {
|
|
ret += value;
|
|
lastIdx = regExp.lastIndex += 1;
|
|
continue;
|
|
}
|
|
}
|
|
next = next.v;
|
|
}
|
|
if (next !== undefined) {
|
|
ret += next;
|
|
lastIdx = i + 1;
|
|
} else {
|
|
var cp = (0, escape_js_1.getCodePoint)(str, i);
|
|
ret += "&#x".concat(cp.toString(16), ";");
|
|
lastIdx = regExp.lastIndex += Number(cp !== char);
|
|
}
|
|
}
|
|
return ret + str.substr(lastIdx);
|
|
}
|
|
});
|
|
|
|
// node_modules/entities/lib/index.js
|
|
var require_lib3 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLAttribute = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.DecodingMode = exports.EntityDecoder = exports.encodeHTML5 = exports.encodeHTML4 = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.escapeText = exports.escapeAttribute = exports.escapeUTF8 = exports.escape = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = exports.EncodingMode = exports.EntityLevel = undefined;
|
|
var decode_js_1 = require_decode();
|
|
var encode_js_1 = require_encode();
|
|
var escape_js_1 = require_escape();
|
|
var EntityLevel;
|
|
(function(EntityLevel2) {
|
|
EntityLevel2[EntityLevel2["XML"] = 0] = "XML";
|
|
EntityLevel2[EntityLevel2["HTML"] = 1] = "HTML";
|
|
})(EntityLevel = exports.EntityLevel || (exports.EntityLevel = {}));
|
|
var EncodingMode;
|
|
(function(EncodingMode2) {
|
|
EncodingMode2[EncodingMode2["UTF8"] = 0] = "UTF8";
|
|
EncodingMode2[EncodingMode2["ASCII"] = 1] = "ASCII";
|
|
EncodingMode2[EncodingMode2["Extensive"] = 2] = "Extensive";
|
|
EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
|
|
EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
|
|
})(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));
|
|
function decode(data, options) {
|
|
if (options === undefined) {
|
|
options = EntityLevel.XML;
|
|
}
|
|
var level = typeof options === "number" ? options : options.level;
|
|
if (level === EntityLevel.HTML) {
|
|
var mode = typeof options === "object" ? options.mode : undefined;
|
|
return (0, decode_js_1.decodeHTML)(data, mode);
|
|
}
|
|
return (0, decode_js_1.decodeXML)(data);
|
|
}
|
|
exports.decode = decode;
|
|
function decodeStrict(data, options) {
|
|
var _a;
|
|
if (options === undefined) {
|
|
options = EntityLevel.XML;
|
|
}
|
|
var opts = typeof options === "number" ? { level: options } : options;
|
|
(_a = opts.mode) !== null && _a !== undefined || (opts.mode = decode_js_1.DecodingMode.Strict);
|
|
return decode(data, opts);
|
|
}
|
|
exports.decodeStrict = decodeStrict;
|
|
function encode(data, options) {
|
|
if (options === undefined) {
|
|
options = EntityLevel.XML;
|
|
}
|
|
var opts = typeof options === "number" ? { level: options } : options;
|
|
if (opts.mode === EncodingMode.UTF8)
|
|
return (0, escape_js_1.escapeUTF8)(data);
|
|
if (opts.mode === EncodingMode.Attribute)
|
|
return (0, escape_js_1.escapeAttribute)(data);
|
|
if (opts.mode === EncodingMode.Text)
|
|
return (0, escape_js_1.escapeText)(data);
|
|
if (opts.level === EntityLevel.HTML) {
|
|
if (opts.mode === EncodingMode.ASCII) {
|
|
return (0, encode_js_1.encodeNonAsciiHTML)(data);
|
|
}
|
|
return (0, encode_js_1.encodeHTML)(data);
|
|
}
|
|
return (0, escape_js_1.encodeXML)(data);
|
|
}
|
|
exports.encode = encode;
|
|
var escape_js_2 = require_escape();
|
|
Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function() {
|
|
return escape_js_2.encodeXML;
|
|
} });
|
|
Object.defineProperty(exports, "escape", { enumerable: true, get: function() {
|
|
return escape_js_2.escape;
|
|
} });
|
|
Object.defineProperty(exports, "escapeUTF8", { enumerable: true, get: function() {
|
|
return escape_js_2.escapeUTF8;
|
|
} });
|
|
Object.defineProperty(exports, "escapeAttribute", { enumerable: true, get: function() {
|
|
return escape_js_2.escapeAttribute;
|
|
} });
|
|
Object.defineProperty(exports, "escapeText", { enumerable: true, get: function() {
|
|
return escape_js_2.escapeText;
|
|
} });
|
|
var encode_js_2 = require_encode();
|
|
Object.defineProperty(exports, "encodeHTML", { enumerable: true, get: function() {
|
|
return encode_js_2.encodeHTML;
|
|
} });
|
|
Object.defineProperty(exports, "encodeNonAsciiHTML", { enumerable: true, get: function() {
|
|
return encode_js_2.encodeNonAsciiHTML;
|
|
} });
|
|
Object.defineProperty(exports, "encodeHTML4", { enumerable: true, get: function() {
|
|
return encode_js_2.encodeHTML;
|
|
} });
|
|
Object.defineProperty(exports, "encodeHTML5", { enumerable: true, get: function() {
|
|
return encode_js_2.encodeHTML;
|
|
} });
|
|
var decode_js_2 = require_decode();
|
|
Object.defineProperty(exports, "EntityDecoder", { enumerable: true, get: function() {
|
|
return decode_js_2.EntityDecoder;
|
|
} });
|
|
Object.defineProperty(exports, "DecodingMode", { enumerable: true, get: function() {
|
|
return decode_js_2.DecodingMode;
|
|
} });
|
|
Object.defineProperty(exports, "decodeXML", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeXML;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTML", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTML;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTMLStrict", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTMLStrict;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTMLAttribute", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTMLAttribute;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTML4", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTML;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTML5", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTML;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTML4Strict", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTMLStrict;
|
|
} });
|
|
Object.defineProperty(exports, "decodeHTML5Strict", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeHTMLStrict;
|
|
} });
|
|
Object.defineProperty(exports, "decodeXMLStrict", { enumerable: true, get: function() {
|
|
return decode_js_2.decodeXML;
|
|
} });
|
|
});
|
|
|
|
// node_modules/dom-serializer/lib/foreignNames.js
|
|
var require_foreignNames = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.attributeNames = exports.elementNames = undefined;
|
|
exports.elementNames = new Map([
|
|
"altGlyph",
|
|
"altGlyphDef",
|
|
"altGlyphItem",
|
|
"animateColor",
|
|
"animateMotion",
|
|
"animateTransform",
|
|
"clipPath",
|
|
"feBlend",
|
|
"feColorMatrix",
|
|
"feComponentTransfer",
|
|
"feComposite",
|
|
"feConvolveMatrix",
|
|
"feDiffuseLighting",
|
|
"feDisplacementMap",
|
|
"feDistantLight",
|
|
"feDropShadow",
|
|
"feFlood",
|
|
"feFuncA",
|
|
"feFuncB",
|
|
"feFuncG",
|
|
"feFuncR",
|
|
"feGaussianBlur",
|
|
"feImage",
|
|
"feMerge",
|
|
"feMergeNode",
|
|
"feMorphology",
|
|
"feOffset",
|
|
"fePointLight",
|
|
"feSpecularLighting",
|
|
"feSpotLight",
|
|
"feTile",
|
|
"feTurbulence",
|
|
"foreignObject",
|
|
"glyphRef",
|
|
"linearGradient",
|
|
"radialGradient",
|
|
"textPath"
|
|
].map(function(val) {
|
|
return [val.toLowerCase(), val];
|
|
}));
|
|
exports.attributeNames = new Map([
|
|
"definitionURL",
|
|
"attributeName",
|
|
"attributeType",
|
|
"baseFrequency",
|
|
"baseProfile",
|
|
"calcMode",
|
|
"clipPathUnits",
|
|
"diffuseConstant",
|
|
"edgeMode",
|
|
"filterUnits",
|
|
"glyphRef",
|
|
"gradientTransform",
|
|
"gradientUnits",
|
|
"kernelMatrix",
|
|
"kernelUnitLength",
|
|
"keyPoints",
|
|
"keySplines",
|
|
"keyTimes",
|
|
"lengthAdjust",
|
|
"limitingConeAngle",
|
|
"markerHeight",
|
|
"markerUnits",
|
|
"markerWidth",
|
|
"maskContentUnits",
|
|
"maskUnits",
|
|
"numOctaves",
|
|
"pathLength",
|
|
"patternContentUnits",
|
|
"patternTransform",
|
|
"patternUnits",
|
|
"pointsAtX",
|
|
"pointsAtY",
|
|
"pointsAtZ",
|
|
"preserveAlpha",
|
|
"preserveAspectRatio",
|
|
"primitiveUnits",
|
|
"refX",
|
|
"refY",
|
|
"repeatCount",
|
|
"repeatDur",
|
|
"requiredExtensions",
|
|
"requiredFeatures",
|
|
"specularConstant",
|
|
"specularExponent",
|
|
"spreadMethod",
|
|
"startOffset",
|
|
"stdDeviation",
|
|
"stitchTiles",
|
|
"surfaceScale",
|
|
"systemLanguage",
|
|
"tableValues",
|
|
"targetX",
|
|
"targetY",
|
|
"textLength",
|
|
"viewBox",
|
|
"viewTarget",
|
|
"xChannelSelector",
|
|
"yChannelSelector",
|
|
"zoomAndPan"
|
|
].map(function(val) {
|
|
return [val.toLowerCase(), val];
|
|
}));
|
|
});
|
|
|
|
// node_modules/dom-serializer/lib/index.js
|
|
var require_lib4 = __commonJS((exports) => {
|
|
var __assign = exports && exports.__assign || function() {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length;i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__importStar || function(mod) {
|
|
if (mod && mod.__esModule)
|
|
return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod)
|
|
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
|
|
__createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.render = undefined;
|
|
var ElementType = __importStar(require_lib());
|
|
var entities_1 = require_lib3();
|
|
var foreignNames_js_1 = require_foreignNames();
|
|
var unencodedElements = new Set([
|
|
"style",
|
|
"script",
|
|
"xmp",
|
|
"iframe",
|
|
"noembed",
|
|
"noframes",
|
|
"plaintext",
|
|
"noscript"
|
|
]);
|
|
function replaceQuotes(value) {
|
|
return value.replace(/"/g, """);
|
|
}
|
|
function formatAttributes(attributes, opts) {
|
|
var _a;
|
|
if (!attributes)
|
|
return;
|
|
var encode = ((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) === false ? replaceQuotes : opts.xmlMode || opts.encodeEntities !== "utf8" ? entities_1.encodeXML : entities_1.escapeAttribute;
|
|
return Object.keys(attributes).map(function(key) {
|
|
var _a2, _b;
|
|
var value = (_a2 = attributes[key]) !== null && _a2 !== undefined ? _a2 : "";
|
|
if (opts.xmlMode === "foreign") {
|
|
key = (_b = foreignNames_js_1.attributeNames.get(key)) !== null && _b !== undefined ? _b : key;
|
|
}
|
|
if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
|
|
return key;
|
|
}
|
|
return "".concat(key, "=\"").concat(encode(value), "\"");
|
|
}).join(" ");
|
|
}
|
|
var singleTag = new Set([
|
|
"area",
|
|
"base",
|
|
"basefont",
|
|
"br",
|
|
"col",
|
|
"command",
|
|
"embed",
|
|
"frame",
|
|
"hr",
|
|
"img",
|
|
"input",
|
|
"isindex",
|
|
"keygen",
|
|
"link",
|
|
"meta",
|
|
"param",
|
|
"source",
|
|
"track",
|
|
"wbr"
|
|
]);
|
|
function render(node, options) {
|
|
if (options === undefined) {
|
|
options = {};
|
|
}
|
|
var nodes = "length" in node ? node : [node];
|
|
var output = "";
|
|
for (var i = 0;i < nodes.length; i++) {
|
|
output += renderNode(nodes[i], options);
|
|
}
|
|
return output;
|
|
}
|
|
exports.render = render;
|
|
exports.default = render;
|
|
function renderNode(node, options) {
|
|
switch (node.type) {
|
|
case ElementType.Root:
|
|
return render(node.children, options);
|
|
case ElementType.Doctype:
|
|
case ElementType.Directive:
|
|
return renderDirective(node);
|
|
case ElementType.Comment:
|
|
return renderComment(node);
|
|
case ElementType.CDATA:
|
|
return renderCdata(node);
|
|
case ElementType.Script:
|
|
case ElementType.Style:
|
|
case ElementType.Tag:
|
|
return renderTag(node, options);
|
|
case ElementType.Text:
|
|
return renderText(node, options);
|
|
}
|
|
}
|
|
var foreignModeIntegrationPoints = new Set([
|
|
"mi",
|
|
"mo",
|
|
"mn",
|
|
"ms",
|
|
"mtext",
|
|
"annotation-xml",
|
|
"foreignObject",
|
|
"desc",
|
|
"title"
|
|
]);
|
|
var foreignElements = new Set(["svg", "math"]);
|
|
function renderTag(elem, opts) {
|
|
var _a;
|
|
if (opts.xmlMode === "foreign") {
|
|
elem.name = (_a = foreignNames_js_1.elementNames.get(elem.name)) !== null && _a !== undefined ? _a : elem.name;
|
|
if (elem.parent && foreignModeIntegrationPoints.has(elem.parent.name)) {
|
|
opts = __assign(__assign({}, opts), { xmlMode: false });
|
|
}
|
|
}
|
|
if (!opts.xmlMode && foreignElements.has(elem.name)) {
|
|
opts = __assign(__assign({}, opts), { xmlMode: "foreign" });
|
|
}
|
|
var tag = "<".concat(elem.name);
|
|
var attribs = formatAttributes(elem.attribs, opts);
|
|
if (attribs) {
|
|
tag += " ".concat(attribs);
|
|
}
|
|
if (elem.children.length === 0 && (opts.xmlMode ? opts.selfClosingTags !== false : opts.selfClosingTags && singleTag.has(elem.name))) {
|
|
if (!opts.xmlMode)
|
|
tag += " ";
|
|
tag += "/>";
|
|
} else {
|
|
tag += ">";
|
|
if (elem.children.length > 0) {
|
|
tag += render(elem.children, opts);
|
|
}
|
|
if (opts.xmlMode || !singleTag.has(elem.name)) {
|
|
tag += "</".concat(elem.name, ">");
|
|
}
|
|
}
|
|
return tag;
|
|
}
|
|
function renderDirective(elem) {
|
|
return "<".concat(elem.data, ">");
|
|
}
|
|
function renderText(elem, opts) {
|
|
var _a;
|
|
var data = elem.data || "";
|
|
if (((_a = opts.encodeEntities) !== null && _a !== undefined ? _a : opts.decodeEntities) !== false && !(!opts.xmlMode && elem.parent && unencodedElements.has(elem.parent.name))) {
|
|
data = opts.xmlMode || opts.encodeEntities !== "utf8" ? (0, entities_1.encodeXML)(data) : (0, entities_1.escapeText)(data);
|
|
}
|
|
return data;
|
|
}
|
|
function renderCdata(elem) {
|
|
return "<![CDATA[".concat(elem.children[0].data, "]]>");
|
|
}
|
|
function renderComment(elem) {
|
|
return "<!--".concat(elem.data, "-->");
|
|
}
|
|
});
|
|
|
|
// node_modules/domutils/lib/stringify.js
|
|
var require_stringify = __commonJS((exports) => {
|
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.innerText = exports.textContent = exports.getText = exports.getInnerHTML = exports.getOuterHTML = undefined;
|
|
var domhandler_1 = require_lib2();
|
|
var dom_serializer_1 = __importDefault(require_lib4());
|
|
var domelementtype_1 = require_lib();
|
|
function getOuterHTML(node, options) {
|
|
return (0, dom_serializer_1.default)(node, options);
|
|
}
|
|
exports.getOuterHTML = getOuterHTML;
|
|
function getInnerHTML(node, options) {
|
|
return (0, domhandler_1.hasChildren)(node) ? node.children.map(function(node2) {
|
|
return getOuterHTML(node2, options);
|
|
}).join("") : "";
|
|
}
|
|
exports.getInnerHTML = getInnerHTML;
|
|
function getText(node) {
|
|
if (Array.isArray(node))
|
|
return node.map(getText).join("");
|
|
if ((0, domhandler_1.isTag)(node))
|
|
return node.name === "br" ? "\n" : getText(node.children);
|
|
if ((0, domhandler_1.isCDATA)(node))
|
|
return getText(node.children);
|
|
if ((0, domhandler_1.isText)(node))
|
|
return node.data;
|
|
return "";
|
|
}
|
|
exports.getText = getText;
|
|
function textContent(node) {
|
|
if (Array.isArray(node))
|
|
return node.map(textContent).join("");
|
|
if ((0, domhandler_1.hasChildren)(node) && !(0, domhandler_1.isComment)(node)) {
|
|
return textContent(node.children);
|
|
}
|
|
if ((0, domhandler_1.isText)(node))
|
|
return node.data;
|
|
return "";
|
|
}
|
|
exports.textContent = textContent;
|
|
function innerText(node) {
|
|
if (Array.isArray(node))
|
|
return node.map(innerText).join("");
|
|
if ((0, domhandler_1.hasChildren)(node) && (node.type === domelementtype_1.ElementType.Tag || (0, domhandler_1.isCDATA)(node))) {
|
|
return innerText(node.children);
|
|
}
|
|
if ((0, domhandler_1.isText)(node))
|
|
return node.data;
|
|
return "";
|
|
}
|
|
exports.innerText = innerText;
|
|
});
|
|
|
|
// node_modules/domutils/lib/traversal.js
|
|
var require_traversal = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.prevElementSibling = exports.nextElementSibling = exports.getName = exports.hasAttrib = exports.getAttributeValue = exports.getSiblings = exports.getParent = exports.getChildren = undefined;
|
|
var domhandler_1 = require_lib2();
|
|
function getChildren(elem) {
|
|
return (0, domhandler_1.hasChildren)(elem) ? elem.children : [];
|
|
}
|
|
exports.getChildren = getChildren;
|
|
function getParent(elem) {
|
|
return elem.parent || null;
|
|
}
|
|
exports.getParent = getParent;
|
|
function getSiblings(elem) {
|
|
var _a, _b;
|
|
var parent = getParent(elem);
|
|
if (parent != null)
|
|
return getChildren(parent);
|
|
var siblings = [elem];
|
|
var { prev, next } = elem;
|
|
while (prev != null) {
|
|
siblings.unshift(prev);
|
|
_a = prev, prev = _a.prev;
|
|
}
|
|
while (next != null) {
|
|
siblings.push(next);
|
|
_b = next, next = _b.next;
|
|
}
|
|
return siblings;
|
|
}
|
|
exports.getSiblings = getSiblings;
|
|
function getAttributeValue(elem, name) {
|
|
var _a;
|
|
return (_a = elem.attribs) === null || _a === undefined ? undefined : _a[name];
|
|
}
|
|
exports.getAttributeValue = getAttributeValue;
|
|
function hasAttrib(elem, name) {
|
|
return elem.attribs != null && Object.prototype.hasOwnProperty.call(elem.attribs, name) && elem.attribs[name] != null;
|
|
}
|
|
exports.hasAttrib = hasAttrib;
|
|
function getName(elem) {
|
|
return elem.name;
|
|
}
|
|
exports.getName = getName;
|
|
function nextElementSibling(elem) {
|
|
var _a;
|
|
var next = elem.next;
|
|
while (next !== null && !(0, domhandler_1.isTag)(next))
|
|
_a = next, next = _a.next;
|
|
return next;
|
|
}
|
|
exports.nextElementSibling = nextElementSibling;
|
|
function prevElementSibling(elem) {
|
|
var _a;
|
|
var prev = elem.prev;
|
|
while (prev !== null && !(0, domhandler_1.isTag)(prev))
|
|
_a = prev, prev = _a.prev;
|
|
return prev;
|
|
}
|
|
exports.prevElementSibling = prevElementSibling;
|
|
});
|
|
|
|
// node_modules/domutils/lib/manipulation.js
|
|
var require_manipulation = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.prepend = exports.prependChild = exports.append = exports.appendChild = exports.replaceElement = exports.removeElement = undefined;
|
|
function removeElement(elem) {
|
|
if (elem.prev)
|
|
elem.prev.next = elem.next;
|
|
if (elem.next)
|
|
elem.next.prev = elem.prev;
|
|
if (elem.parent) {
|
|
var childs = elem.parent.children;
|
|
var childsIndex = childs.lastIndexOf(elem);
|
|
if (childsIndex >= 0) {
|
|
childs.splice(childsIndex, 1);
|
|
}
|
|
}
|
|
elem.next = null;
|
|
elem.prev = null;
|
|
elem.parent = null;
|
|
}
|
|
exports.removeElement = removeElement;
|
|
function replaceElement(elem, replacement) {
|
|
var prev = replacement.prev = elem.prev;
|
|
if (prev) {
|
|
prev.next = replacement;
|
|
}
|
|
var next = replacement.next = elem.next;
|
|
if (next) {
|
|
next.prev = replacement;
|
|
}
|
|
var parent = replacement.parent = elem.parent;
|
|
if (parent) {
|
|
var childs = parent.children;
|
|
childs[childs.lastIndexOf(elem)] = replacement;
|
|
elem.parent = null;
|
|
}
|
|
}
|
|
exports.replaceElement = replaceElement;
|
|
function appendChild(parent, child) {
|
|
removeElement(child);
|
|
child.next = null;
|
|
child.parent = parent;
|
|
if (parent.children.push(child) > 1) {
|
|
var sibling = parent.children[parent.children.length - 2];
|
|
sibling.next = child;
|
|
child.prev = sibling;
|
|
} else {
|
|
child.prev = null;
|
|
}
|
|
}
|
|
exports.appendChild = appendChild;
|
|
function append(elem, next) {
|
|
removeElement(next);
|
|
var parent = elem.parent;
|
|
var currNext = elem.next;
|
|
next.next = currNext;
|
|
next.prev = elem;
|
|
elem.next = next;
|
|
next.parent = parent;
|
|
if (currNext) {
|
|
currNext.prev = next;
|
|
if (parent) {
|
|
var childs = parent.children;
|
|
childs.splice(childs.lastIndexOf(currNext), 0, next);
|
|
}
|
|
} else if (parent) {
|
|
parent.children.push(next);
|
|
}
|
|
}
|
|
exports.append = append;
|
|
function prependChild(parent, child) {
|
|
removeElement(child);
|
|
child.parent = parent;
|
|
child.prev = null;
|
|
if (parent.children.unshift(child) !== 1) {
|
|
var sibling = parent.children[1];
|
|
sibling.prev = child;
|
|
child.next = sibling;
|
|
} else {
|
|
child.next = null;
|
|
}
|
|
}
|
|
exports.prependChild = prependChild;
|
|
function prepend(elem, prev) {
|
|
removeElement(prev);
|
|
var parent = elem.parent;
|
|
if (parent) {
|
|
var childs = parent.children;
|
|
childs.splice(childs.indexOf(elem), 0, prev);
|
|
}
|
|
if (elem.prev) {
|
|
elem.prev.next = prev;
|
|
}
|
|
prev.parent = parent;
|
|
prev.prev = elem.prev;
|
|
prev.next = elem;
|
|
elem.prev = prev;
|
|
}
|
|
exports.prepend = prepend;
|
|
});
|
|
|
|
// node_modules/domutils/lib/querying.js
|
|
var require_querying = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.findAll = exports.existsOne = exports.findOne = exports.findOneChild = exports.find = exports.filter = undefined;
|
|
var domhandler_1 = require_lib2();
|
|
function filter(test, node, recurse, limit) {
|
|
if (recurse === undefined) {
|
|
recurse = true;
|
|
}
|
|
if (limit === undefined) {
|
|
limit = Infinity;
|
|
}
|
|
return find(test, Array.isArray(node) ? node : [node], recurse, limit);
|
|
}
|
|
exports.filter = filter;
|
|
function find(test, nodes, recurse, limit) {
|
|
var result = [];
|
|
var nodeStack = [nodes];
|
|
var indexStack = [0];
|
|
for (;; ) {
|
|
if (indexStack[0] >= nodeStack[0].length) {
|
|
if (indexStack.length === 1) {
|
|
return result;
|
|
}
|
|
nodeStack.shift();
|
|
indexStack.shift();
|
|
continue;
|
|
}
|
|
var elem = nodeStack[0][indexStack[0]++];
|
|
if (test(elem)) {
|
|
result.push(elem);
|
|
if (--limit <= 0)
|
|
return result;
|
|
}
|
|
if (recurse && (0, domhandler_1.hasChildren)(elem) && elem.children.length > 0) {
|
|
indexStack.unshift(0);
|
|
nodeStack.unshift(elem.children);
|
|
}
|
|
}
|
|
}
|
|
exports.find = find;
|
|
function findOneChild(test, nodes) {
|
|
return nodes.find(test);
|
|
}
|
|
exports.findOneChild = findOneChild;
|
|
function findOne(test, nodes, recurse) {
|
|
if (recurse === undefined) {
|
|
recurse = true;
|
|
}
|
|
var elem = null;
|
|
for (var i = 0;i < nodes.length && !elem; i++) {
|
|
var node = nodes[i];
|
|
if (!(0, domhandler_1.isTag)(node)) {
|
|
continue;
|
|
} else if (test(node)) {
|
|
elem = node;
|
|
} else if (recurse && node.children.length > 0) {
|
|
elem = findOne(test, node.children, true);
|
|
}
|
|
}
|
|
return elem;
|
|
}
|
|
exports.findOne = findOne;
|
|
function existsOne(test, nodes) {
|
|
return nodes.some(function(checked) {
|
|
return (0, domhandler_1.isTag)(checked) && (test(checked) || existsOne(test, checked.children));
|
|
});
|
|
}
|
|
exports.existsOne = existsOne;
|
|
function findAll(test, nodes) {
|
|
var result = [];
|
|
var nodeStack = [nodes];
|
|
var indexStack = [0];
|
|
for (;; ) {
|
|
if (indexStack[0] >= nodeStack[0].length) {
|
|
if (nodeStack.length === 1) {
|
|
return result;
|
|
}
|
|
nodeStack.shift();
|
|
indexStack.shift();
|
|
continue;
|
|
}
|
|
var elem = nodeStack[0][indexStack[0]++];
|
|
if (!(0, domhandler_1.isTag)(elem))
|
|
continue;
|
|
if (test(elem))
|
|
result.push(elem);
|
|
if (elem.children.length > 0) {
|
|
indexStack.unshift(0);
|
|
nodeStack.unshift(elem.children);
|
|
}
|
|
}
|
|
}
|
|
exports.findAll = findAll;
|
|
});
|
|
|
|
// node_modules/domutils/lib/legacy.js
|
|
var require_legacy = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getElementsByTagType = exports.getElementsByTagName = exports.getElementById = exports.getElements = exports.testElement = undefined;
|
|
var domhandler_1 = require_lib2();
|
|
var querying_js_1 = require_querying();
|
|
var Checks = {
|
|
tag_name: function(name) {
|
|
if (typeof name === "function") {
|
|
return function(elem) {
|
|
return (0, domhandler_1.isTag)(elem) && name(elem.name);
|
|
};
|
|
} else if (name === "*") {
|
|
return domhandler_1.isTag;
|
|
}
|
|
return function(elem) {
|
|
return (0, domhandler_1.isTag)(elem) && elem.name === name;
|
|
};
|
|
},
|
|
tag_type: function(type) {
|
|
if (typeof type === "function") {
|
|
return function(elem) {
|
|
return type(elem.type);
|
|
};
|
|
}
|
|
return function(elem) {
|
|
return elem.type === type;
|
|
};
|
|
},
|
|
tag_contains: function(data) {
|
|
if (typeof data === "function") {
|
|
return function(elem) {
|
|
return (0, domhandler_1.isText)(elem) && data(elem.data);
|
|
};
|
|
}
|
|
return function(elem) {
|
|
return (0, domhandler_1.isText)(elem) && elem.data === data;
|
|
};
|
|
}
|
|
};
|
|
function getAttribCheck(attrib, value) {
|
|
if (typeof value === "function") {
|
|
return function(elem) {
|
|
return (0, domhandler_1.isTag)(elem) && value(elem.attribs[attrib]);
|
|
};
|
|
}
|
|
return function(elem) {
|
|
return (0, domhandler_1.isTag)(elem) && elem.attribs[attrib] === value;
|
|
};
|
|
}
|
|
function combineFuncs(a, b) {
|
|
return function(elem) {
|
|
return a(elem) || b(elem);
|
|
};
|
|
}
|
|
function compileTest(options) {
|
|
var funcs = Object.keys(options).map(function(key) {
|
|
var value = options[key];
|
|
return Object.prototype.hasOwnProperty.call(Checks, key) ? Checks[key](value) : getAttribCheck(key, value);
|
|
});
|
|
return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
|
|
}
|
|
function testElement(options, node) {
|
|
var test = compileTest(options);
|
|
return test ? test(node) : true;
|
|
}
|
|
exports.testElement = testElement;
|
|
function getElements(options, nodes, recurse, limit) {
|
|
if (limit === undefined) {
|
|
limit = Infinity;
|
|
}
|
|
var test = compileTest(options);
|
|
return test ? (0, querying_js_1.filter)(test, nodes, recurse, limit) : [];
|
|
}
|
|
exports.getElements = getElements;
|
|
function getElementById(id, nodes, recurse) {
|
|
if (recurse === undefined) {
|
|
recurse = true;
|
|
}
|
|
if (!Array.isArray(nodes))
|
|
nodes = [nodes];
|
|
return (0, querying_js_1.findOne)(getAttribCheck("id", id), nodes, recurse);
|
|
}
|
|
exports.getElementById = getElementById;
|
|
function getElementsByTagName(tagName, nodes, recurse, limit) {
|
|
if (recurse === undefined) {
|
|
recurse = true;
|
|
}
|
|
if (limit === undefined) {
|
|
limit = Infinity;
|
|
}
|
|
return (0, querying_js_1.filter)(Checks["tag_name"](tagName), nodes, recurse, limit);
|
|
}
|
|
exports.getElementsByTagName = getElementsByTagName;
|
|
function getElementsByTagType(type, nodes, recurse, limit) {
|
|
if (recurse === undefined) {
|
|
recurse = true;
|
|
}
|
|
if (limit === undefined) {
|
|
limit = Infinity;
|
|
}
|
|
return (0, querying_js_1.filter)(Checks["tag_type"](type), nodes, recurse, limit);
|
|
}
|
|
exports.getElementsByTagType = getElementsByTagType;
|
|
});
|
|
|
|
// node_modules/domutils/lib/helpers.js
|
|
var require_helpers = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.uniqueSort = exports.compareDocumentPosition = exports.DocumentPosition = exports.removeSubsets = undefined;
|
|
var domhandler_1 = require_lib2();
|
|
function removeSubsets(nodes) {
|
|
var idx = nodes.length;
|
|
while (--idx >= 0) {
|
|
var node = nodes[idx];
|
|
if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
|
|
nodes.splice(idx, 1);
|
|
continue;
|
|
}
|
|
for (var ancestor = node.parent;ancestor; ancestor = ancestor.parent) {
|
|
if (nodes.includes(ancestor)) {
|
|
nodes.splice(idx, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return nodes;
|
|
}
|
|
exports.removeSubsets = removeSubsets;
|
|
var DocumentPosition;
|
|
(function(DocumentPosition2) {
|
|
DocumentPosition2[DocumentPosition2["DISCONNECTED"] = 1] = "DISCONNECTED";
|
|
DocumentPosition2[DocumentPosition2["PRECEDING"] = 2] = "PRECEDING";
|
|
DocumentPosition2[DocumentPosition2["FOLLOWING"] = 4] = "FOLLOWING";
|
|
DocumentPosition2[DocumentPosition2["CONTAINS"] = 8] = "CONTAINS";
|
|
DocumentPosition2[DocumentPosition2["CONTAINED_BY"] = 16] = "CONTAINED_BY";
|
|
})(DocumentPosition = exports.DocumentPosition || (exports.DocumentPosition = {}));
|
|
function compareDocumentPosition(nodeA, nodeB) {
|
|
var aParents = [];
|
|
var bParents = [];
|
|
if (nodeA === nodeB) {
|
|
return 0;
|
|
}
|
|
var current = (0, domhandler_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
|
|
while (current) {
|
|
aParents.unshift(current);
|
|
current = current.parent;
|
|
}
|
|
current = (0, domhandler_1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
|
|
while (current) {
|
|
bParents.unshift(current);
|
|
current = current.parent;
|
|
}
|
|
var maxIdx = Math.min(aParents.length, bParents.length);
|
|
var idx = 0;
|
|
while (idx < maxIdx && aParents[idx] === bParents[idx]) {
|
|
idx++;
|
|
}
|
|
if (idx === 0) {
|
|
return DocumentPosition.DISCONNECTED;
|
|
}
|
|
var sharedParent = aParents[idx - 1];
|
|
var siblings = sharedParent.children;
|
|
var aSibling = aParents[idx];
|
|
var bSibling = bParents[idx];
|
|
if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
|
|
if (sharedParent === nodeB) {
|
|
return DocumentPosition.FOLLOWING | DocumentPosition.CONTAINED_BY;
|
|
}
|
|
return DocumentPosition.FOLLOWING;
|
|
}
|
|
if (sharedParent === nodeA) {
|
|
return DocumentPosition.PRECEDING | DocumentPosition.CONTAINS;
|
|
}
|
|
return DocumentPosition.PRECEDING;
|
|
}
|
|
exports.compareDocumentPosition = compareDocumentPosition;
|
|
function uniqueSort(nodes) {
|
|
nodes = nodes.filter(function(node, i, arr) {
|
|
return !arr.includes(node, i + 1);
|
|
});
|
|
nodes.sort(function(a, b) {
|
|
var relative = compareDocumentPosition(a, b);
|
|
if (relative & DocumentPosition.PRECEDING) {
|
|
return -1;
|
|
} else if (relative & DocumentPosition.FOLLOWING) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
});
|
|
return nodes;
|
|
}
|
|
exports.uniqueSort = uniqueSort;
|
|
});
|
|
|
|
// node_modules/domutils/lib/feeds.js
|
|
var require_feeds = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getFeed = undefined;
|
|
var stringify_js_1 = require_stringify();
|
|
var legacy_js_1 = require_legacy();
|
|
function getFeed(doc) {
|
|
var feedRoot = getOneElement(isValidFeed, doc);
|
|
return !feedRoot ? null : feedRoot.name === "feed" ? getAtomFeed(feedRoot) : getRssFeed(feedRoot);
|
|
}
|
|
exports.getFeed = getFeed;
|
|
function getAtomFeed(feedRoot) {
|
|
var _a;
|
|
var childs = feedRoot.children;
|
|
var feed = {
|
|
type: "atom",
|
|
items: (0, legacy_js_1.getElementsByTagName)("entry", childs).map(function(item) {
|
|
var _a2;
|
|
var children = item.children;
|
|
var entry = { media: getMediaElements(children) };
|
|
addConditionally(entry, "id", "id", children);
|
|
addConditionally(entry, "title", "title", children);
|
|
var href2 = (_a2 = getOneElement("link", children)) === null || _a2 === undefined ? undefined : _a2.attribs["href"];
|
|
if (href2) {
|
|
entry.link = href2;
|
|
}
|
|
var description = fetch2("summary", children) || fetch2("content", children);
|
|
if (description) {
|
|
entry.description = description;
|
|
}
|
|
var pubDate = fetch2("updated", children);
|
|
if (pubDate) {
|
|
entry.pubDate = new Date(pubDate);
|
|
}
|
|
return entry;
|
|
})
|
|
};
|
|
addConditionally(feed, "id", "id", childs);
|
|
addConditionally(feed, "title", "title", childs);
|
|
var href = (_a = getOneElement("link", childs)) === null || _a === undefined ? undefined : _a.attribs["href"];
|
|
if (href) {
|
|
feed.link = href;
|
|
}
|
|
addConditionally(feed, "description", "subtitle", childs);
|
|
var updated = fetch2("updated", childs);
|
|
if (updated) {
|
|
feed.updated = new Date(updated);
|
|
}
|
|
addConditionally(feed, "author", "email", childs, true);
|
|
return feed;
|
|
}
|
|
function getRssFeed(feedRoot) {
|
|
var _a, _b;
|
|
var childs = (_b = (_a = getOneElement("channel", feedRoot.children)) === null || _a === undefined ? undefined : _a.children) !== null && _b !== undefined ? _b : [];
|
|
var feed = {
|
|
type: feedRoot.name.substr(0, 3),
|
|
id: "",
|
|
items: (0, legacy_js_1.getElementsByTagName)("item", feedRoot.children).map(function(item) {
|
|
var children = item.children;
|
|
var entry = { media: getMediaElements(children) };
|
|
addConditionally(entry, "id", "guid", children);
|
|
addConditionally(entry, "title", "title", children);
|
|
addConditionally(entry, "link", "link", children);
|
|
addConditionally(entry, "description", "description", children);
|
|
var pubDate = fetch2("pubDate", children) || fetch2("dc:date", children);
|
|
if (pubDate)
|
|
entry.pubDate = new Date(pubDate);
|
|
return entry;
|
|
})
|
|
};
|
|
addConditionally(feed, "title", "title", childs);
|
|
addConditionally(feed, "link", "link", childs);
|
|
addConditionally(feed, "description", "description", childs);
|
|
var updated = fetch2("lastBuildDate", childs);
|
|
if (updated) {
|
|
feed.updated = new Date(updated);
|
|
}
|
|
addConditionally(feed, "author", "managingEditor", childs, true);
|
|
return feed;
|
|
}
|
|
var MEDIA_KEYS_STRING = ["url", "type", "lang"];
|
|
var MEDIA_KEYS_INT = [
|
|
"fileSize",
|
|
"bitrate",
|
|
"framerate",
|
|
"samplingrate",
|
|
"channels",
|
|
"duration",
|
|
"height",
|
|
"width"
|
|
];
|
|
function getMediaElements(where) {
|
|
return (0, legacy_js_1.getElementsByTagName)("media:content", where).map(function(elem) {
|
|
var attribs = elem.attribs;
|
|
var media = {
|
|
medium: attribs["medium"],
|
|
isDefault: !!attribs["isDefault"]
|
|
};
|
|
for (var _i = 0, MEDIA_KEYS_STRING_1 = MEDIA_KEYS_STRING;_i < MEDIA_KEYS_STRING_1.length; _i++) {
|
|
var attrib = MEDIA_KEYS_STRING_1[_i];
|
|
if (attribs[attrib]) {
|
|
media[attrib] = attribs[attrib];
|
|
}
|
|
}
|
|
for (var _a = 0, MEDIA_KEYS_INT_1 = MEDIA_KEYS_INT;_a < MEDIA_KEYS_INT_1.length; _a++) {
|
|
var attrib = MEDIA_KEYS_INT_1[_a];
|
|
if (attribs[attrib]) {
|
|
media[attrib] = parseInt(attribs[attrib], 10);
|
|
}
|
|
}
|
|
if (attribs["expression"]) {
|
|
media.expression = attribs["expression"];
|
|
}
|
|
return media;
|
|
});
|
|
}
|
|
function getOneElement(tagName, node) {
|
|
return (0, legacy_js_1.getElementsByTagName)(tagName, node, true, 1)[0];
|
|
}
|
|
function fetch2(tagName, where, recurse) {
|
|
if (recurse === undefined) {
|
|
recurse = false;
|
|
}
|
|
return (0, stringify_js_1.textContent)((0, legacy_js_1.getElementsByTagName)(tagName, where, recurse, 1)).trim();
|
|
}
|
|
function addConditionally(obj, prop, tagName, where, recurse) {
|
|
if (recurse === undefined) {
|
|
recurse = false;
|
|
}
|
|
var val = fetch2(tagName, where, recurse);
|
|
if (val)
|
|
obj[prop] = val;
|
|
}
|
|
function isValidFeed(value) {
|
|
return value === "rss" || value === "feed" || value === "rdf:RDF";
|
|
}
|
|
});
|
|
|
|
// node_modules/domutils/lib/index.js
|
|
var require_lib5 = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
|
|
for (var p in m)
|
|
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
|
|
__createBinding(exports2, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = undefined;
|
|
__exportStar(require_stringify(), exports);
|
|
__exportStar(require_traversal(), exports);
|
|
__exportStar(require_manipulation(), exports);
|
|
__exportStar(require_querying(), exports);
|
|
__exportStar(require_legacy(), exports);
|
|
__exportStar(require_helpers(), exports);
|
|
__exportStar(require_feeds(), exports);
|
|
var domhandler_1 = require_lib2();
|
|
Object.defineProperty(exports, "isTag", { enumerable: true, get: function() {
|
|
return domhandler_1.isTag;
|
|
} });
|
|
Object.defineProperty(exports, "isCDATA", { enumerable: true, get: function() {
|
|
return domhandler_1.isCDATA;
|
|
} });
|
|
Object.defineProperty(exports, "isText", { enumerable: true, get: function() {
|
|
return domhandler_1.isText;
|
|
} });
|
|
Object.defineProperty(exports, "isComment", { enumerable: true, get: function() {
|
|
return domhandler_1.isComment;
|
|
} });
|
|
Object.defineProperty(exports, "isDocument", { enumerable: true, get: function() {
|
|
return domhandler_1.isDocument;
|
|
} });
|
|
Object.defineProperty(exports, "hasChildren", { enumerable: true, get: function() {
|
|
return domhandler_1.hasChildren;
|
|
} });
|
|
});
|
|
|
|
// node_modules/htmlparser2/lib/index.js
|
|
var require_lib6 = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === undefined)
|
|
k2 = k;
|
|
o[k2] = m[k];
|
|
});
|
|
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__importStar || function(mod) {
|
|
if (mod && mod.__esModule)
|
|
return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod)
|
|
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
|
|
__createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DomUtils = exports.parseFeed = exports.getFeed = exports.ElementType = exports.Tokenizer = exports.createDomStream = exports.parseDOM = exports.parseDocument = exports.DefaultHandler = exports.DomHandler = exports.Parser = undefined;
|
|
var Parser_js_1 = require_Parser2();
|
|
var Parser_js_2 = require_Parser2();
|
|
Object.defineProperty(exports, "Parser", { enumerable: true, get: function() {
|
|
return Parser_js_2.Parser;
|
|
} });
|
|
var domhandler_1 = require_lib2();
|
|
var domhandler_2 = require_lib2();
|
|
Object.defineProperty(exports, "DomHandler", { enumerable: true, get: function() {
|
|
return domhandler_2.DomHandler;
|
|
} });
|
|
Object.defineProperty(exports, "DefaultHandler", { enumerable: true, get: function() {
|
|
return domhandler_2.DomHandler;
|
|
} });
|
|
function parseDocument(data, options) {
|
|
var handler = new domhandler_1.DomHandler(undefined, options);
|
|
new Parser_js_1.Parser(handler, options).end(data);
|
|
return handler.root;
|
|
}
|
|
exports.parseDocument = parseDocument;
|
|
function parseDOM(data, options) {
|
|
return parseDocument(data, options).children;
|
|
}
|
|
exports.parseDOM = parseDOM;
|
|
function createDomStream(callback, options, elementCallback) {
|
|
var handler = new domhandler_1.DomHandler(callback, options, elementCallback);
|
|
return new Parser_js_1.Parser(handler, options);
|
|
}
|
|
exports.createDomStream = createDomStream;
|
|
var Tokenizer_js_1 = require_Tokenizer();
|
|
Object.defineProperty(exports, "Tokenizer", { enumerable: true, get: function() {
|
|
return __importDefault(Tokenizer_js_1).default;
|
|
} });
|
|
exports.ElementType = __importStar(require_lib());
|
|
var domutils_1 = require_lib5();
|
|
var domutils_2 = require_lib5();
|
|
Object.defineProperty(exports, "getFeed", { enumerable: true, get: function() {
|
|
return domutils_2.getFeed;
|
|
} });
|
|
var parseFeedDefaultOptions = { xmlMode: true };
|
|
function parseFeed(feed, options) {
|
|
if (options === undefined) {
|
|
options = parseFeedDefaultOptions;
|
|
}
|
|
return (0, domutils_1.getFeed)(parseDOM(feed, options));
|
|
}
|
|
exports.parseFeed = parseFeed;
|
|
exports.DomUtils = __importStar(require_lib5());
|
|
});
|
|
|
|
// node_modules/escape-string-regexp/index.js
|
|
var require_escape_string_regexp = __commonJS((exports, module) => {
|
|
module.exports = (string) => {
|
|
if (typeof string !== "string") {
|
|
throw new TypeError("Expected a string");
|
|
}
|
|
return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
|
|
};
|
|
});
|
|
|
|
// node_modules/is-plain-object/dist/is-plain-object.js
|
|
var require_is_plain_object = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
/*!
|
|
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
|
|
*
|
|
* Copyright (c) 2014-2017, Jon Schlinkert.
|
|
* Released under the MIT License.
|
|
*/
|
|
function isObject(o) {
|
|
return Object.prototype.toString.call(o) === "[object Object]";
|
|
}
|
|
function isPlainObject(o) {
|
|
var ctor, prot;
|
|
if (isObject(o) === false)
|
|
return false;
|
|
ctor = o.constructor;
|
|
if (ctor === undefined)
|
|
return true;
|
|
prot = ctor.prototype;
|
|
if (isObject(prot) === false)
|
|
return false;
|
|
if (prot.hasOwnProperty("isPrototypeOf") === false) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
exports.isPlainObject = isPlainObject;
|
|
});
|
|
|
|
// node_modules/deepmerge/dist/cjs.js
|
|
var require_cjs = __commonJS((exports, module) => {
|
|
var isMergeableObject = function isMergeableObject(value) {
|
|
return isNonNullObject(value) && !isSpecial(value);
|
|
};
|
|
function isNonNullObject(value) {
|
|
return !!value && typeof value === "object";
|
|
}
|
|
function isSpecial(value) {
|
|
var stringValue = Object.prototype.toString.call(value);
|
|
return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
|
|
}
|
|
var canUseSymbol = typeof Symbol === "function" && Symbol.for;
|
|
var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
|
|
function isReactElement(value) {
|
|
return value.$$typeof === REACT_ELEMENT_TYPE;
|
|
}
|
|
function emptyTarget(val) {
|
|
return Array.isArray(val) ? [] : {};
|
|
}
|
|
function cloneUnlessOtherwiseSpecified(value, options) {
|
|
return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
|
|
}
|
|
function defaultArrayMerge(target, source, options) {
|
|
return target.concat(source).map(function(element) {
|
|
return cloneUnlessOtherwiseSpecified(element, options);
|
|
});
|
|
}
|
|
function getMergeFunction(key, options) {
|
|
if (!options.customMerge) {
|
|
return deepmerge;
|
|
}
|
|
var customMerge = options.customMerge(key);
|
|
return typeof customMerge === "function" ? customMerge : deepmerge;
|
|
}
|
|
function getEnumerableOwnPropertySymbols(target) {
|
|
return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
|
|
return Object.propertyIsEnumerable.call(target, symbol);
|
|
}) : [];
|
|
}
|
|
function getKeys(target) {
|
|
return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
|
|
}
|
|
function propertyIsOnObject(object, property) {
|
|
try {
|
|
return property in object;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
}
|
|
function propertyIsUnsafe(target, key) {
|
|
return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
|
|
}
|
|
function mergeObject(target, source, options) {
|
|
var destination = {};
|
|
if (options.isMergeableObject(target)) {
|
|
getKeys(target).forEach(function(key) {
|
|
destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
|
|
});
|
|
}
|
|
getKeys(source).forEach(function(key) {
|
|
if (propertyIsUnsafe(target, key)) {
|
|
return;
|
|
}
|
|
if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
|
|
destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
|
|
} else {
|
|
destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
|
|
}
|
|
});
|
|
return destination;
|
|
}
|
|
function deepmerge(target, source, options) {
|
|
options = options || {};
|
|
options.arrayMerge = options.arrayMerge || defaultArrayMerge;
|
|
options.isMergeableObject = options.isMergeableObject || isMergeableObject;
|
|
options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
|
|
var sourceIsArray = Array.isArray(source);
|
|
var targetIsArray = Array.isArray(target);
|
|
var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
|
|
if (!sourceAndTargetTypesMatch) {
|
|
return cloneUnlessOtherwiseSpecified(source, options);
|
|
} else if (sourceIsArray) {
|
|
return options.arrayMerge(target, source, options);
|
|
} else {
|
|
return mergeObject(target, source, options);
|
|
}
|
|
}
|
|
deepmerge.all = function deepmergeAll(array, options) {
|
|
if (!Array.isArray(array)) {
|
|
throw new Error("first argument should be an array");
|
|
}
|
|
return array.reduce(function(prev, next) {
|
|
return deepmerge(prev, next, options);
|
|
}, {});
|
|
};
|
|
var deepmerge_1 = deepmerge;
|
|
module.exports = deepmerge_1;
|
|
});
|
|
|
|
// node_modules/parse-srcset/src/parse-srcset.js
|
|
var require_parse_srcset = __commonJS((exports, module) => {
|
|
(function(root, factory) {
|
|
if (typeof define === "function" && define.amd) {
|
|
define([], factory);
|
|
} else if (typeof module === "object" && module.exports) {
|
|
module.exports = factory();
|
|
} else {
|
|
root.parseSrcset = factory();
|
|
}
|
|
})(exports, function() {
|
|
return function(input) {
|
|
function isSpace(c2) {
|
|
return c2 === " " || c2 === "\t" || c2 === `
|
|
` || c2 === "\f" || c2 === `\r`;
|
|
}
|
|
function collectCharacters(regEx) {
|
|
var chars, match = regEx.exec(input.substring(pos));
|
|
if (match) {
|
|
chars = match[0];
|
|
pos += chars.length;
|
|
return chars;
|
|
}
|
|
}
|
|
var inputLength = input.length, regexLeadingSpaces = /^[ \t\n\r\u000c]+/, regexLeadingCommasOrSpaces = /^[, \t\n\r\u000c]+/, regexLeadingNotSpaces = /^[^ \t\n\r\u000c]+/, regexTrailingCommas = /[,]+$/, regexNonNegativeInteger = /^\d+$/, regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/, url, descriptors, currentDescriptor, state, c, pos = 0, candidates = [];
|
|
while (true) {
|
|
collectCharacters(regexLeadingCommasOrSpaces);
|
|
if (pos >= inputLength) {
|
|
return candidates;
|
|
}
|
|
url = collectCharacters(regexLeadingNotSpaces);
|
|
descriptors = [];
|
|
if (url.slice(-1) === ",") {
|
|
url = url.replace(regexTrailingCommas, "");
|
|
parseDescriptors();
|
|
} else {
|
|
tokenize();
|
|
}
|
|
}
|
|
function tokenize() {
|
|
collectCharacters(regexLeadingSpaces);
|
|
currentDescriptor = "";
|
|
state = "in descriptor";
|
|
while (true) {
|
|
c = input.charAt(pos);
|
|
if (state === "in descriptor") {
|
|
if (isSpace(c)) {
|
|
if (currentDescriptor) {
|
|
descriptors.push(currentDescriptor);
|
|
currentDescriptor = "";
|
|
state = "after descriptor";
|
|
}
|
|
} else if (c === ",") {
|
|
pos += 1;
|
|
if (currentDescriptor) {
|
|
descriptors.push(currentDescriptor);
|
|
}
|
|
parseDescriptors();
|
|
return;
|
|
} else if (c === "(") {
|
|
currentDescriptor = currentDescriptor + c;
|
|
state = "in parens";
|
|
} else if (c === "") {
|
|
if (currentDescriptor) {
|
|
descriptors.push(currentDescriptor);
|
|
}
|
|
parseDescriptors();
|
|
return;
|
|
} else {
|
|
currentDescriptor = currentDescriptor + c;
|
|
}
|
|
} else if (state === "in parens") {
|
|
if (c === ")") {
|
|
currentDescriptor = currentDescriptor + c;
|
|
state = "in descriptor";
|
|
} else if (c === "") {
|
|
descriptors.push(currentDescriptor);
|
|
parseDescriptors();
|
|
return;
|
|
} else {
|
|
currentDescriptor = currentDescriptor + c;
|
|
}
|
|
} else if (state === "after descriptor") {
|
|
if (isSpace(c)) {
|
|
} else if (c === "") {
|
|
parseDescriptors();
|
|
return;
|
|
} else {
|
|
state = "in descriptor";
|
|
pos -= 1;
|
|
}
|
|
}
|
|
pos += 1;
|
|
}
|
|
}
|
|
function parseDescriptors() {
|
|
var pError = false, w, d, h, i, candidate = {}, desc, lastChar, value, intVal, floatVal;
|
|
for (i = 0;i < descriptors.length; i++) {
|
|
desc = descriptors[i];
|
|
lastChar = desc[desc.length - 1];
|
|
value = desc.substring(0, desc.length - 1);
|
|
intVal = parseInt(value, 10);
|
|
floatVal = parseFloat(value);
|
|
if (regexNonNegativeInteger.test(value) && lastChar === "w") {
|
|
if (w || d) {
|
|
pError = true;
|
|
}
|
|
if (intVal === 0) {
|
|
pError = true;
|
|
} else {
|
|
w = intVal;
|
|
}
|
|
} else if (regexFloatingPoint.test(value) && lastChar === "x") {
|
|
if (w || d || h) {
|
|
pError = true;
|
|
}
|
|
if (floatVal < 0) {
|
|
pError = true;
|
|
} else {
|
|
d = floatVal;
|
|
}
|
|
} else if (regexNonNegativeInteger.test(value) && lastChar === "h") {
|
|
if (h || d) {
|
|
pError = true;
|
|
}
|
|
if (intVal === 0) {
|
|
pError = true;
|
|
} else {
|
|
h = intVal;
|
|
}
|
|
} else {
|
|
pError = true;
|
|
}
|
|
}
|
|
if (!pError) {
|
|
candidate.url = url;
|
|
if (w) {
|
|
candidate.w = w;
|
|
}
|
|
if (d) {
|
|
candidate.d = d;
|
|
}
|
|
if (h) {
|
|
candidate.h = h;
|
|
}
|
|
candidates.push(candidate);
|
|
} else if (console && console.log) {
|
|
console.log("Invalid srcset descriptor found in '" + input + "' at '" + desc + "'.");
|
|
}
|
|
}
|
|
};
|
|
});
|
|
});
|
|
|
|
// node_modules/picocolors/picocolors.js
|
|
var require_picocolors = __commonJS((exports, module) => {
|
|
var p = process || {};
|
|
var argv = p.argv || [];
|
|
var env = p.env || {};
|
|
var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
|
|
var formatter = (open, close, replace = open) => (input) => {
|
|
let string = "" + input, index = string.indexOf(close, open.length);
|
|
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
|
|
};
|
|
var replaceClose = (string, close, replace, index) => {
|
|
let result = "", cursor = 0;
|
|
do {
|
|
result += string.substring(cursor, index) + replace;
|
|
cursor = index + close.length;
|
|
index = string.indexOf(close, cursor);
|
|
} while (~index);
|
|
return result + string.substring(cursor);
|
|
};
|
|
var createColors = (enabled = isColorSupported) => {
|
|
let f = enabled ? formatter : () => String;
|
|
return {
|
|
isColorSupported: enabled,
|
|
reset: f("\x1B[0m", "\x1B[0m"),
|
|
bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
|
|
dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
|
|
italic: f("\x1B[3m", "\x1B[23m"),
|
|
underline: f("\x1B[4m", "\x1B[24m"),
|
|
inverse: f("\x1B[7m", "\x1B[27m"),
|
|
hidden: f("\x1B[8m", "\x1B[28m"),
|
|
strikethrough: f("\x1B[9m", "\x1B[29m"),
|
|
black: f("\x1B[30m", "\x1B[39m"),
|
|
red: f("\x1B[31m", "\x1B[39m"),
|
|
green: f("\x1B[32m", "\x1B[39m"),
|
|
yellow: f("\x1B[33m", "\x1B[39m"),
|
|
blue: f("\x1B[34m", "\x1B[39m"),
|
|
magenta: f("\x1B[35m", "\x1B[39m"),
|
|
cyan: f("\x1B[36m", "\x1B[39m"),
|
|
white: f("\x1B[37m", "\x1B[39m"),
|
|
gray: f("\x1B[90m", "\x1B[39m"),
|
|
bgBlack: f("\x1B[40m", "\x1B[49m"),
|
|
bgRed: f("\x1B[41m", "\x1B[49m"),
|
|
bgGreen: f("\x1B[42m", "\x1B[49m"),
|
|
bgYellow: f("\x1B[43m", "\x1B[49m"),
|
|
bgBlue: f("\x1B[44m", "\x1B[49m"),
|
|
bgMagenta: f("\x1B[45m", "\x1B[49m"),
|
|
bgCyan: f("\x1B[46m", "\x1B[49m"),
|
|
bgWhite: f("\x1B[47m", "\x1B[49m"),
|
|
blackBright: f("\x1B[90m", "\x1B[39m"),
|
|
redBright: f("\x1B[91m", "\x1B[39m"),
|
|
greenBright: f("\x1B[92m", "\x1B[39m"),
|
|
yellowBright: f("\x1B[93m", "\x1B[39m"),
|
|
blueBright: f("\x1B[94m", "\x1B[39m"),
|
|
magentaBright: f("\x1B[95m", "\x1B[39m"),
|
|
cyanBright: f("\x1B[96m", "\x1B[39m"),
|
|
whiteBright: f("\x1B[97m", "\x1B[39m"),
|
|
bgBlackBright: f("\x1B[100m", "\x1B[49m"),
|
|
bgRedBright: f("\x1B[101m", "\x1B[49m"),
|
|
bgGreenBright: f("\x1B[102m", "\x1B[49m"),
|
|
bgYellowBright: f("\x1B[103m", "\x1B[49m"),
|
|
bgBlueBright: f("\x1B[104m", "\x1B[49m"),
|
|
bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
|
|
bgCyanBright: f("\x1B[106m", "\x1B[49m"),
|
|
bgWhiteBright: f("\x1B[107m", "\x1B[49m")
|
|
};
|
|
};
|
|
module.exports = createColors();
|
|
module.exports.createColors = createColors;
|
|
});
|
|
|
|
// node_modules/postcss/lib/tokenize.js
|
|
var require_tokenize = __commonJS((exports, module) => {
|
|
var SINGLE_QUOTE = "'".charCodeAt(0);
|
|
var DOUBLE_QUOTE = '"'.charCodeAt(0);
|
|
var BACKSLASH = "\\".charCodeAt(0);
|
|
var SLASH = "/".charCodeAt(0);
|
|
var NEWLINE = "\n".charCodeAt(0);
|
|
var SPACE = " ".charCodeAt(0);
|
|
var FEED = "\f".charCodeAt(0);
|
|
var TAB = "\t".charCodeAt(0);
|
|
var CR = "\r".charCodeAt(0);
|
|
var OPEN_SQUARE = "[".charCodeAt(0);
|
|
var CLOSE_SQUARE = "]".charCodeAt(0);
|
|
var OPEN_PARENTHESES = "(".charCodeAt(0);
|
|
var CLOSE_PARENTHESES = ")".charCodeAt(0);
|
|
var OPEN_CURLY = "{".charCodeAt(0);
|
|
var CLOSE_CURLY = "}".charCodeAt(0);
|
|
var SEMICOLON = ";".charCodeAt(0);
|
|
var ASTERISK = "*".charCodeAt(0);
|
|
var COLON = ":".charCodeAt(0);
|
|
var AT = "@".charCodeAt(0);
|
|
var RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
|
|
var RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
|
|
var RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
|
|
var RE_HEX_ESCAPE = /[\da-f]/i;
|
|
module.exports = function tokenizer(input, options = {}) {
|
|
let css = input.css.valueOf();
|
|
let ignore = options.ignoreErrors;
|
|
let code, content, escape, next, quote;
|
|
let currentToken, escaped, escapePos, n, prev;
|
|
let length = css.length;
|
|
let pos = 0;
|
|
let buffer = [];
|
|
let returned = [];
|
|
function position() {
|
|
return pos;
|
|
}
|
|
function unclosed(what) {
|
|
throw input.error("Unclosed " + what, pos);
|
|
}
|
|
function endOfFile() {
|
|
return returned.length === 0 && pos >= length;
|
|
}
|
|
function nextToken(opts) {
|
|
if (returned.length)
|
|
return returned.pop();
|
|
if (pos >= length)
|
|
return;
|
|
let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
|
|
code = css.charCodeAt(pos);
|
|
switch (code) {
|
|
case NEWLINE:
|
|
case SPACE:
|
|
case TAB:
|
|
case CR:
|
|
case FEED: {
|
|
next = pos;
|
|
do {
|
|
next += 1;
|
|
code = css.charCodeAt(next);
|
|
} while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
|
|
currentToken = ["space", css.slice(pos, next)];
|
|
pos = next - 1;
|
|
break;
|
|
}
|
|
case OPEN_SQUARE:
|
|
case CLOSE_SQUARE:
|
|
case OPEN_CURLY:
|
|
case CLOSE_CURLY:
|
|
case COLON:
|
|
case SEMICOLON:
|
|
case CLOSE_PARENTHESES: {
|
|
let controlChar = String.fromCharCode(code);
|
|
currentToken = [controlChar, controlChar, pos];
|
|
break;
|
|
}
|
|
case OPEN_PARENTHESES: {
|
|
prev = buffer.length ? buffer.pop()[1] : "";
|
|
n = css.charCodeAt(pos + 1);
|
|
if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
|
|
next = pos;
|
|
do {
|
|
escaped = false;
|
|
next = css.indexOf(")", next + 1);
|
|
if (next === -1) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = pos;
|
|
break;
|
|
} else {
|
|
unclosed("bracket");
|
|
}
|
|
}
|
|
escapePos = next;
|
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
|
escapePos -= 1;
|
|
escaped = !escaped;
|
|
}
|
|
} while (escaped);
|
|
currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
} else {
|
|
next = css.indexOf(")", pos + 1);
|
|
content = css.slice(pos, next + 1);
|
|
if (next === -1 || RE_BAD_BRACKET.test(content)) {
|
|
currentToken = ["(", "(", pos];
|
|
} else {
|
|
currentToken = ["brackets", content, pos, next];
|
|
pos = next;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case SINGLE_QUOTE:
|
|
case DOUBLE_QUOTE: {
|
|
quote = code === SINGLE_QUOTE ? "'" : '"';
|
|
next = pos;
|
|
do {
|
|
escaped = false;
|
|
next = css.indexOf(quote, next + 1);
|
|
if (next === -1) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = pos + 1;
|
|
break;
|
|
} else {
|
|
unclosed("string");
|
|
}
|
|
}
|
|
escapePos = next;
|
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
|
escapePos -= 1;
|
|
escaped = !escaped;
|
|
}
|
|
} while (escaped);
|
|
currentToken = ["string", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
case AT: {
|
|
RE_AT_END.lastIndex = pos + 1;
|
|
RE_AT_END.test(css);
|
|
if (RE_AT_END.lastIndex === 0) {
|
|
next = css.length - 1;
|
|
} else {
|
|
next = RE_AT_END.lastIndex - 2;
|
|
}
|
|
currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
case BACKSLASH: {
|
|
next = pos;
|
|
escape = true;
|
|
while (css.charCodeAt(next + 1) === BACKSLASH) {
|
|
next += 1;
|
|
escape = !escape;
|
|
}
|
|
code = css.charCodeAt(next + 1);
|
|
if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
|
|
next += 1;
|
|
if (RE_HEX_ESCAPE.test(css.charAt(next))) {
|
|
while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
|
|
next += 1;
|
|
}
|
|
if (css.charCodeAt(next + 1) === SPACE) {
|
|
next += 1;
|
|
}
|
|
}
|
|
}
|
|
currentToken = ["word", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
default: {
|
|
if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
|
|
next = css.indexOf("*/", pos + 2) + 1;
|
|
if (next === 0) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = css.length;
|
|
} else {
|
|
unclosed("comment");
|
|
}
|
|
}
|
|
currentToken = ["comment", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
} else {
|
|
RE_WORD_END.lastIndex = pos + 1;
|
|
RE_WORD_END.test(css);
|
|
if (RE_WORD_END.lastIndex === 0) {
|
|
next = css.length - 1;
|
|
} else {
|
|
next = RE_WORD_END.lastIndex - 2;
|
|
}
|
|
currentToken = ["word", css.slice(pos, next + 1), pos, next];
|
|
buffer.push(currentToken);
|
|
pos = next;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
pos++;
|
|
return currentToken;
|
|
}
|
|
function back(token) {
|
|
returned.push(token);
|
|
}
|
|
return {
|
|
back,
|
|
endOfFile,
|
|
nextToken,
|
|
position
|
|
};
|
|
};
|
|
});
|
|
|
|
// node_modules/postcss/lib/terminal-highlight.js
|
|
var require_terminal_highlight = __commonJS((exports, module) => {
|
|
var pico = require_picocolors();
|
|
var tokenizer = require_tokenize();
|
|
var Input;
|
|
function registerInput(dependant) {
|
|
Input = dependant;
|
|
}
|
|
var HIGHLIGHT_THEME = {
|
|
";": pico.yellow,
|
|
":": pico.yellow,
|
|
"(": pico.cyan,
|
|
")": pico.cyan,
|
|
"[": pico.yellow,
|
|
"]": pico.yellow,
|
|
"{": pico.yellow,
|
|
"}": pico.yellow,
|
|
"at-word": pico.cyan,
|
|
brackets: pico.cyan,
|
|
call: pico.cyan,
|
|
class: pico.yellow,
|
|
comment: pico.gray,
|
|
hash: pico.magenta,
|
|
string: pico.green
|
|
};
|
|
function getTokenType([type, value], processor) {
|
|
if (type === "word") {
|
|
if (value[0] === ".") {
|
|
return "class";
|
|
}
|
|
if (value[0] === "#") {
|
|
return "hash";
|
|
}
|
|
}
|
|
if (!processor.endOfFile()) {
|
|
let next = processor.nextToken();
|
|
processor.back(next);
|
|
if (next[0] === "brackets" || next[0] === "(")
|
|
return "call";
|
|
}
|
|
return type;
|
|
}
|
|
function terminalHighlight(css) {
|
|
let processor = tokenizer(new Input(css), { ignoreErrors: true });
|
|
let result = "";
|
|
while (!processor.endOfFile()) {
|
|
let token = processor.nextToken();
|
|
let color = HIGHLIGHT_THEME[getTokenType(token, processor)];
|
|
if (color) {
|
|
result += token[1].split(/\r?\n/).map((i) => color(i)).join("\n");
|
|
} else {
|
|
result += token[1];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
terminalHighlight.registerInput = registerInput;
|
|
module.exports = terminalHighlight;
|
|
});
|
|
|
|
// node_modules/postcss/lib/css-syntax-error.js
|
|
var require_css_syntax_error = __commonJS((exports, module) => {
|
|
var pico = require_picocolors();
|
|
var terminalHighlight = require_terminal_highlight();
|
|
|
|
class CssSyntaxError extends Error {
|
|
constructor(message, line, column, source, file, plugin) {
|
|
super(message);
|
|
this.name = "CssSyntaxError";
|
|
this.reason = message;
|
|
if (file) {
|
|
this.file = file;
|
|
}
|
|
if (source) {
|
|
this.source = source;
|
|
}
|
|
if (plugin) {
|
|
this.plugin = plugin;
|
|
}
|
|
if (typeof line !== "undefined" && typeof column !== "undefined") {
|
|
if (typeof line === "number") {
|
|
this.line = line;
|
|
this.column = column;
|
|
} else {
|
|
this.line = line.line;
|
|
this.column = line.column;
|
|
this.endLine = column.line;
|
|
this.endColumn = column.column;
|
|
}
|
|
}
|
|
this.setMessage();
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, CssSyntaxError);
|
|
}
|
|
}
|
|
setMessage() {
|
|
this.message = this.plugin ? this.plugin + ": " : "";
|
|
this.message += this.file ? this.file : "<css input>";
|
|
if (typeof this.line !== "undefined") {
|
|
this.message += ":" + this.line + ":" + this.column;
|
|
}
|
|
this.message += ": " + this.reason;
|
|
}
|
|
showSourceCode(color) {
|
|
if (!this.source)
|
|
return "";
|
|
let css = this.source;
|
|
if (color == null)
|
|
color = pico.isColorSupported;
|
|
let aside = (text) => text;
|
|
let mark = (text) => text;
|
|
let highlight = (text) => text;
|
|
if (color) {
|
|
let { bold, gray, red } = pico.createColors(true);
|
|
mark = (text) => bold(red(text));
|
|
aside = (text) => gray(text);
|
|
if (terminalHighlight) {
|
|
highlight = (text) => terminalHighlight(text);
|
|
}
|
|
}
|
|
let lines = css.split(/\r?\n/);
|
|
let start = Math.max(this.line - 3, 0);
|
|
let end = Math.min(this.line + 2, lines.length);
|
|
let maxWidth = String(end).length;
|
|
return lines.slice(start, end).map((line, index) => {
|
|
let number = start + 1 + index;
|
|
let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
|
|
if (number === this.line) {
|
|
if (line.length > 160) {
|
|
let padding = 20;
|
|
let subLineStart = Math.max(0, this.column - padding);
|
|
let subLineEnd = Math.max(this.column + padding, this.endColumn + padding);
|
|
let subLine = line.slice(subLineStart, subLineEnd);
|
|
let spacing2 = aside(gutter.replace(/\d/g, " ")) + line.slice(0, Math.min(this.column - 1, padding - 1)).replace(/[^\t]/g, " ");
|
|
return mark(">") + aside(gutter) + highlight(subLine) + "\n " + spacing2 + mark("^");
|
|
}
|
|
let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
|
|
return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
|
|
}
|
|
return " " + aside(gutter) + highlight(line);
|
|
}).join("\n");
|
|
}
|
|
toString() {
|
|
let code = this.showSourceCode();
|
|
if (code) {
|
|
code = "\n\n" + code + "\n";
|
|
}
|
|
return this.name + ": " + this.message + code;
|
|
}
|
|
}
|
|
module.exports = CssSyntaxError;
|
|
CssSyntaxError.default = CssSyntaxError;
|
|
});
|
|
|
|
// node_modules/postcss/lib/stringifier.js
|
|
var require_stringifier = __commonJS((exports, module) => {
|
|
var DEFAULT_RAW = {
|
|
after: "\n",
|
|
beforeClose: "\n",
|
|
beforeComment: "\n",
|
|
beforeDecl: "\n",
|
|
beforeOpen: " ",
|
|
beforeRule: "\n",
|
|
colon: ": ",
|
|
commentLeft: " ",
|
|
commentRight: " ",
|
|
emptyBody: "",
|
|
indent: " ",
|
|
semicolon: false
|
|
};
|
|
function capitalize(str) {
|
|
return str[0].toUpperCase() + str.slice(1);
|
|
}
|
|
|
|
class Stringifier {
|
|
constructor(builder) {
|
|
this.builder = builder;
|
|
}
|
|
atrule(node, semicolon) {
|
|
let name = "@" + node.name;
|
|
let params = node.params ? this.rawValue(node, "params") : "";
|
|
if (typeof node.raws.afterName !== "undefined") {
|
|
name += node.raws.afterName;
|
|
} else if (params) {
|
|
name += " ";
|
|
}
|
|
if (node.nodes) {
|
|
this.block(node, name + params);
|
|
} else {
|
|
let end = (node.raws.between || "") + (semicolon ? ";" : "");
|
|
this.builder(name + params + end, node);
|
|
}
|
|
}
|
|
beforeAfter(node, detect) {
|
|
let value;
|
|
if (node.type === "decl") {
|
|
value = this.raw(node, null, "beforeDecl");
|
|
} else if (node.type === "comment") {
|
|
value = this.raw(node, null, "beforeComment");
|
|
} else if (detect === "before") {
|
|
value = this.raw(node, null, "beforeRule");
|
|
} else {
|
|
value = this.raw(node, null, "beforeClose");
|
|
}
|
|
let buf = node.parent;
|
|
let depth = 0;
|
|
while (buf && buf.type !== "root") {
|
|
depth += 1;
|
|
buf = buf.parent;
|
|
}
|
|
if (value.includes("\n")) {
|
|
let indent = this.raw(node, null, "indent");
|
|
if (indent.length) {
|
|
for (let step = 0;step < depth; step++)
|
|
value += indent;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
block(node, start) {
|
|
let between = this.raw(node, "between", "beforeOpen");
|
|
this.builder(start + between + "{", node, "start");
|
|
let after;
|
|
if (node.nodes && node.nodes.length) {
|
|
this.body(node);
|
|
after = this.raw(node, "after");
|
|
} else {
|
|
after = this.raw(node, "after", "emptyBody");
|
|
}
|
|
if (after)
|
|
this.builder(after);
|
|
this.builder("}", node, "end");
|
|
}
|
|
body(node) {
|
|
let last = node.nodes.length - 1;
|
|
while (last > 0) {
|
|
if (node.nodes[last].type !== "comment")
|
|
break;
|
|
last -= 1;
|
|
}
|
|
let semicolon = this.raw(node, "semicolon");
|
|
for (let i = 0;i < node.nodes.length; i++) {
|
|
let child = node.nodes[i];
|
|
let before = this.raw(child, "before");
|
|
if (before)
|
|
this.builder(before);
|
|
this.stringify(child, last !== i || semicolon);
|
|
}
|
|
}
|
|
comment(node) {
|
|
let left = this.raw(node, "left", "commentLeft");
|
|
let right = this.raw(node, "right", "commentRight");
|
|
this.builder("/*" + left + node.text + right + "*/", node);
|
|
}
|
|
decl(node, semicolon) {
|
|
let between = this.raw(node, "between", "colon");
|
|
let string = node.prop + between + this.rawValue(node, "value");
|
|
if (node.important) {
|
|
string += node.raws.important || " !important";
|
|
}
|
|
if (semicolon)
|
|
string += ";";
|
|
this.builder(string, node);
|
|
}
|
|
document(node) {
|
|
this.body(node);
|
|
}
|
|
raw(node, own, detect) {
|
|
let value;
|
|
if (!detect)
|
|
detect = own;
|
|
if (own) {
|
|
value = node.raws[own];
|
|
if (typeof value !== "undefined")
|
|
return value;
|
|
}
|
|
let parent = node.parent;
|
|
if (detect === "before") {
|
|
if (!parent || parent.type === "root" && parent.first === node) {
|
|
return "";
|
|
}
|
|
if (parent && parent.type === "document") {
|
|
return "";
|
|
}
|
|
}
|
|
if (!parent)
|
|
return DEFAULT_RAW[detect];
|
|
let root = node.root();
|
|
if (!root.rawCache)
|
|
root.rawCache = {};
|
|
if (typeof root.rawCache[detect] !== "undefined") {
|
|
return root.rawCache[detect];
|
|
}
|
|
if (detect === "before" || detect === "after") {
|
|
return this.beforeAfter(node, detect);
|
|
} else {
|
|
let method = "raw" + capitalize(detect);
|
|
if (this[method]) {
|
|
value = this[method](root, node);
|
|
} else {
|
|
root.walk((i) => {
|
|
value = i.raws[own];
|
|
if (typeof value !== "undefined")
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
if (typeof value === "undefined")
|
|
value = DEFAULT_RAW[detect];
|
|
root.rawCache[detect] = value;
|
|
return value;
|
|
}
|
|
rawBeforeClose(root) {
|
|
let value;
|
|
root.walk((i) => {
|
|
if (i.nodes && i.nodes.length > 0) {
|
|
if (typeof i.raws.after !== "undefined") {
|
|
value = i.raws.after;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
if (value)
|
|
value = value.replace(/\S/g, "");
|
|
return value;
|
|
}
|
|
rawBeforeComment(root, node) {
|
|
let value;
|
|
root.walkComments((i) => {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
if (typeof value === "undefined") {
|
|
value = this.raw(node, null, "beforeDecl");
|
|
} else if (value) {
|
|
value = value.replace(/\S/g, "");
|
|
}
|
|
return value;
|
|
}
|
|
rawBeforeDecl(root, node) {
|
|
let value;
|
|
root.walkDecls((i) => {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
if (typeof value === "undefined") {
|
|
value = this.raw(node, null, "beforeRule");
|
|
} else if (value) {
|
|
value = value.replace(/\S/g, "");
|
|
}
|
|
return value;
|
|
}
|
|
rawBeforeOpen(root) {
|
|
let value;
|
|
root.walk((i) => {
|
|
if (i.type !== "decl") {
|
|
value = i.raws.between;
|
|
if (typeof value !== "undefined")
|
|
return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawBeforeRule(root) {
|
|
let value;
|
|
root.walk((i) => {
|
|
if (i.nodes && (i.parent !== root || root.first !== i)) {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
if (value)
|
|
value = value.replace(/\S/g, "");
|
|
return value;
|
|
}
|
|
rawColon(root) {
|
|
let value;
|
|
root.walkDecls((i) => {
|
|
if (typeof i.raws.between !== "undefined") {
|
|
value = i.raws.between.replace(/[^\s:]/g, "");
|
|
return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawEmptyBody(root) {
|
|
let value;
|
|
root.walk((i) => {
|
|
if (i.nodes && i.nodes.length === 0) {
|
|
value = i.raws.after;
|
|
if (typeof value !== "undefined")
|
|
return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawIndent(root) {
|
|
if (root.raws.indent)
|
|
return root.raws.indent;
|
|
let value;
|
|
root.walk((i) => {
|
|
let p = i.parent;
|
|
if (p && p !== root && p.parent && p.parent === root) {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
let parts = i.raws.before.split("\n");
|
|
value = parts[parts.length - 1];
|
|
value = value.replace(/\S/g, "");
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawSemicolon(root) {
|
|
let value;
|
|
root.walk((i) => {
|
|
if (i.nodes && i.nodes.length && i.last.type === "decl") {
|
|
value = i.raws.semicolon;
|
|
if (typeof value !== "undefined")
|
|
return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawValue(node, prop) {
|
|
let value = node[prop];
|
|
let raw = node.raws[prop];
|
|
if (raw && raw.value === value) {
|
|
return raw.raw;
|
|
}
|
|
return value;
|
|
}
|
|
root(node) {
|
|
this.body(node);
|
|
if (node.raws.after)
|
|
this.builder(node.raws.after);
|
|
}
|
|
rule(node) {
|
|
this.block(node, this.rawValue(node, "selector"));
|
|
if (node.raws.ownSemicolon) {
|
|
this.builder(node.raws.ownSemicolon, node, "end");
|
|
}
|
|
}
|
|
stringify(node, semicolon) {
|
|
if (!this[node.type]) {
|
|
throw new Error("Unknown AST node type " + node.type + ". " + "Maybe you need to change PostCSS stringifier.");
|
|
}
|
|
this[node.type](node, semicolon);
|
|
}
|
|
}
|
|
module.exports = Stringifier;
|
|
Stringifier.default = Stringifier;
|
|
});
|
|
|
|
// node_modules/postcss/lib/stringify.js
|
|
var require_stringify2 = __commonJS((exports, module) => {
|
|
var Stringifier = require_stringifier();
|
|
function stringify(node, builder) {
|
|
let str = new Stringifier(builder);
|
|
str.stringify(node);
|
|
}
|
|
module.exports = stringify;
|
|
stringify.default = stringify;
|
|
});
|
|
|
|
// node_modules/postcss/lib/symbols.js
|
|
var require_symbols = __commonJS((exports, module) => {
|
|
exports.isClean = Symbol("isClean");
|
|
exports.my = Symbol("my");
|
|
});
|
|
|
|
// node_modules/postcss/lib/node.js
|
|
var require_node3 = __commonJS((exports, module) => {
|
|
var CssSyntaxError = require_css_syntax_error();
|
|
var Stringifier = require_stringifier();
|
|
var stringify = require_stringify2();
|
|
var { isClean, my } = require_symbols();
|
|
function cloneNode(obj, parent) {
|
|
let cloned = new obj.constructor;
|
|
for (let i in obj) {
|
|
if (!Object.prototype.hasOwnProperty.call(obj, i)) {
|
|
continue;
|
|
}
|
|
if (i === "proxyCache")
|
|
continue;
|
|
let value = obj[i];
|
|
let type = typeof value;
|
|
if (i === "parent" && type === "object") {
|
|
if (parent)
|
|
cloned[i] = parent;
|
|
} else if (i === "source") {
|
|
cloned[i] = value;
|
|
} else if (Array.isArray(value)) {
|
|
cloned[i] = value.map((j) => cloneNode(j, cloned));
|
|
} else {
|
|
if (type === "object" && value !== null)
|
|
value = cloneNode(value);
|
|
cloned[i] = value;
|
|
}
|
|
}
|
|
return cloned;
|
|
}
|
|
|
|
class Node {
|
|
constructor(defaults = {}) {
|
|
this.raws = {};
|
|
this[isClean] = false;
|
|
this[my] = true;
|
|
for (let name in defaults) {
|
|
if (name === "nodes") {
|
|
this.nodes = [];
|
|
for (let node of defaults[name]) {
|
|
if (typeof node.clone === "function") {
|
|
this.append(node.clone());
|
|
} else {
|
|
this.append(node);
|
|
}
|
|
}
|
|
} else {
|
|
this[name] = defaults[name];
|
|
}
|
|
}
|
|
}
|
|
addToError(error) {
|
|
error.postcssNode = this;
|
|
if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
|
|
let s = this.source;
|
|
error.stack = error.stack.replace(/\n\s{4}at /, `\$&${s.input.from}:${s.start.line}:${s.start.column}\$&`);
|
|
}
|
|
return error;
|
|
}
|
|
after(add) {
|
|
this.parent.insertAfter(this, add);
|
|
return this;
|
|
}
|
|
assign(overrides = {}) {
|
|
for (let name in overrides) {
|
|
this[name] = overrides[name];
|
|
}
|
|
return this;
|
|
}
|
|
before(add) {
|
|
this.parent.insertBefore(this, add);
|
|
return this;
|
|
}
|
|
cleanRaws(keepBetween) {
|
|
delete this.raws.before;
|
|
delete this.raws.after;
|
|
if (!keepBetween)
|
|
delete this.raws.between;
|
|
}
|
|
clone(overrides = {}) {
|
|
let cloned = cloneNode(this);
|
|
for (let name in overrides) {
|
|
cloned[name] = overrides[name];
|
|
}
|
|
return cloned;
|
|
}
|
|
cloneAfter(overrides = {}) {
|
|
let cloned = this.clone(overrides);
|
|
this.parent.insertAfter(this, cloned);
|
|
return cloned;
|
|
}
|
|
cloneBefore(overrides = {}) {
|
|
let cloned = this.clone(overrides);
|
|
this.parent.insertBefore(this, cloned);
|
|
return cloned;
|
|
}
|
|
error(message, opts = {}) {
|
|
if (this.source) {
|
|
let { end, start } = this.rangeBy(opts);
|
|
return this.source.input.error(message, { column: start.column, line: start.line }, { column: end.column, line: end.line }, opts);
|
|
}
|
|
return new CssSyntaxError(message);
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
get(node, prop) {
|
|
if (prop === "proxyOf") {
|
|
return node;
|
|
} else if (prop === "root") {
|
|
return () => node.root().toProxy();
|
|
} else {
|
|
return node[prop];
|
|
}
|
|
},
|
|
set(node, prop, value) {
|
|
if (node[prop] === value)
|
|
return true;
|
|
node[prop] = value;
|
|
if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || prop === "text") {
|
|
node.markDirty();
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
markClean() {
|
|
this[isClean] = true;
|
|
}
|
|
markDirty() {
|
|
if (this[isClean]) {
|
|
this[isClean] = false;
|
|
let next = this;
|
|
while (next = next.parent) {
|
|
next[isClean] = false;
|
|
}
|
|
}
|
|
}
|
|
next() {
|
|
if (!this.parent)
|
|
return;
|
|
let index = this.parent.index(this);
|
|
return this.parent.nodes[index + 1];
|
|
}
|
|
positionBy(opts, stringRepresentation) {
|
|
let pos = this.source.start;
|
|
if (opts.index) {
|
|
pos = this.positionInside(opts.index, stringRepresentation);
|
|
} else if (opts.word) {
|
|
stringRepresentation = this.toString();
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1)
|
|
pos = this.positionInside(index, stringRepresentation);
|
|
}
|
|
return pos;
|
|
}
|
|
positionInside(index, stringRepresentation) {
|
|
let string = stringRepresentation || this.toString();
|
|
let column = this.source.start.column;
|
|
let line = this.source.start.line;
|
|
for (let i = 0;i < index; i++) {
|
|
if (string[i] === "\n") {
|
|
column = 1;
|
|
line += 1;
|
|
} else {
|
|
column += 1;
|
|
}
|
|
}
|
|
return { column, line };
|
|
}
|
|
prev() {
|
|
if (!this.parent)
|
|
return;
|
|
let index = this.parent.index(this);
|
|
return this.parent.nodes[index - 1];
|
|
}
|
|
rangeBy(opts) {
|
|
let start = {
|
|
column: this.source.start.column,
|
|
line: this.source.start.line
|
|
};
|
|
let end = this.source.end ? {
|
|
column: this.source.end.column + 1,
|
|
line: this.source.end.line
|
|
} : {
|
|
column: start.column + 1,
|
|
line: start.line
|
|
};
|
|
if (opts.word) {
|
|
let stringRepresentation = this.toString();
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1) {
|
|
start = this.positionInside(index, stringRepresentation);
|
|
end = this.positionInside(index + opts.word.length, stringRepresentation);
|
|
}
|
|
} else {
|
|
if (opts.start) {
|
|
start = {
|
|
column: opts.start.column,
|
|
line: opts.start.line
|
|
};
|
|
} else if (opts.index) {
|
|
start = this.positionInside(opts.index);
|
|
}
|
|
if (opts.end) {
|
|
end = {
|
|
column: opts.end.column,
|
|
line: opts.end.line
|
|
};
|
|
} else if (typeof opts.endIndex === "number") {
|
|
end = this.positionInside(opts.endIndex);
|
|
} else if (opts.index) {
|
|
end = this.positionInside(opts.index + 1);
|
|
}
|
|
}
|
|
if (end.line < start.line || end.line === start.line && end.column <= start.column) {
|
|
end = { column: start.column + 1, line: start.line };
|
|
}
|
|
return { end, start };
|
|
}
|
|
raw(prop, defaultType) {
|
|
let str = new Stringifier;
|
|
return str.raw(this, prop, defaultType);
|
|
}
|
|
remove() {
|
|
if (this.parent) {
|
|
this.parent.removeChild(this);
|
|
}
|
|
this.parent = undefined;
|
|
return this;
|
|
}
|
|
replaceWith(...nodes) {
|
|
if (this.parent) {
|
|
let bookmark = this;
|
|
let foundSelf = false;
|
|
for (let node of nodes) {
|
|
if (node === this) {
|
|
foundSelf = true;
|
|
} else if (foundSelf) {
|
|
this.parent.insertAfter(bookmark, node);
|
|
bookmark = node;
|
|
} else {
|
|
this.parent.insertBefore(bookmark, node);
|
|
}
|
|
}
|
|
if (!foundSelf) {
|
|
this.remove();
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
root() {
|
|
let result = this;
|
|
while (result.parent && result.parent.type !== "document") {
|
|
result = result.parent;
|
|
}
|
|
return result;
|
|
}
|
|
toJSON(_, inputs) {
|
|
let fixed = {};
|
|
let emitInputs = inputs == null;
|
|
inputs = inputs || new Map;
|
|
let inputsNextIndex = 0;
|
|
for (let name in this) {
|
|
if (!Object.prototype.hasOwnProperty.call(this, name)) {
|
|
continue;
|
|
}
|
|
if (name === "parent" || name === "proxyCache")
|
|
continue;
|
|
let value = this[name];
|
|
if (Array.isArray(value)) {
|
|
fixed[name] = value.map((i) => {
|
|
if (typeof i === "object" && i.toJSON) {
|
|
return i.toJSON(null, inputs);
|
|
} else {
|
|
return i;
|
|
}
|
|
});
|
|
} else if (typeof value === "object" && value.toJSON) {
|
|
fixed[name] = value.toJSON(null, inputs);
|
|
} else if (name === "source") {
|
|
let inputId = inputs.get(value.input);
|
|
if (inputId == null) {
|
|
inputId = inputsNextIndex;
|
|
inputs.set(value.input, inputsNextIndex);
|
|
inputsNextIndex++;
|
|
}
|
|
fixed[name] = {
|
|
end: value.end,
|
|
inputId,
|
|
start: value.start
|
|
};
|
|
} else {
|
|
fixed[name] = value;
|
|
}
|
|
}
|
|
if (emitInputs) {
|
|
fixed.inputs = [...inputs.keys()].map((input) => input.toJSON());
|
|
}
|
|
return fixed;
|
|
}
|
|
toProxy() {
|
|
if (!this.proxyCache) {
|
|
this.proxyCache = new Proxy(this, this.getProxyProcessor());
|
|
}
|
|
return this.proxyCache;
|
|
}
|
|
toString(stringifier = stringify) {
|
|
if (stringifier.stringify)
|
|
stringifier = stringifier.stringify;
|
|
let result = "";
|
|
stringifier(this, (i) => {
|
|
result += i;
|
|
});
|
|
return result;
|
|
}
|
|
warn(result, text, opts) {
|
|
let data = { node: this };
|
|
for (let i in opts)
|
|
data[i] = opts[i];
|
|
return result.warn(text, data);
|
|
}
|
|
get proxyOf() {
|
|
return this;
|
|
}
|
|
}
|
|
module.exports = Node;
|
|
Node.default = Node;
|
|
});
|
|
|
|
// node_modules/postcss/lib/comment.js
|
|
var require_comment = __commonJS((exports, module) => {
|
|
var Node = require_node3();
|
|
|
|
class Comment extends Node {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "comment";
|
|
}
|
|
}
|
|
module.exports = Comment;
|
|
Comment.default = Comment;
|
|
});
|
|
|
|
// node_modules/postcss/lib/declaration.js
|
|
var require_declaration = __commonJS((exports, module) => {
|
|
var Node = require_node3();
|
|
|
|
class Declaration extends Node {
|
|
constructor(defaults) {
|
|
if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
|
|
defaults = { ...defaults, value: String(defaults.value) };
|
|
}
|
|
super(defaults);
|
|
this.type = "decl";
|
|
}
|
|
get variable() {
|
|
return this.prop.startsWith("--") || this.prop[0] === "$";
|
|
}
|
|
}
|
|
module.exports = Declaration;
|
|
Declaration.default = Declaration;
|
|
});
|
|
|
|
// node_modules/postcss/lib/container.js
|
|
var require_container = __commonJS((exports, module) => {
|
|
var Comment = require_comment();
|
|
var Declaration = require_declaration();
|
|
var Node = require_node3();
|
|
var { isClean, my } = require_symbols();
|
|
var AtRule;
|
|
var parse;
|
|
var Root;
|
|
var Rule;
|
|
function cleanSource(nodes) {
|
|
return nodes.map((i) => {
|
|
if (i.nodes)
|
|
i.nodes = cleanSource(i.nodes);
|
|
delete i.source;
|
|
return i;
|
|
});
|
|
}
|
|
function markTreeDirty(node) {
|
|
node[isClean] = false;
|
|
if (node.proxyOf.nodes) {
|
|
for (let i of node.proxyOf.nodes) {
|
|
markTreeDirty(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
class Container extends Node {
|
|
append(...children) {
|
|
for (let child of children) {
|
|
let nodes = this.normalize(child, this.last);
|
|
for (let node of nodes)
|
|
this.proxyOf.nodes.push(node);
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
cleanRaws(keepBetween) {
|
|
super.cleanRaws(keepBetween);
|
|
if (this.nodes) {
|
|
for (let node of this.nodes)
|
|
node.cleanRaws(keepBetween);
|
|
}
|
|
}
|
|
each(callback) {
|
|
if (!this.proxyOf.nodes)
|
|
return;
|
|
let iterator = this.getIterator();
|
|
let index, result;
|
|
while (this.indexes[iterator] < this.proxyOf.nodes.length) {
|
|
index = this.indexes[iterator];
|
|
result = callback(this.proxyOf.nodes[index], index);
|
|
if (result === false)
|
|
break;
|
|
this.indexes[iterator] += 1;
|
|
}
|
|
delete this.indexes[iterator];
|
|
return result;
|
|
}
|
|
every(condition) {
|
|
return this.nodes.every(condition);
|
|
}
|
|
getIterator() {
|
|
if (!this.lastEach)
|
|
this.lastEach = 0;
|
|
if (!this.indexes)
|
|
this.indexes = {};
|
|
this.lastEach += 1;
|
|
let iterator = this.lastEach;
|
|
this.indexes[iterator] = 0;
|
|
return iterator;
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
get(node, prop) {
|
|
if (prop === "proxyOf") {
|
|
return node;
|
|
} else if (!node[prop]) {
|
|
return node[prop];
|
|
} else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
|
|
return (...args) => {
|
|
return node[prop](...args.map((i) => {
|
|
if (typeof i === "function") {
|
|
return (child, index) => i(child.toProxy(), index);
|
|
} else {
|
|
return i;
|
|
}
|
|
}));
|
|
};
|
|
} else if (prop === "every" || prop === "some") {
|
|
return (cb) => {
|
|
return node[prop]((child, ...other) => cb(child.toProxy(), ...other));
|
|
};
|
|
} else if (prop === "root") {
|
|
return () => node.root().toProxy();
|
|
} else if (prop === "nodes") {
|
|
return node.nodes.map((i) => i.toProxy());
|
|
} else if (prop === "first" || prop === "last") {
|
|
return node[prop].toProxy();
|
|
} else {
|
|
return node[prop];
|
|
}
|
|
},
|
|
set(node, prop, value) {
|
|
if (node[prop] === value)
|
|
return true;
|
|
node[prop] = value;
|
|
if (prop === "name" || prop === "params" || prop === "selector") {
|
|
node.markDirty();
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
index(child) {
|
|
if (typeof child === "number")
|
|
return child;
|
|
if (child.proxyOf)
|
|
child = child.proxyOf;
|
|
return this.proxyOf.nodes.indexOf(child);
|
|
}
|
|
insertAfter(exist, add) {
|
|
let existIndex = this.index(exist);
|
|
let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
|
|
existIndex = this.index(exist);
|
|
for (let node of nodes)
|
|
this.proxyOf.nodes.splice(existIndex + 1, 0, node);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (existIndex < index) {
|
|
this.indexes[id] = index + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
insertBefore(exist, add) {
|
|
let existIndex = this.index(exist);
|
|
let type = existIndex === 0 ? "prepend" : false;
|
|
let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
|
|
existIndex = this.index(exist);
|
|
for (let node of nodes)
|
|
this.proxyOf.nodes.splice(existIndex, 0, node);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (existIndex <= index) {
|
|
this.indexes[id] = index + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
normalize(nodes, sample) {
|
|
if (typeof nodes === "string") {
|
|
nodes = cleanSource(parse(nodes).nodes);
|
|
} else if (typeof nodes === "undefined") {
|
|
nodes = [];
|
|
} else if (Array.isArray(nodes)) {
|
|
nodes = nodes.slice(0);
|
|
for (let i of nodes) {
|
|
if (i.parent)
|
|
i.parent.removeChild(i, "ignore");
|
|
}
|
|
} else if (nodes.type === "root" && this.type !== "document") {
|
|
nodes = nodes.nodes.slice(0);
|
|
for (let i of nodes) {
|
|
if (i.parent)
|
|
i.parent.removeChild(i, "ignore");
|
|
}
|
|
} else if (nodes.type) {
|
|
nodes = [nodes];
|
|
} else if (nodes.prop) {
|
|
if (typeof nodes.value === "undefined") {
|
|
throw new Error("Value field is missed in node creation");
|
|
} else if (typeof nodes.value !== "string") {
|
|
nodes.value = String(nodes.value);
|
|
}
|
|
nodes = [new Declaration(nodes)];
|
|
} else if (nodes.selector || nodes.selectors) {
|
|
nodes = [new Rule(nodes)];
|
|
} else if (nodes.name) {
|
|
nodes = [new AtRule(nodes)];
|
|
} else if (nodes.text) {
|
|
nodes = [new Comment(nodes)];
|
|
} else {
|
|
throw new Error("Unknown node type in node creation");
|
|
}
|
|
let processed = nodes.map((i) => {
|
|
if (!i[my])
|
|
Container.rebuild(i);
|
|
i = i.proxyOf;
|
|
if (i.parent)
|
|
i.parent.removeChild(i);
|
|
if (i[isClean])
|
|
markTreeDirty(i);
|
|
if (!i.raws)
|
|
i.raws = {};
|
|
if (typeof i.raws.before === "undefined") {
|
|
if (sample && typeof sample.raws.before !== "undefined") {
|
|
i.raws.before = sample.raws.before.replace(/\S/g, "");
|
|
}
|
|
}
|
|
i.parent = this.proxyOf;
|
|
return i;
|
|
});
|
|
return processed;
|
|
}
|
|
prepend(...children) {
|
|
children = children.reverse();
|
|
for (let child of children) {
|
|
let nodes = this.normalize(child, this.first, "prepend").reverse();
|
|
for (let node of nodes)
|
|
this.proxyOf.nodes.unshift(node);
|
|
for (let id in this.indexes) {
|
|
this.indexes[id] = this.indexes[id] + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
push(child) {
|
|
child.parent = this;
|
|
this.proxyOf.nodes.push(child);
|
|
return this;
|
|
}
|
|
removeAll() {
|
|
for (let node of this.proxyOf.nodes)
|
|
node.parent = undefined;
|
|
this.proxyOf.nodes = [];
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
removeChild(child) {
|
|
child = this.index(child);
|
|
this.proxyOf.nodes[child].parent = undefined;
|
|
this.proxyOf.nodes.splice(child, 1);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (index >= child) {
|
|
this.indexes[id] = index - 1;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
replaceValues(pattern, opts, callback) {
|
|
if (!callback) {
|
|
callback = opts;
|
|
opts = {};
|
|
}
|
|
this.walkDecls((decl) => {
|
|
if (opts.props && !opts.props.includes(decl.prop))
|
|
return;
|
|
if (opts.fast && !decl.value.includes(opts.fast))
|
|
return;
|
|
decl.value = decl.value.replace(pattern, callback);
|
|
});
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
some(condition) {
|
|
return this.nodes.some(condition);
|
|
}
|
|
walk(callback) {
|
|
return this.each((child, i) => {
|
|
let result;
|
|
try {
|
|
result = callback(child, i);
|
|
} catch (e) {
|
|
throw child.addToError(e);
|
|
}
|
|
if (result !== false && child.walk) {
|
|
result = child.walk(callback);
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
walkAtRules(name, callback) {
|
|
if (!callback) {
|
|
callback = name;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (name instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule" && name.test(child.name)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule" && child.name === name) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkComments(callback) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "comment") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkDecls(prop, callback) {
|
|
if (!callback) {
|
|
callback = prop;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (prop instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl" && prop.test(child.prop)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl" && child.prop === prop) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkRules(selector, callback) {
|
|
if (!callback) {
|
|
callback = selector;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (selector instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule" && selector.test(child.selector)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule" && child.selector === selector) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
get first() {
|
|
if (!this.proxyOf.nodes)
|
|
return;
|
|
return this.proxyOf.nodes[0];
|
|
}
|
|
get last() {
|
|
if (!this.proxyOf.nodes)
|
|
return;
|
|
return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
|
|
}
|
|
}
|
|
Container.registerParse = (dependant) => {
|
|
parse = dependant;
|
|
};
|
|
Container.registerRule = (dependant) => {
|
|
Rule = dependant;
|
|
};
|
|
Container.registerAtRule = (dependant) => {
|
|
AtRule = dependant;
|
|
};
|
|
Container.registerRoot = (dependant) => {
|
|
Root = dependant;
|
|
};
|
|
module.exports = Container;
|
|
Container.default = Container;
|
|
Container.rebuild = (node) => {
|
|
if (node.type === "atrule") {
|
|
Object.setPrototypeOf(node, AtRule.prototype);
|
|
} else if (node.type === "rule") {
|
|
Object.setPrototypeOf(node, Rule.prototype);
|
|
} else if (node.type === "decl") {
|
|
Object.setPrototypeOf(node, Declaration.prototype);
|
|
} else if (node.type === "comment") {
|
|
Object.setPrototypeOf(node, Comment.prototype);
|
|
} else if (node.type === "root") {
|
|
Object.setPrototypeOf(node, Root.prototype);
|
|
}
|
|
node[my] = true;
|
|
if (node.nodes) {
|
|
node.nodes.forEach((child) => {
|
|
Container.rebuild(child);
|
|
});
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/postcss/lib/at-rule.js
|
|
var require_at_rule = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
|
|
class AtRule extends Container {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "atrule";
|
|
}
|
|
append(...children) {
|
|
if (!this.proxyOf.nodes)
|
|
this.nodes = [];
|
|
return super.append(...children);
|
|
}
|
|
prepend(...children) {
|
|
if (!this.proxyOf.nodes)
|
|
this.nodes = [];
|
|
return super.prepend(...children);
|
|
}
|
|
}
|
|
module.exports = AtRule;
|
|
AtRule.default = AtRule;
|
|
Container.registerAtRule(AtRule);
|
|
});
|
|
|
|
// node_modules/postcss/lib/document.js
|
|
var require_document = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
var LazyResult;
|
|
var Processor;
|
|
|
|
class Document extends Container {
|
|
constructor(defaults) {
|
|
super({ type: "document", ...defaults });
|
|
if (!this.nodes) {
|
|
this.nodes = [];
|
|
}
|
|
}
|
|
toResult(opts = {}) {
|
|
let lazy = new LazyResult(new Processor, this, opts);
|
|
return lazy.stringify();
|
|
}
|
|
}
|
|
Document.registerLazyResult = (dependant) => {
|
|
LazyResult = dependant;
|
|
};
|
|
Document.registerProcessor = (dependant) => {
|
|
Processor = dependant;
|
|
};
|
|
module.exports = Document;
|
|
Document.default = Document;
|
|
});
|
|
|
|
// node_modules/nanoid/non-secure/index.cjs
|
|
var require_non_secure = __commonJS((exports, module) => {
|
|
var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
|
var customAlphabet = (alphabet, defaultSize = 21) => {
|
|
return (size = defaultSize) => {
|
|
let id = "";
|
|
let i = size;
|
|
while (i--) {
|
|
id += alphabet[Math.random() * alphabet.length | 0];
|
|
}
|
|
return id;
|
|
};
|
|
};
|
|
var nanoid = (size = 21) => {
|
|
let id = "";
|
|
let i = size;
|
|
while (i--) {
|
|
id += urlAlphabet[Math.random() * 64 | 0];
|
|
}
|
|
return id;
|
|
};
|
|
module.exports = { nanoid, customAlphabet };
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/base64.js
|
|
var require_base64 = __commonJS((exports) => {
|
|
var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
|
|
exports.encode = function(number) {
|
|
if (0 <= number && number < intToCharMap.length) {
|
|
return intToCharMap[number];
|
|
}
|
|
throw new TypeError("Must be between 0 and 63: " + number);
|
|
};
|
|
exports.decode = function(charCode) {
|
|
var bigA = 65;
|
|
var bigZ = 90;
|
|
var littleA = 97;
|
|
var littleZ = 122;
|
|
var zero = 48;
|
|
var nine = 57;
|
|
var plus = 43;
|
|
var slash = 47;
|
|
var littleOffset = 26;
|
|
var numberOffset = 52;
|
|
if (bigA <= charCode && charCode <= bigZ) {
|
|
return charCode - bigA;
|
|
}
|
|
if (littleA <= charCode && charCode <= littleZ) {
|
|
return charCode - littleA + littleOffset;
|
|
}
|
|
if (zero <= charCode && charCode <= nine) {
|
|
return charCode - zero + numberOffset;
|
|
}
|
|
if (charCode == plus) {
|
|
return 62;
|
|
}
|
|
if (charCode == slash) {
|
|
return 63;
|
|
}
|
|
return -1;
|
|
};
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/base64-vlq.js
|
|
var require_base64_vlq = __commonJS((exports) => {
|
|
var base64 = require_base64();
|
|
var VLQ_BASE_SHIFT = 5;
|
|
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
|
|
var VLQ_BASE_MASK = VLQ_BASE - 1;
|
|
var VLQ_CONTINUATION_BIT = VLQ_BASE;
|
|
function toVLQSigned(aValue) {
|
|
return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
|
|
}
|
|
function fromVLQSigned(aValue) {
|
|
var isNegative = (aValue & 1) === 1;
|
|
var shifted = aValue >> 1;
|
|
return isNegative ? -shifted : shifted;
|
|
}
|
|
exports.encode = function base64VLQ_encode(aValue) {
|
|
var encoded = "";
|
|
var digit;
|
|
var vlq = toVLQSigned(aValue);
|
|
do {
|
|
digit = vlq & VLQ_BASE_MASK;
|
|
vlq >>>= VLQ_BASE_SHIFT;
|
|
if (vlq > 0) {
|
|
digit |= VLQ_CONTINUATION_BIT;
|
|
}
|
|
encoded += base64.encode(digit);
|
|
} while (vlq > 0);
|
|
return encoded;
|
|
};
|
|
exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
|
|
var strLen = aStr.length;
|
|
var result = 0;
|
|
var shift = 0;
|
|
var continuation, digit;
|
|
do {
|
|
if (aIndex >= strLen) {
|
|
throw new Error("Expected more digits in base 64 VLQ value.");
|
|
}
|
|
digit = base64.decode(aStr.charCodeAt(aIndex++));
|
|
if (digit === -1) {
|
|
throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
|
|
}
|
|
continuation = !!(digit & VLQ_CONTINUATION_BIT);
|
|
digit &= VLQ_BASE_MASK;
|
|
result = result + (digit << shift);
|
|
shift += VLQ_BASE_SHIFT;
|
|
} while (continuation);
|
|
aOutParam.value = fromVLQSigned(result);
|
|
aOutParam.rest = aIndex;
|
|
};
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/util.js
|
|
var require_util2 = __commonJS((exports) => {
|
|
function getArg(aArgs, aName, aDefaultValue) {
|
|
if (aName in aArgs) {
|
|
return aArgs[aName];
|
|
} else if (arguments.length === 3) {
|
|
return aDefaultValue;
|
|
} else {
|
|
throw new Error('"' + aName + '" is a required argument.');
|
|
}
|
|
}
|
|
exports.getArg = getArg;
|
|
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
|
|
var dataUrlRegexp = /^data:.+\,.+$/;
|
|
function urlParse(aUrl) {
|
|
var match = aUrl.match(urlRegexp);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
return {
|
|
scheme: match[1],
|
|
auth: match[2],
|
|
host: match[3],
|
|
port: match[4],
|
|
path: match[5]
|
|
};
|
|
}
|
|
exports.urlParse = urlParse;
|
|
function urlGenerate(aParsedUrl) {
|
|
var url = "";
|
|
if (aParsedUrl.scheme) {
|
|
url += aParsedUrl.scheme + ":";
|
|
}
|
|
url += "//";
|
|
if (aParsedUrl.auth) {
|
|
url += aParsedUrl.auth + "@";
|
|
}
|
|
if (aParsedUrl.host) {
|
|
url += aParsedUrl.host;
|
|
}
|
|
if (aParsedUrl.port) {
|
|
url += ":" + aParsedUrl.port;
|
|
}
|
|
if (aParsedUrl.path) {
|
|
url += aParsedUrl.path;
|
|
}
|
|
return url;
|
|
}
|
|
exports.urlGenerate = urlGenerate;
|
|
var MAX_CACHED_INPUTS = 32;
|
|
function lruMemoize(f) {
|
|
var cache = [];
|
|
return function(input) {
|
|
for (var i = 0;i < cache.length; i++) {
|
|
if (cache[i].input === input) {
|
|
var temp = cache[0];
|
|
cache[0] = cache[i];
|
|
cache[i] = temp;
|
|
return cache[0].result;
|
|
}
|
|
}
|
|
var result = f(input);
|
|
cache.unshift({
|
|
input,
|
|
result
|
|
});
|
|
if (cache.length > MAX_CACHED_INPUTS) {
|
|
cache.pop();
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
var normalize = lruMemoize(function normalize(aPath) {
|
|
var path = aPath;
|
|
var url = urlParse(aPath);
|
|
if (url) {
|
|
if (!url.path) {
|
|
return aPath;
|
|
}
|
|
path = url.path;
|
|
}
|
|
var isAbsolute = exports.isAbsolute(path);
|
|
var parts = [];
|
|
var start = 0;
|
|
var i = 0;
|
|
while (true) {
|
|
start = i;
|
|
i = path.indexOf("/", start);
|
|
if (i === -1) {
|
|
parts.push(path.slice(start));
|
|
break;
|
|
} else {
|
|
parts.push(path.slice(start, i));
|
|
while (i < path.length && path[i] === "/") {
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
|
|
part = parts[i];
|
|
if (part === ".") {
|
|
parts.splice(i, 1);
|
|
} else if (part === "..") {
|
|
up++;
|
|
} else if (up > 0) {
|
|
if (part === "") {
|
|
parts.splice(i + 1, up);
|
|
up = 0;
|
|
} else {
|
|
parts.splice(i, 2);
|
|
up--;
|
|
}
|
|
}
|
|
}
|
|
path = parts.join("/");
|
|
if (path === "") {
|
|
path = isAbsolute ? "/" : ".";
|
|
}
|
|
if (url) {
|
|
url.path = path;
|
|
return urlGenerate(url);
|
|
}
|
|
return path;
|
|
});
|
|
exports.normalize = normalize;
|
|
function join(aRoot, aPath) {
|
|
if (aRoot === "") {
|
|
aRoot = ".";
|
|
}
|
|
if (aPath === "") {
|
|
aPath = ".";
|
|
}
|
|
var aPathUrl = urlParse(aPath);
|
|
var aRootUrl = urlParse(aRoot);
|
|
if (aRootUrl) {
|
|
aRoot = aRootUrl.path || "/";
|
|
}
|
|
if (aPathUrl && !aPathUrl.scheme) {
|
|
if (aRootUrl) {
|
|
aPathUrl.scheme = aRootUrl.scheme;
|
|
}
|
|
return urlGenerate(aPathUrl);
|
|
}
|
|
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
|
return aPath;
|
|
}
|
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
|
aRootUrl.host = aPath;
|
|
return urlGenerate(aRootUrl);
|
|
}
|
|
var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
|
|
if (aRootUrl) {
|
|
aRootUrl.path = joined;
|
|
return urlGenerate(aRootUrl);
|
|
}
|
|
return joined;
|
|
}
|
|
exports.join = join;
|
|
exports.isAbsolute = function(aPath) {
|
|
return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
|
|
};
|
|
function relative(aRoot, aPath) {
|
|
if (aRoot === "") {
|
|
aRoot = ".";
|
|
}
|
|
aRoot = aRoot.replace(/\/$/, "");
|
|
var level = 0;
|
|
while (aPath.indexOf(aRoot + "/") !== 0) {
|
|
var index = aRoot.lastIndexOf("/");
|
|
if (index < 0) {
|
|
return aPath;
|
|
}
|
|
aRoot = aRoot.slice(0, index);
|
|
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
|
|
return aPath;
|
|
}
|
|
++level;
|
|
}
|
|
return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
|
|
}
|
|
exports.relative = relative;
|
|
var supportsNullProto = function() {
|
|
var obj = Object.create(null);
|
|
return !("__proto__" in obj);
|
|
}();
|
|
function identity(s) {
|
|
return s;
|
|
}
|
|
function toSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return "$" + aStr;
|
|
}
|
|
return aStr;
|
|
}
|
|
exports.toSetString = supportsNullProto ? identity : toSetString;
|
|
function fromSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return aStr.slice(1);
|
|
}
|
|
return aStr;
|
|
}
|
|
exports.fromSetString = supportsNullProto ? identity : fromSetString;
|
|
function isProtoString(s) {
|
|
if (!s) {
|
|
return false;
|
|
}
|
|
var length = s.length;
|
|
if (length < 9) {
|
|
return false;
|
|
}
|
|
if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
|
|
return false;
|
|
}
|
|
for (var i = length - 10;i >= 0; i--) {
|
|
if (s.charCodeAt(i) !== 36) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
|
var cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0 || onlyCompareOriginal) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByOriginalPositions = compareByOriginalPositions;
|
|
function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
|
|
var cmp;
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0 || onlyCompareOriginal) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
|
|
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
|
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0 || onlyCompareGenerated) {
|
|
return cmp;
|
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
|
|
function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
|
|
var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0 || onlyCompareGenerated) {
|
|
return cmp;
|
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
|
|
function strcmp(aStr1, aStr2) {
|
|
if (aStr1 === aStr2) {
|
|
return 0;
|
|
}
|
|
if (aStr1 === null) {
|
|
return 1;
|
|
}
|
|
if (aStr2 === null) {
|
|
return -1;
|
|
}
|
|
if (aStr1 > aStr2) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
|
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
|
|
function parseSourceMapInput(str) {
|
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
|
|
}
|
|
exports.parseSourceMapInput = parseSourceMapInput;
|
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
|
|
sourceURL = sourceURL || "";
|
|
if (sourceRoot) {
|
|
if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
|
|
sourceRoot += "/";
|
|
}
|
|
sourceURL = sourceRoot + sourceURL;
|
|
}
|
|
if (sourceMapURL) {
|
|
var parsed = urlParse(sourceMapURL);
|
|
if (!parsed) {
|
|
throw new Error("sourceMapURL could not be parsed");
|
|
}
|
|
if (parsed.path) {
|
|
var index = parsed.path.lastIndexOf("/");
|
|
if (index >= 0) {
|
|
parsed.path = parsed.path.substring(0, index + 1);
|
|
}
|
|
}
|
|
sourceURL = join(urlGenerate(parsed), sourceURL);
|
|
}
|
|
return normalize(sourceURL);
|
|
}
|
|
exports.computeSourceURL = computeSourceURL;
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/array-set.js
|
|
var require_array_set = __commonJS((exports) => {
|
|
var util = require_util2();
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var hasNativeMap = typeof Map !== "undefined";
|
|
function ArraySet() {
|
|
this._array = [];
|
|
this._set = hasNativeMap ? new Map : Object.create(null);
|
|
}
|
|
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
|
|
var set = new ArraySet;
|
|
for (var i = 0, len = aArray.length;i < len; i++) {
|
|
set.add(aArray[i], aAllowDuplicates);
|
|
}
|
|
return set;
|
|
};
|
|
ArraySet.prototype.size = function ArraySet_size() {
|
|
return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
|
|
};
|
|
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
|
|
var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
|
|
var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
|
|
var idx = this._array.length;
|
|
if (!isDuplicate || aAllowDuplicates) {
|
|
this._array.push(aStr);
|
|
}
|
|
if (!isDuplicate) {
|
|
if (hasNativeMap) {
|
|
this._set.set(aStr, idx);
|
|
} else {
|
|
this._set[sStr] = idx;
|
|
}
|
|
}
|
|
};
|
|
ArraySet.prototype.has = function ArraySet_has(aStr) {
|
|
if (hasNativeMap) {
|
|
return this._set.has(aStr);
|
|
} else {
|
|
var sStr = util.toSetString(aStr);
|
|
return has.call(this._set, sStr);
|
|
}
|
|
};
|
|
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
|
|
if (hasNativeMap) {
|
|
var idx = this._set.get(aStr);
|
|
if (idx >= 0) {
|
|
return idx;
|
|
}
|
|
} else {
|
|
var sStr = util.toSetString(aStr);
|
|
if (has.call(this._set, sStr)) {
|
|
return this._set[sStr];
|
|
}
|
|
}
|
|
throw new Error('"' + aStr + '" is not in the set.');
|
|
};
|
|
ArraySet.prototype.at = function ArraySet_at(aIdx) {
|
|
if (aIdx >= 0 && aIdx < this._array.length) {
|
|
return this._array[aIdx];
|
|
}
|
|
throw new Error("No element indexed by " + aIdx);
|
|
};
|
|
ArraySet.prototype.toArray = function ArraySet_toArray() {
|
|
return this._array.slice();
|
|
};
|
|
exports.ArraySet = ArraySet;
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/mapping-list.js
|
|
var require_mapping_list = __commonJS((exports) => {
|
|
var util = require_util2();
|
|
function generatedPositionAfter(mappingA, mappingB) {
|
|
var lineA = mappingA.generatedLine;
|
|
var lineB = mappingB.generatedLine;
|
|
var columnA = mappingA.generatedColumn;
|
|
var columnB = mappingB.generatedColumn;
|
|
return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
|
|
}
|
|
function MappingList() {
|
|
this._array = [];
|
|
this._sorted = true;
|
|
this._last = { generatedLine: -1, generatedColumn: 0 };
|
|
}
|
|
MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
|
|
this._array.forEach(aCallback, aThisArg);
|
|
};
|
|
MappingList.prototype.add = function MappingList_add(aMapping) {
|
|
if (generatedPositionAfter(this._last, aMapping)) {
|
|
this._last = aMapping;
|
|
this._array.push(aMapping);
|
|
} else {
|
|
this._sorted = false;
|
|
this._array.push(aMapping);
|
|
}
|
|
};
|
|
MappingList.prototype.toArray = function MappingList_toArray() {
|
|
if (!this._sorted) {
|
|
this._array.sort(util.compareByGeneratedPositionsInflated);
|
|
this._sorted = true;
|
|
}
|
|
return this._array;
|
|
};
|
|
exports.MappingList = MappingList;
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/source-map-generator.js
|
|
var require_source_map_generator = __commonJS((exports) => {
|
|
var base64VLQ = require_base64_vlq();
|
|
var util = require_util2();
|
|
var ArraySet = require_array_set().ArraySet;
|
|
var MappingList = require_mapping_list().MappingList;
|
|
function SourceMapGenerator(aArgs) {
|
|
if (!aArgs) {
|
|
aArgs = {};
|
|
}
|
|
this._file = util.getArg(aArgs, "file", null);
|
|
this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
|
|
this._skipValidation = util.getArg(aArgs, "skipValidation", false);
|
|
this._ignoreInvalidMapping = util.getArg(aArgs, "ignoreInvalidMapping", false);
|
|
this._sources = new ArraySet;
|
|
this._names = new ArraySet;
|
|
this._mappings = new MappingList;
|
|
this._sourcesContents = null;
|
|
}
|
|
SourceMapGenerator.prototype._version = 3;
|
|
SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
|
|
var sourceRoot = aSourceMapConsumer.sourceRoot;
|
|
var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
|
|
file: aSourceMapConsumer.file,
|
|
sourceRoot
|
|
}));
|
|
aSourceMapConsumer.eachMapping(function(mapping) {
|
|
var newMapping = {
|
|
generated: {
|
|
line: mapping.generatedLine,
|
|
column: mapping.generatedColumn
|
|
}
|
|
};
|
|
if (mapping.source != null) {
|
|
newMapping.source = mapping.source;
|
|
if (sourceRoot != null) {
|
|
newMapping.source = util.relative(sourceRoot, newMapping.source);
|
|
}
|
|
newMapping.original = {
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
};
|
|
if (mapping.name != null) {
|
|
newMapping.name = mapping.name;
|
|
}
|
|
}
|
|
generator.addMapping(newMapping);
|
|
});
|
|
aSourceMapConsumer.sources.forEach(function(sourceFile) {
|
|
var sourceRelative = sourceFile;
|
|
if (sourceRoot !== null) {
|
|
sourceRelative = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
if (!generator._sources.has(sourceRelative)) {
|
|
generator._sources.add(sourceRelative);
|
|
}
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
generator.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
return generator;
|
|
};
|
|
SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
|
|
var generated = util.getArg(aArgs, "generated");
|
|
var original = util.getArg(aArgs, "original", null);
|
|
var source = util.getArg(aArgs, "source", null);
|
|
var name = util.getArg(aArgs, "name", null);
|
|
if (!this._skipValidation) {
|
|
if (this._validateMapping(generated, original, source, name) === false) {
|
|
return;
|
|
}
|
|
}
|
|
if (source != null) {
|
|
source = String(source);
|
|
if (!this._sources.has(source)) {
|
|
this._sources.add(source);
|
|
}
|
|
}
|
|
if (name != null) {
|
|
name = String(name);
|
|
if (!this._names.has(name)) {
|
|
this._names.add(name);
|
|
}
|
|
}
|
|
this._mappings.add({
|
|
generatedLine: generated.line,
|
|
generatedColumn: generated.column,
|
|
originalLine: original != null && original.line,
|
|
originalColumn: original != null && original.column,
|
|
source,
|
|
name
|
|
});
|
|
};
|
|
SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
|
|
var source = aSourceFile;
|
|
if (this._sourceRoot != null) {
|
|
source = util.relative(this._sourceRoot, source);
|
|
}
|
|
if (aSourceContent != null) {
|
|
if (!this._sourcesContents) {
|
|
this._sourcesContents = Object.create(null);
|
|
}
|
|
this._sourcesContents[util.toSetString(source)] = aSourceContent;
|
|
} else if (this._sourcesContents) {
|
|
delete this._sourcesContents[util.toSetString(source)];
|
|
if (Object.keys(this._sourcesContents).length === 0) {
|
|
this._sourcesContents = null;
|
|
}
|
|
}
|
|
};
|
|
SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
|
|
var sourceFile = aSourceFile;
|
|
if (aSourceFile == null) {
|
|
if (aSourceMapConsumer.file == null) {
|
|
throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + 'or the source map\'s "file" property. Both were omitted.');
|
|
}
|
|
sourceFile = aSourceMapConsumer.file;
|
|
}
|
|
var sourceRoot = this._sourceRoot;
|
|
if (sourceRoot != null) {
|
|
sourceFile = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
var newSources = new ArraySet;
|
|
var newNames = new ArraySet;
|
|
this._mappings.unsortedForEach(function(mapping) {
|
|
if (mapping.source === sourceFile && mapping.originalLine != null) {
|
|
var original = aSourceMapConsumer.originalPositionFor({
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
});
|
|
if (original.source != null) {
|
|
mapping.source = original.source;
|
|
if (aSourceMapPath != null) {
|
|
mapping.source = util.join(aSourceMapPath, mapping.source);
|
|
}
|
|
if (sourceRoot != null) {
|
|
mapping.source = util.relative(sourceRoot, mapping.source);
|
|
}
|
|
mapping.originalLine = original.line;
|
|
mapping.originalColumn = original.column;
|
|
if (original.name != null) {
|
|
mapping.name = original.name;
|
|
}
|
|
}
|
|
}
|
|
var source = mapping.source;
|
|
if (source != null && !newSources.has(source)) {
|
|
newSources.add(source);
|
|
}
|
|
var name = mapping.name;
|
|
if (name != null && !newNames.has(name)) {
|
|
newNames.add(name);
|
|
}
|
|
}, this);
|
|
this._sources = newSources;
|
|
this._names = newNames;
|
|
aSourceMapConsumer.sources.forEach(function(sourceFile2) {
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
|
|
if (content != null) {
|
|
if (aSourceMapPath != null) {
|
|
sourceFile2 = util.join(aSourceMapPath, sourceFile2);
|
|
}
|
|
if (sourceRoot != null) {
|
|
sourceFile2 = util.relative(sourceRoot, sourceFile2);
|
|
}
|
|
this.setSourceContent(sourceFile2, content);
|
|
}
|
|
}, this);
|
|
};
|
|
SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
|
|
if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
|
|
var message = "original.line and original.column are not numbers -- you probably meant to omit " + "the original mapping entirely and only map the generated position. If so, pass " + "null for the original mapping instead of an object with empty or null values.";
|
|
if (this._ignoreInvalidMapping) {
|
|
if (typeof console !== "undefined" && console.warn) {
|
|
console.warn(message);
|
|
}
|
|
return false;
|
|
} else {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
|
|
return;
|
|
} else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
|
|
return;
|
|
} else {
|
|
var message = "Invalid mapping: " + JSON.stringify({
|
|
generated: aGenerated,
|
|
source: aSource,
|
|
original: aOriginal,
|
|
name: aName
|
|
});
|
|
if (this._ignoreInvalidMapping) {
|
|
if (typeof console !== "undefined" && console.warn) {
|
|
console.warn(message);
|
|
}
|
|
return false;
|
|
} else {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
};
|
|
SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
|
|
var previousGeneratedColumn = 0;
|
|
var previousGeneratedLine = 1;
|
|
var previousOriginalColumn = 0;
|
|
var previousOriginalLine = 0;
|
|
var previousName = 0;
|
|
var previousSource = 0;
|
|
var result = "";
|
|
var next;
|
|
var mapping;
|
|
var nameIdx;
|
|
var sourceIdx;
|
|
var mappings = this._mappings.toArray();
|
|
for (var i = 0, len = mappings.length;i < len; i++) {
|
|
mapping = mappings[i];
|
|
next = "";
|
|
if (mapping.generatedLine !== previousGeneratedLine) {
|
|
previousGeneratedColumn = 0;
|
|
while (mapping.generatedLine !== previousGeneratedLine) {
|
|
next += ";";
|
|
previousGeneratedLine++;
|
|
}
|
|
} else {
|
|
if (i > 0) {
|
|
if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
|
|
continue;
|
|
}
|
|
next += ",";
|
|
}
|
|
}
|
|
next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
|
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (mapping.source != null) {
|
|
sourceIdx = this._sources.indexOf(mapping.source);
|
|
next += base64VLQ.encode(sourceIdx - previousSource);
|
|
previousSource = sourceIdx;
|
|
next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
|
|
previousOriginalLine = mapping.originalLine - 1;
|
|
next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
|
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (mapping.name != null) {
|
|
nameIdx = this._names.indexOf(mapping.name);
|
|
next += base64VLQ.encode(nameIdx - previousName);
|
|
previousName = nameIdx;
|
|
}
|
|
}
|
|
result += next;
|
|
}
|
|
return result;
|
|
};
|
|
SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
|
|
return aSources.map(function(source) {
|
|
if (!this._sourcesContents) {
|
|
return null;
|
|
}
|
|
if (aSourceRoot != null) {
|
|
source = util.relative(aSourceRoot, source);
|
|
}
|
|
var key = util.toSetString(source);
|
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
|
|
}, this);
|
|
};
|
|
SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
|
|
var map = {
|
|
version: this._version,
|
|
sources: this._sources.toArray(),
|
|
names: this._names.toArray(),
|
|
mappings: this._serializeMappings()
|
|
};
|
|
if (this._file != null) {
|
|
map.file = this._file;
|
|
}
|
|
if (this._sourceRoot != null) {
|
|
map.sourceRoot = this._sourceRoot;
|
|
}
|
|
if (this._sourcesContents) {
|
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
|
|
}
|
|
return map;
|
|
};
|
|
SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
|
|
return JSON.stringify(this.toJSON());
|
|
};
|
|
exports.SourceMapGenerator = SourceMapGenerator;
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/binary-search.js
|
|
var require_binary_search = __commonJS((exports) => {
|
|
exports.GREATEST_LOWER_BOUND = 1;
|
|
exports.LEAST_UPPER_BOUND = 2;
|
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
|
|
var mid = Math.floor((aHigh - aLow) / 2) + aLow;
|
|
var cmp = aCompare(aNeedle, aHaystack[mid], true);
|
|
if (cmp === 0) {
|
|
return mid;
|
|
} else if (cmp > 0) {
|
|
if (aHigh - mid > 1) {
|
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
|
|
}
|
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
|
return aHigh < aHaystack.length ? aHigh : -1;
|
|
} else {
|
|
return mid;
|
|
}
|
|
} else {
|
|
if (mid - aLow > 1) {
|
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
|
|
}
|
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
|
return mid;
|
|
} else {
|
|
return aLow < 0 ? -1 : aLow;
|
|
}
|
|
}
|
|
}
|
|
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
|
|
if (aHaystack.length === 0) {
|
|
return -1;
|
|
}
|
|
var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
|
|
if (index < 0) {
|
|
return -1;
|
|
}
|
|
while (index - 1 >= 0) {
|
|
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
|
|
break;
|
|
}
|
|
--index;
|
|
}
|
|
return index;
|
|
};
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/quick-sort.js
|
|
var require_quick_sort = __commonJS((exports) => {
|
|
function SortTemplate(comparator) {
|
|
function swap(ary, x, y) {
|
|
var temp = ary[x];
|
|
ary[x] = ary[y];
|
|
ary[y] = temp;
|
|
}
|
|
function randomIntInRange(low, high) {
|
|
return Math.round(low + Math.random() * (high - low));
|
|
}
|
|
function doQuickSort(ary, comparator2, p, r) {
|
|
if (p < r) {
|
|
var pivotIndex = randomIntInRange(p, r);
|
|
var i = p - 1;
|
|
swap(ary, pivotIndex, r);
|
|
var pivot = ary[r];
|
|
for (var j = p;j < r; j++) {
|
|
if (comparator2(ary[j], pivot, false) <= 0) {
|
|
i += 1;
|
|
swap(ary, i, j);
|
|
}
|
|
}
|
|
swap(ary, i + 1, j);
|
|
var q = i + 1;
|
|
doQuickSort(ary, comparator2, p, q - 1);
|
|
doQuickSort(ary, comparator2, q + 1, r);
|
|
}
|
|
}
|
|
return doQuickSort;
|
|
}
|
|
function cloneSort(comparator) {
|
|
let template = SortTemplate.toString();
|
|
let templateFn = new Function(`return ${template}`)();
|
|
return templateFn(comparator);
|
|
}
|
|
var sortCache = new WeakMap;
|
|
exports.quickSort = function(ary, comparator, start = 0) {
|
|
let doQuickSort = sortCache.get(comparator);
|
|
if (doQuickSort === undefined) {
|
|
doQuickSort = cloneSort(comparator);
|
|
sortCache.set(comparator, doQuickSort);
|
|
}
|
|
doQuickSort(ary, comparator, start, ary.length - 1);
|
|
};
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/source-map-consumer.js
|
|
var require_source_map_consumer = __commonJS((exports) => {
|
|
var util = require_util2();
|
|
var binarySearch = require_binary_search();
|
|
var ArraySet = require_array_set().ArraySet;
|
|
var base64VLQ = require_base64_vlq();
|
|
var quickSort = require_quick_sort().quickSort;
|
|
function SourceMapConsumer(aSourceMap, aSourceMapURL) {
|
|
var sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
|
|
}
|
|
SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
|
|
return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
|
|
};
|
|
SourceMapConsumer.prototype._version = 3;
|
|
SourceMapConsumer.prototype.__generatedMappings = null;
|
|
Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!this.__generatedMappings) {
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
}
|
|
return this.__generatedMappings;
|
|
}
|
|
});
|
|
SourceMapConsumer.prototype.__originalMappings = null;
|
|
Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!this.__originalMappings) {
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
}
|
|
return this.__originalMappings;
|
|
}
|
|
});
|
|
SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
|
|
var c = aStr.charAt(index);
|
|
return c === ";" || c === ",";
|
|
};
|
|
SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
|
throw new Error("Subclasses must implement _parseMappings");
|
|
};
|
|
SourceMapConsumer.GENERATED_ORDER = 1;
|
|
SourceMapConsumer.ORIGINAL_ORDER = 2;
|
|
SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
|
|
SourceMapConsumer.LEAST_UPPER_BOUND = 2;
|
|
SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
|
|
var context = aContext || null;
|
|
var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
|
|
var mappings;
|
|
switch (order) {
|
|
case SourceMapConsumer.GENERATED_ORDER:
|
|
mappings = this._generatedMappings;
|
|
break;
|
|
case SourceMapConsumer.ORIGINAL_ORDER:
|
|
mappings = this._originalMappings;
|
|
break;
|
|
default:
|
|
throw new Error("Unknown order of iteration.");
|
|
}
|
|
var sourceRoot = this.sourceRoot;
|
|
var boundCallback = aCallback.bind(context);
|
|
var names = this._names;
|
|
var sources = this._sources;
|
|
var sourceMapURL = this._sourceMapURL;
|
|
for (var i = 0, n = mappings.length;i < n; i++) {
|
|
var mapping = mappings[i];
|
|
var source = mapping.source === null ? null : sources.at(mapping.source);
|
|
if (source !== null) {
|
|
source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
|
|
}
|
|
boundCallback({
|
|
source,
|
|
generatedLine: mapping.generatedLine,
|
|
generatedColumn: mapping.generatedColumn,
|
|
originalLine: mapping.originalLine,
|
|
originalColumn: mapping.originalColumn,
|
|
name: mapping.name === null ? null : names.at(mapping.name)
|
|
});
|
|
}
|
|
};
|
|
SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
|
|
var line = util.getArg(aArgs, "line");
|
|
var needle = {
|
|
source: util.getArg(aArgs, "source"),
|
|
originalLine: line,
|
|
originalColumn: util.getArg(aArgs, "column", 0)
|
|
};
|
|
needle.source = this._findSourceIndex(needle.source);
|
|
if (needle.source < 0) {
|
|
return [];
|
|
}
|
|
var mappings = [];
|
|
var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
|
|
if (index >= 0) {
|
|
var mapping = this._originalMappings[index];
|
|
if (aArgs.column === undefined) {
|
|
var originalLine = mapping.originalLine;
|
|
while (mapping && mapping.originalLine === originalLine) {
|
|
mappings.push({
|
|
line: util.getArg(mapping, "generatedLine", null),
|
|
column: util.getArg(mapping, "generatedColumn", null),
|
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
|
|
});
|
|
mapping = this._originalMappings[++index];
|
|
}
|
|
} else {
|
|
var originalColumn = mapping.originalColumn;
|
|
while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
|
|
mappings.push({
|
|
line: util.getArg(mapping, "generatedLine", null),
|
|
column: util.getArg(mapping, "generatedColumn", null),
|
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
|
|
});
|
|
mapping = this._originalMappings[++index];
|
|
}
|
|
}
|
|
}
|
|
return mappings;
|
|
};
|
|
exports.SourceMapConsumer = SourceMapConsumer;
|
|
function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
|
|
var sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
var version = util.getArg(sourceMap, "version");
|
|
var sources = util.getArg(sourceMap, "sources");
|
|
var names = util.getArg(sourceMap, "names", []);
|
|
var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
|
|
var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
|
|
var mappings = util.getArg(sourceMap, "mappings");
|
|
var file = util.getArg(sourceMap, "file", null);
|
|
if (version != this._version) {
|
|
throw new Error("Unsupported version: " + version);
|
|
}
|
|
if (sourceRoot) {
|
|
sourceRoot = util.normalize(sourceRoot);
|
|
}
|
|
sources = sources.map(String).map(util.normalize).map(function(source) {
|
|
return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
|
|
});
|
|
this._names = ArraySet.fromArray(names.map(String), true);
|
|
this._sources = ArraySet.fromArray(sources, true);
|
|
this._absoluteSources = this._sources.toArray().map(function(s) {
|
|
return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
|
|
});
|
|
this.sourceRoot = sourceRoot;
|
|
this.sourcesContent = sourcesContent;
|
|
this._mappings = mappings;
|
|
this._sourceMapURL = aSourceMapURL;
|
|
this.file = file;
|
|
}
|
|
BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
|
|
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
|
|
BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
|
|
var relativeSource = aSource;
|
|
if (this.sourceRoot != null) {
|
|
relativeSource = util.relative(this.sourceRoot, relativeSource);
|
|
}
|
|
if (this._sources.has(relativeSource)) {
|
|
return this._sources.indexOf(relativeSource);
|
|
}
|
|
var i;
|
|
for (i = 0;i < this._absoluteSources.length; ++i) {
|
|
if (this._absoluteSources[i] == aSource) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
|
|
var smc = Object.create(BasicSourceMapConsumer.prototype);
|
|
var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
|
|
var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
|
|
smc.sourceRoot = aSourceMap._sourceRoot;
|
|
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
|
|
smc.file = aSourceMap._file;
|
|
smc._sourceMapURL = aSourceMapURL;
|
|
smc._absoluteSources = smc._sources.toArray().map(function(s) {
|
|
return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
|
|
});
|
|
var generatedMappings = aSourceMap._mappings.toArray().slice();
|
|
var destGeneratedMappings = smc.__generatedMappings = [];
|
|
var destOriginalMappings = smc.__originalMappings = [];
|
|
for (var i = 0, length = generatedMappings.length;i < length; i++) {
|
|
var srcMapping = generatedMappings[i];
|
|
var destMapping = new Mapping;
|
|
destMapping.generatedLine = srcMapping.generatedLine;
|
|
destMapping.generatedColumn = srcMapping.generatedColumn;
|
|
if (srcMapping.source) {
|
|
destMapping.source = sources.indexOf(srcMapping.source);
|
|
destMapping.originalLine = srcMapping.originalLine;
|
|
destMapping.originalColumn = srcMapping.originalColumn;
|
|
if (srcMapping.name) {
|
|
destMapping.name = names.indexOf(srcMapping.name);
|
|
}
|
|
destOriginalMappings.push(destMapping);
|
|
}
|
|
destGeneratedMappings.push(destMapping);
|
|
}
|
|
quickSort(smc.__originalMappings, util.compareByOriginalPositions);
|
|
return smc;
|
|
};
|
|
BasicSourceMapConsumer.prototype._version = 3;
|
|
Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
|
|
get: function() {
|
|
return this._absoluteSources.slice();
|
|
}
|
|
});
|
|
function Mapping() {
|
|
this.generatedLine = 0;
|
|
this.generatedColumn = 0;
|
|
this.source = null;
|
|
this.originalLine = null;
|
|
this.originalColumn = null;
|
|
this.name = null;
|
|
}
|
|
var compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
|
|
function sortGenerated(array, start) {
|
|
let l = array.length;
|
|
let n = array.length - start;
|
|
if (n <= 1) {
|
|
return;
|
|
} else if (n == 2) {
|
|
let a = array[start];
|
|
let b = array[start + 1];
|
|
if (compareGenerated(a, b) > 0) {
|
|
array[start] = b;
|
|
array[start + 1] = a;
|
|
}
|
|
} else if (n < 20) {
|
|
for (let i = start;i < l; i++) {
|
|
for (let j = i;j > start; j--) {
|
|
let a = array[j - 1];
|
|
let b = array[j];
|
|
if (compareGenerated(a, b) <= 0) {
|
|
break;
|
|
}
|
|
array[j - 1] = b;
|
|
array[j] = a;
|
|
}
|
|
}
|
|
} else {
|
|
quickSort(array, compareGenerated, start);
|
|
}
|
|
}
|
|
BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
|
var generatedLine = 1;
|
|
var previousGeneratedColumn = 0;
|
|
var previousOriginalLine = 0;
|
|
var previousOriginalColumn = 0;
|
|
var previousSource = 0;
|
|
var previousName = 0;
|
|
var length = aStr.length;
|
|
var index = 0;
|
|
var cachedSegments = {};
|
|
var temp = {};
|
|
var originalMappings = [];
|
|
var generatedMappings = [];
|
|
var mapping, str, segment, end, value;
|
|
let subarrayStart = 0;
|
|
while (index < length) {
|
|
if (aStr.charAt(index) === ";") {
|
|
generatedLine++;
|
|
index++;
|
|
previousGeneratedColumn = 0;
|
|
sortGenerated(generatedMappings, subarrayStart);
|
|
subarrayStart = generatedMappings.length;
|
|
} else if (aStr.charAt(index) === ",") {
|
|
index++;
|
|
} else {
|
|
mapping = new Mapping;
|
|
mapping.generatedLine = generatedLine;
|
|
for (end = index;end < length; end++) {
|
|
if (this._charIsMappingSeparator(aStr, end)) {
|
|
break;
|
|
}
|
|
}
|
|
str = aStr.slice(index, end);
|
|
segment = [];
|
|
while (index < end) {
|
|
base64VLQ.decode(aStr, index, temp);
|
|
value = temp.value;
|
|
index = temp.rest;
|
|
segment.push(value);
|
|
}
|
|
if (segment.length === 2) {
|
|
throw new Error("Found a source, but no line and column");
|
|
}
|
|
if (segment.length === 3) {
|
|
throw new Error("Found a source and line, but no column");
|
|
}
|
|
mapping.generatedColumn = previousGeneratedColumn + segment[0];
|
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (segment.length > 1) {
|
|
mapping.source = previousSource + segment[1];
|
|
previousSource += segment[1];
|
|
mapping.originalLine = previousOriginalLine + segment[2];
|
|
previousOriginalLine = mapping.originalLine;
|
|
mapping.originalLine += 1;
|
|
mapping.originalColumn = previousOriginalColumn + segment[3];
|
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (segment.length > 4) {
|
|
mapping.name = previousName + segment[4];
|
|
previousName += segment[4];
|
|
}
|
|
}
|
|
generatedMappings.push(mapping);
|
|
if (typeof mapping.originalLine === "number") {
|
|
let currentSource = mapping.source;
|
|
while (originalMappings.length <= currentSource) {
|
|
originalMappings.push(null);
|
|
}
|
|
if (originalMappings[currentSource] === null) {
|
|
originalMappings[currentSource] = [];
|
|
}
|
|
originalMappings[currentSource].push(mapping);
|
|
}
|
|
}
|
|
}
|
|
sortGenerated(generatedMappings, subarrayStart);
|
|
this.__generatedMappings = generatedMappings;
|
|
for (var i = 0;i < originalMappings.length; i++) {
|
|
if (originalMappings[i] != null) {
|
|
quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
|
|
}
|
|
}
|
|
this.__originalMappings = [].concat(...originalMappings);
|
|
};
|
|
BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
|
|
if (aNeedle[aLineName] <= 0) {
|
|
throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
|
|
}
|
|
if (aNeedle[aColumnName] < 0) {
|
|
throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
|
|
}
|
|
return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
|
|
};
|
|
BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
|
|
for (var index = 0;index < this._generatedMappings.length; ++index) {
|
|
var mapping = this._generatedMappings[index];
|
|
if (index + 1 < this._generatedMappings.length) {
|
|
var nextMapping = this._generatedMappings[index + 1];
|
|
if (mapping.generatedLine === nextMapping.generatedLine) {
|
|
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
|
|
continue;
|
|
}
|
|
}
|
|
mapping.lastGeneratedColumn = Infinity;
|
|
}
|
|
};
|
|
BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
|
|
var needle = {
|
|
generatedLine: util.getArg(aArgs, "line"),
|
|
generatedColumn: util.getArg(aArgs, "column")
|
|
};
|
|
var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
|
|
if (index >= 0) {
|
|
var mapping = this._generatedMappings[index];
|
|
if (mapping.generatedLine === needle.generatedLine) {
|
|
var source = util.getArg(mapping, "source", null);
|
|
if (source !== null) {
|
|
source = this._sources.at(source);
|
|
source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
|
|
}
|
|
var name = util.getArg(mapping, "name", null);
|
|
if (name !== null) {
|
|
name = this._names.at(name);
|
|
}
|
|
return {
|
|
source,
|
|
line: util.getArg(mapping, "originalLine", null),
|
|
column: util.getArg(mapping, "originalColumn", null),
|
|
name
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
source: null,
|
|
line: null,
|
|
column: null,
|
|
name: null
|
|
};
|
|
};
|
|
BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
|
|
if (!this.sourcesContent) {
|
|
return false;
|
|
}
|
|
return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
|
|
return sc == null;
|
|
});
|
|
};
|
|
BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
|
if (!this.sourcesContent) {
|
|
return null;
|
|
}
|
|
var index = this._findSourceIndex(aSource);
|
|
if (index >= 0) {
|
|
return this.sourcesContent[index];
|
|
}
|
|
var relativeSource = aSource;
|
|
if (this.sourceRoot != null) {
|
|
relativeSource = util.relative(this.sourceRoot, relativeSource);
|
|
}
|
|
var url;
|
|
if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
|
|
var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
|
|
if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
|
|
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
|
|
}
|
|
if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
|
|
return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
|
|
}
|
|
}
|
|
if (nullOnMissing) {
|
|
return null;
|
|
} else {
|
|
throw new Error('"' + relativeSource + '" is not in the SourceMap.');
|
|
}
|
|
};
|
|
BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
|
|
var source = util.getArg(aArgs, "source");
|
|
source = this._findSourceIndex(source);
|
|
if (source < 0) {
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
}
|
|
var needle = {
|
|
source,
|
|
originalLine: util.getArg(aArgs, "line"),
|
|
originalColumn: util.getArg(aArgs, "column")
|
|
};
|
|
var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
|
|
if (index >= 0) {
|
|
var mapping = this._originalMappings[index];
|
|
if (mapping.source === needle.source) {
|
|
return {
|
|
line: util.getArg(mapping, "generatedLine", null),
|
|
column: util.getArg(mapping, "generatedColumn", null),
|
|
lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
};
|
|
exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
|
|
function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
|
|
var sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
var version = util.getArg(sourceMap, "version");
|
|
var sections = util.getArg(sourceMap, "sections");
|
|
if (version != this._version) {
|
|
throw new Error("Unsupported version: " + version);
|
|
}
|
|
this._sources = new ArraySet;
|
|
this._names = new ArraySet;
|
|
var lastOffset = {
|
|
line: -1,
|
|
column: 0
|
|
};
|
|
this._sections = sections.map(function(s) {
|
|
if (s.url) {
|
|
throw new Error("Support for url field in sections not implemented.");
|
|
}
|
|
var offset = util.getArg(s, "offset");
|
|
var offsetLine = util.getArg(offset, "line");
|
|
var offsetColumn = util.getArg(offset, "column");
|
|
if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
|
|
throw new Error("Section offsets must be ordered and non-overlapping.");
|
|
}
|
|
lastOffset = offset;
|
|
return {
|
|
generatedOffset: {
|
|
generatedLine: offsetLine + 1,
|
|
generatedColumn: offsetColumn + 1
|
|
},
|
|
consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
|
|
};
|
|
});
|
|
}
|
|
IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
|
|
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
|
|
IndexedSourceMapConsumer.prototype._version = 3;
|
|
Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
|
|
get: function() {
|
|
var sources = [];
|
|
for (var i = 0;i < this._sections.length; i++) {
|
|
for (var j = 0;j < this._sections[i].consumer.sources.length; j++) {
|
|
sources.push(this._sections[i].consumer.sources[j]);
|
|
}
|
|
}
|
|
return sources;
|
|
}
|
|
});
|
|
IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
|
|
var needle = {
|
|
generatedLine: util.getArg(aArgs, "line"),
|
|
generatedColumn: util.getArg(aArgs, "column")
|
|
};
|
|
var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) {
|
|
var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
|
|
});
|
|
var section = this._sections[sectionIndex];
|
|
if (!section) {
|
|
return {
|
|
source: null,
|
|
line: null,
|
|
column: null,
|
|
name: null
|
|
};
|
|
}
|
|
return section.consumer.originalPositionFor({
|
|
line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
|
|
column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
|
|
bias: aArgs.bias
|
|
});
|
|
};
|
|
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
|
|
return this._sections.every(function(s) {
|
|
return s.consumer.hasContentsOfAllSources();
|
|
});
|
|
};
|
|
IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
|
for (var i = 0;i < this._sections.length; i++) {
|
|
var section = this._sections[i];
|
|
var content = section.consumer.sourceContentFor(aSource, true);
|
|
if (content || content === "") {
|
|
return content;
|
|
}
|
|
}
|
|
if (nullOnMissing) {
|
|
return null;
|
|
} else {
|
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
|
}
|
|
};
|
|
IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
|
|
for (var i = 0;i < this._sections.length; i++) {
|
|
var section = this._sections[i];
|
|
if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
|
|
continue;
|
|
}
|
|
var generatedPosition = section.consumer.generatedPositionFor(aArgs);
|
|
if (generatedPosition) {
|
|
var ret = {
|
|
line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
|
|
column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
|
|
};
|
|
return ret;
|
|
}
|
|
}
|
|
return {
|
|
line: null,
|
|
column: null
|
|
};
|
|
};
|
|
IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
|
this.__generatedMappings = [];
|
|
this.__originalMappings = [];
|
|
for (var i = 0;i < this._sections.length; i++) {
|
|
var section = this._sections[i];
|
|
var sectionMappings = section.consumer._generatedMappings;
|
|
for (var j = 0;j < sectionMappings.length; j++) {
|
|
var mapping = sectionMappings[j];
|
|
var source = section.consumer._sources.at(mapping.source);
|
|
if (source !== null) {
|
|
source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
|
|
}
|
|
this._sources.add(source);
|
|
source = this._sources.indexOf(source);
|
|
var name = null;
|
|
if (mapping.name) {
|
|
name = section.consumer._names.at(mapping.name);
|
|
this._names.add(name);
|
|
name = this._names.indexOf(name);
|
|
}
|
|
var adjustedMapping = {
|
|
source,
|
|
generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
|
|
generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
|
|
originalLine: mapping.originalLine,
|
|
originalColumn: mapping.originalColumn,
|
|
name
|
|
};
|
|
this.__generatedMappings.push(adjustedMapping);
|
|
if (typeof adjustedMapping.originalLine === "number") {
|
|
this.__originalMappings.push(adjustedMapping);
|
|
}
|
|
}
|
|
}
|
|
quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
|
|
quickSort(this.__originalMappings, util.compareByOriginalPositions);
|
|
};
|
|
exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
|
|
});
|
|
|
|
// node_modules/source-map-js/lib/source-node.js
|
|
var require_source_node = __commonJS((exports) => {
|
|
var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
|
|
var util = require_util2();
|
|
var REGEX_NEWLINE = /(\r?\n)/;
|
|
var NEWLINE_CODE = 10;
|
|
var isSourceNode = "$$$isSourceNode$$$";
|
|
function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
|
|
this.children = [];
|
|
this.sourceContents = {};
|
|
this.line = aLine == null ? null : aLine;
|
|
this.column = aColumn == null ? null : aColumn;
|
|
this.source = aSource == null ? null : aSource;
|
|
this.name = aName == null ? null : aName;
|
|
this[isSourceNode] = true;
|
|
if (aChunks != null)
|
|
this.add(aChunks);
|
|
}
|
|
SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
|
|
var node = new SourceNode;
|
|
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
|
|
var remainingLinesIndex = 0;
|
|
var shiftNextLine = function() {
|
|
var lineContents = getNextLine();
|
|
var newLine = getNextLine() || "";
|
|
return lineContents + newLine;
|
|
function getNextLine() {
|
|
return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : undefined;
|
|
}
|
|
};
|
|
var lastGeneratedLine = 1, lastGeneratedColumn = 0;
|
|
var lastMapping = null;
|
|
aSourceMapConsumer.eachMapping(function(mapping) {
|
|
if (lastMapping !== null) {
|
|
if (lastGeneratedLine < mapping.generatedLine) {
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
lastGeneratedLine++;
|
|
lastGeneratedColumn = 0;
|
|
} else {
|
|
var nextLine = remainingLines[remainingLinesIndex] || "";
|
|
var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
|
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
addMappingWithCode(lastMapping, code);
|
|
lastMapping = mapping;
|
|
return;
|
|
}
|
|
}
|
|
while (lastGeneratedLine < mapping.generatedLine) {
|
|
node.add(shiftNextLine());
|
|
lastGeneratedLine++;
|
|
}
|
|
if (lastGeneratedColumn < mapping.generatedColumn) {
|
|
var nextLine = remainingLines[remainingLinesIndex] || "";
|
|
node.add(nextLine.substr(0, mapping.generatedColumn));
|
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
}
|
|
lastMapping = mapping;
|
|
}, this);
|
|
if (remainingLinesIndex < remainingLines.length) {
|
|
if (lastMapping) {
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
}
|
|
node.add(remainingLines.splice(remainingLinesIndex).join(""));
|
|
}
|
|
aSourceMapConsumer.sources.forEach(function(sourceFile) {
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
if (aRelativePath != null) {
|
|
sourceFile = util.join(aRelativePath, sourceFile);
|
|
}
|
|
node.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
return node;
|
|
function addMappingWithCode(mapping, code) {
|
|
if (mapping === null || mapping.source === undefined) {
|
|
node.add(code);
|
|
} else {
|
|
var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
|
|
node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
|
|
}
|
|
}
|
|
};
|
|
SourceNode.prototype.add = function SourceNode_add(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
aChunk.forEach(function(chunk) {
|
|
this.add(chunk);
|
|
}, this);
|
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
if (aChunk) {
|
|
this.children.push(aChunk);
|
|
}
|
|
} else {
|
|
throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
|
|
}
|
|
return this;
|
|
};
|
|
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
for (var i = aChunk.length - 1;i >= 0; i--) {
|
|
this.prepend(aChunk[i]);
|
|
}
|
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
this.children.unshift(aChunk);
|
|
} else {
|
|
throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
|
|
}
|
|
return this;
|
|
};
|
|
SourceNode.prototype.walk = function SourceNode_walk(aFn) {
|
|
var chunk;
|
|
for (var i = 0, len = this.children.length;i < len; i++) {
|
|
chunk = this.children[i];
|
|
if (chunk[isSourceNode]) {
|
|
chunk.walk(aFn);
|
|
} else {
|
|
if (chunk !== "") {
|
|
aFn(chunk, {
|
|
source: this.source,
|
|
line: this.line,
|
|
column: this.column,
|
|
name: this.name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
SourceNode.prototype.join = function SourceNode_join(aSep) {
|
|
var newChildren;
|
|
var i;
|
|
var len = this.children.length;
|
|
if (len > 0) {
|
|
newChildren = [];
|
|
for (i = 0;i < len - 1; i++) {
|
|
newChildren.push(this.children[i]);
|
|
newChildren.push(aSep);
|
|
}
|
|
newChildren.push(this.children[i]);
|
|
this.children = newChildren;
|
|
}
|
|
return this;
|
|
};
|
|
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
|
|
var lastChild = this.children[this.children.length - 1];
|
|
if (lastChild[isSourceNode]) {
|
|
lastChild.replaceRight(aPattern, aReplacement);
|
|
} else if (typeof lastChild === "string") {
|
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
|
|
} else {
|
|
this.children.push("".replace(aPattern, aReplacement));
|
|
}
|
|
return this;
|
|
};
|
|
SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
|
|
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
|
|
};
|
|
SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
|
|
for (var i = 0, len = this.children.length;i < len; i++) {
|
|
if (this.children[i][isSourceNode]) {
|
|
this.children[i].walkSourceContents(aFn);
|
|
}
|
|
}
|
|
var sources = Object.keys(this.sourceContents);
|
|
for (var i = 0, len = sources.length;i < len; i++) {
|
|
aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
|
|
}
|
|
};
|
|
SourceNode.prototype.toString = function SourceNode_toString() {
|
|
var str = "";
|
|
this.walk(function(chunk) {
|
|
str += chunk;
|
|
});
|
|
return str;
|
|
};
|
|
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
|
|
var generated = {
|
|
code: "",
|
|
line: 1,
|
|
column: 0
|
|
};
|
|
var map = new SourceMapGenerator(aArgs);
|
|
var sourceMappingActive = false;
|
|
var lastOriginalSource = null;
|
|
var lastOriginalLine = null;
|
|
var lastOriginalColumn = null;
|
|
var lastOriginalName = null;
|
|
this.walk(function(chunk, original) {
|
|
generated.code += chunk;
|
|
if (original.source !== null && original.line !== null && original.column !== null) {
|
|
if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
lastOriginalSource = original.source;
|
|
lastOriginalLine = original.line;
|
|
lastOriginalColumn = original.column;
|
|
lastOriginalName = original.name;
|
|
sourceMappingActive = true;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
}
|
|
});
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
}
|
|
for (var idx = 0, length = chunk.length;idx < length; idx++) {
|
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
|
|
generated.line++;
|
|
generated.column = 0;
|
|
if (idx + 1 === length) {
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
} else {
|
|
generated.column++;
|
|
}
|
|
}
|
|
});
|
|
this.walkSourceContents(function(sourceFile, sourceContent) {
|
|
map.setSourceContent(sourceFile, sourceContent);
|
|
});
|
|
return { code: generated.code, map };
|
|
};
|
|
exports.SourceNode = SourceNode;
|
|
});
|
|
|
|
// node_modules/source-map-js/source-map.js
|
|
var require_source_map = __commonJS((exports) => {
|
|
exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
|
|
exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
|
|
exports.SourceNode = require_source_node().SourceNode;
|
|
});
|
|
|
|
// node_modules/postcss/lib/previous-map.js
|
|
var require_previous_map = __commonJS((exports, module) => {
|
|
var { existsSync, readFileSync } = __require("fs");
|
|
var { dirname, join } = __require("path");
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
function fromBase64(str) {
|
|
if (Buffer) {
|
|
return Buffer.from(str, "base64").toString();
|
|
} else {
|
|
return window.atob(str);
|
|
}
|
|
}
|
|
|
|
class PreviousMap {
|
|
constructor(css, opts) {
|
|
if (opts.map === false)
|
|
return;
|
|
this.loadAnnotation(css);
|
|
this.inline = this.startWith(this.annotation, "data:");
|
|
let prev = opts.map ? opts.map.prev : undefined;
|
|
let text = this.loadMap(opts.from, prev);
|
|
if (!this.mapFile && opts.from) {
|
|
this.mapFile = opts.from;
|
|
}
|
|
if (this.mapFile)
|
|
this.root = dirname(this.mapFile);
|
|
if (text)
|
|
this.text = text;
|
|
}
|
|
consumer() {
|
|
if (!this.consumerCache) {
|
|
this.consumerCache = new SourceMapConsumer(this.text);
|
|
}
|
|
return this.consumerCache;
|
|
}
|
|
decodeInline(text) {
|
|
let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
|
|
let baseUri = /^data:application\/json;base64,/;
|
|
let charsetUri = /^data:application\/json;charset=utf-?8,/;
|
|
let uri = /^data:application\/json,/;
|
|
let uriMatch = text.match(charsetUri) || text.match(uri);
|
|
if (uriMatch) {
|
|
return decodeURIComponent(text.substr(uriMatch[0].length));
|
|
}
|
|
let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
|
|
if (baseUriMatch) {
|
|
return fromBase64(text.substr(baseUriMatch[0].length));
|
|
}
|
|
let encoding = text.match(/data:application\/json;([^,]+),/)[1];
|
|
throw new Error("Unsupported source map encoding " + encoding);
|
|
}
|
|
getAnnotationURL(sourceMapString) {
|
|
return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
|
|
}
|
|
isMap(map) {
|
|
if (typeof map !== "object")
|
|
return false;
|
|
return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
|
|
}
|
|
loadAnnotation(css) {
|
|
let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
|
|
if (!comments)
|
|
return;
|
|
let start = css.lastIndexOf(comments.pop());
|
|
let end = css.indexOf("*/", start);
|
|
if (start > -1 && end > -1) {
|
|
this.annotation = this.getAnnotationURL(css.substring(start, end));
|
|
}
|
|
}
|
|
loadFile(path) {
|
|
this.root = dirname(path);
|
|
if (existsSync(path)) {
|
|
this.mapFile = path;
|
|
return readFileSync(path, "utf-8").toString().trim();
|
|
}
|
|
}
|
|
loadMap(file, prev) {
|
|
if (prev === false)
|
|
return false;
|
|
if (prev) {
|
|
if (typeof prev === "string") {
|
|
return prev;
|
|
} else if (typeof prev === "function") {
|
|
let prevPath = prev(file);
|
|
if (prevPath) {
|
|
let map = this.loadFile(prevPath);
|
|
if (!map) {
|
|
throw new Error("Unable to load previous source map: " + prevPath.toString());
|
|
}
|
|
return map;
|
|
}
|
|
} else if (prev instanceof SourceMapConsumer) {
|
|
return SourceMapGenerator.fromSourceMap(prev).toString();
|
|
} else if (prev instanceof SourceMapGenerator) {
|
|
return prev.toString();
|
|
} else if (this.isMap(prev)) {
|
|
return JSON.stringify(prev);
|
|
} else {
|
|
throw new Error("Unsupported previous source map format: " + prev.toString());
|
|
}
|
|
} else if (this.inline) {
|
|
return this.decodeInline(this.annotation);
|
|
} else if (this.annotation) {
|
|
let map = this.annotation;
|
|
if (file)
|
|
map = join(dirname(file), map);
|
|
return this.loadFile(map);
|
|
}
|
|
}
|
|
startWith(string, start) {
|
|
if (!string)
|
|
return false;
|
|
return string.substr(0, start.length) === start;
|
|
}
|
|
withContent() {
|
|
return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
|
|
}
|
|
}
|
|
module.exports = PreviousMap;
|
|
PreviousMap.default = PreviousMap;
|
|
});
|
|
|
|
// node_modules/postcss/lib/input.js
|
|
var require_input = __commonJS((exports, module) => {
|
|
var { nanoid } = require_non_secure();
|
|
var { isAbsolute, resolve } = __require("path");
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
var { fileURLToPath, pathToFileURL } = __require("url");
|
|
var CssSyntaxError = require_css_syntax_error();
|
|
var PreviousMap = require_previous_map();
|
|
var terminalHighlight = require_terminal_highlight();
|
|
var fromOffsetCache = Symbol("fromOffsetCache");
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(resolve && isAbsolute);
|
|
|
|
class Input {
|
|
constructor(css, opts = {}) {
|
|
if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
|
|
throw new Error(`PostCSS received ${css} instead of CSS string`);
|
|
}
|
|
this.css = css.toString();
|
|
if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
|
|
this.hasBOM = true;
|
|
this.css = this.css.slice(1);
|
|
} else {
|
|
this.hasBOM = false;
|
|
}
|
|
if (opts.from) {
|
|
if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
|
|
this.file = opts.from;
|
|
} else {
|
|
this.file = resolve(opts.from);
|
|
}
|
|
}
|
|
if (pathAvailable && sourceMapAvailable) {
|
|
let map = new PreviousMap(this.css, opts);
|
|
if (map.text) {
|
|
this.map = map;
|
|
let file = map.consumer().file;
|
|
if (!this.file && file)
|
|
this.file = this.mapResolve(file);
|
|
}
|
|
}
|
|
if (!this.file) {
|
|
this.id = "<input css " + nanoid(6) + ">";
|
|
}
|
|
if (this.map)
|
|
this.map.file = this.from;
|
|
}
|
|
error(message, line, column, opts = {}) {
|
|
let endColumn, endLine, result;
|
|
if (line && typeof line === "object") {
|
|
let start = line;
|
|
let end = column;
|
|
if (typeof start.offset === "number") {
|
|
let pos = this.fromOffset(start.offset);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
} else {
|
|
line = start.line;
|
|
column = start.column;
|
|
}
|
|
if (typeof end.offset === "number") {
|
|
let pos = this.fromOffset(end.offset);
|
|
endLine = pos.line;
|
|
endColumn = pos.col;
|
|
} else {
|
|
endLine = end.line;
|
|
endColumn = end.column;
|
|
}
|
|
} else if (!column) {
|
|
let pos = this.fromOffset(line);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
}
|
|
let origin = this.origin(line, column, endLine, endColumn);
|
|
if (origin) {
|
|
result = new CssSyntaxError(message, origin.endLine === undefined ? origin.line : { column: origin.column, line: origin.line }, origin.endLine === undefined ? origin.column : { column: origin.endColumn, line: origin.endLine }, origin.source, origin.file, opts.plugin);
|
|
} else {
|
|
result = new CssSyntaxError(message, endLine === undefined ? line : { column, line }, endLine === undefined ? column : { column: endColumn, line: endLine }, this.css, this.file, opts.plugin);
|
|
}
|
|
result.input = { column, endColumn, endLine, line, source: this.css };
|
|
if (this.file) {
|
|
if (pathToFileURL) {
|
|
result.input.url = pathToFileURL(this.file).toString();
|
|
}
|
|
result.input.file = this.file;
|
|
}
|
|
return result;
|
|
}
|
|
fromOffset(offset) {
|
|
let lastLine, lineToIndex;
|
|
if (!this[fromOffsetCache]) {
|
|
let lines = this.css.split("\n");
|
|
lineToIndex = new Array(lines.length);
|
|
let prevIndex = 0;
|
|
for (let i = 0, l = lines.length;i < l; i++) {
|
|
lineToIndex[i] = prevIndex;
|
|
prevIndex += lines[i].length + 1;
|
|
}
|
|
this[fromOffsetCache] = lineToIndex;
|
|
} else {
|
|
lineToIndex = this[fromOffsetCache];
|
|
}
|
|
lastLine = lineToIndex[lineToIndex.length - 1];
|
|
let min = 0;
|
|
if (offset >= lastLine) {
|
|
min = lineToIndex.length - 1;
|
|
} else {
|
|
let max = lineToIndex.length - 2;
|
|
let mid;
|
|
while (min < max) {
|
|
mid = min + (max - min >> 1);
|
|
if (offset < lineToIndex[mid]) {
|
|
max = mid - 1;
|
|
} else if (offset >= lineToIndex[mid + 1]) {
|
|
min = mid + 1;
|
|
} else {
|
|
min = mid;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
col: offset - lineToIndex[min] + 1,
|
|
line: min + 1
|
|
};
|
|
}
|
|
mapResolve(file) {
|
|
if (/^\w+:\/\//.test(file)) {
|
|
return file;
|
|
}
|
|
return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
|
|
}
|
|
origin(line, column, endLine, endColumn) {
|
|
if (!this.map)
|
|
return false;
|
|
let consumer = this.map.consumer();
|
|
let from = consumer.originalPositionFor({ column, line });
|
|
if (!from.source)
|
|
return false;
|
|
let to;
|
|
if (typeof endLine === "number") {
|
|
to = consumer.originalPositionFor({ column: endColumn, line: endLine });
|
|
}
|
|
let fromUrl;
|
|
if (isAbsolute(from.source)) {
|
|
fromUrl = pathToFileURL(from.source);
|
|
} else {
|
|
fromUrl = new URL(from.source, this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile));
|
|
}
|
|
let result = {
|
|
column: from.column,
|
|
endColumn: to && to.column,
|
|
endLine: to && to.line,
|
|
line: from.line,
|
|
url: fromUrl.toString()
|
|
};
|
|
if (fromUrl.protocol === "file:") {
|
|
if (fileURLToPath) {
|
|
result.file = fileURLToPath(fromUrl);
|
|
} else {
|
|
throw new Error(`file: protocol is not available in this PostCSS build`);
|
|
}
|
|
}
|
|
let source = consumer.sourceContentFor(from.source);
|
|
if (source)
|
|
result.source = source;
|
|
return result;
|
|
}
|
|
toJSON() {
|
|
let json = {};
|
|
for (let name of ["hasBOM", "css", "file", "id"]) {
|
|
if (this[name] != null) {
|
|
json[name] = this[name];
|
|
}
|
|
}
|
|
if (this.map) {
|
|
json.map = { ...this.map };
|
|
if (json.map.consumerCache) {
|
|
json.map.consumerCache = undefined;
|
|
}
|
|
}
|
|
return json;
|
|
}
|
|
get from() {
|
|
return this.file || this.id;
|
|
}
|
|
}
|
|
module.exports = Input;
|
|
Input.default = Input;
|
|
if (terminalHighlight && terminalHighlight.registerInput) {
|
|
terminalHighlight.registerInput(Input);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/root.js
|
|
var require_root = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
var LazyResult;
|
|
var Processor;
|
|
|
|
class Root extends Container {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "root";
|
|
if (!this.nodes)
|
|
this.nodes = [];
|
|
}
|
|
normalize(child, sample, type) {
|
|
let nodes = super.normalize(child);
|
|
if (sample) {
|
|
if (type === "prepend") {
|
|
if (this.nodes.length > 1) {
|
|
sample.raws.before = this.nodes[1].raws.before;
|
|
} else {
|
|
delete sample.raws.before;
|
|
}
|
|
} else if (this.first !== sample) {
|
|
for (let node of nodes) {
|
|
node.raws.before = sample.raws.before;
|
|
}
|
|
}
|
|
}
|
|
return nodes;
|
|
}
|
|
removeChild(child, ignore) {
|
|
let index = this.index(child);
|
|
if (!ignore && index === 0 && this.nodes.length > 1) {
|
|
this.nodes[1].raws.before = this.nodes[index].raws.before;
|
|
}
|
|
return super.removeChild(child);
|
|
}
|
|
toResult(opts = {}) {
|
|
let lazy = new LazyResult(new Processor, this, opts);
|
|
return lazy.stringify();
|
|
}
|
|
}
|
|
Root.registerLazyResult = (dependant) => {
|
|
LazyResult = dependant;
|
|
};
|
|
Root.registerProcessor = (dependant) => {
|
|
Processor = dependant;
|
|
};
|
|
module.exports = Root;
|
|
Root.default = Root;
|
|
Container.registerRoot(Root);
|
|
});
|
|
|
|
// node_modules/postcss/lib/list.js
|
|
var require_list = __commonJS((exports, module) => {
|
|
var list = {
|
|
comma(string) {
|
|
return list.split(string, [","], true);
|
|
},
|
|
space(string) {
|
|
let spaces = [" ", "\n", "\t"];
|
|
return list.split(string, spaces);
|
|
},
|
|
split(string, separators, last) {
|
|
let array = [];
|
|
let current = "";
|
|
let split = false;
|
|
let func = 0;
|
|
let inQuote = false;
|
|
let prevQuote = "";
|
|
let escape = false;
|
|
for (let letter of string) {
|
|
if (escape) {
|
|
escape = false;
|
|
} else if (letter === "\\") {
|
|
escape = true;
|
|
} else if (inQuote) {
|
|
if (letter === prevQuote) {
|
|
inQuote = false;
|
|
}
|
|
} else if (letter === '"' || letter === "'") {
|
|
inQuote = true;
|
|
prevQuote = letter;
|
|
} else if (letter === "(") {
|
|
func += 1;
|
|
} else if (letter === ")") {
|
|
if (func > 0)
|
|
func -= 1;
|
|
} else if (func === 0) {
|
|
if (separators.includes(letter))
|
|
split = true;
|
|
}
|
|
if (split) {
|
|
if (current !== "")
|
|
array.push(current.trim());
|
|
current = "";
|
|
split = false;
|
|
} else {
|
|
current += letter;
|
|
}
|
|
}
|
|
if (last || current !== "")
|
|
array.push(current.trim());
|
|
return array;
|
|
}
|
|
};
|
|
module.exports = list;
|
|
list.default = list;
|
|
});
|
|
|
|
// node_modules/postcss/lib/rule.js
|
|
var require_rule = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
var list = require_list();
|
|
|
|
class Rule extends Container {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "rule";
|
|
if (!this.nodes)
|
|
this.nodes = [];
|
|
}
|
|
get selectors() {
|
|
return list.comma(this.selector);
|
|
}
|
|
set selectors(values) {
|
|
let match = this.selector ? this.selector.match(/,\s*/) : null;
|
|
let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
|
|
this.selector = values.join(sep);
|
|
}
|
|
}
|
|
module.exports = Rule;
|
|
Rule.default = Rule;
|
|
Container.registerRule(Rule);
|
|
});
|
|
|
|
// node_modules/postcss/lib/fromJSON.js
|
|
var require_fromJSON = __commonJS((exports, module) => {
|
|
var AtRule = require_at_rule();
|
|
var Comment = require_comment();
|
|
var Declaration = require_declaration();
|
|
var Input = require_input();
|
|
var PreviousMap = require_previous_map();
|
|
var Root = require_root();
|
|
var Rule = require_rule();
|
|
function fromJSON(json, inputs) {
|
|
if (Array.isArray(json))
|
|
return json.map((n) => fromJSON(n));
|
|
let { inputs: ownInputs, ...defaults } = json;
|
|
if (ownInputs) {
|
|
inputs = [];
|
|
for (let input of ownInputs) {
|
|
let inputHydrated = { ...input, __proto__: Input.prototype };
|
|
if (inputHydrated.map) {
|
|
inputHydrated.map = {
|
|
...inputHydrated.map,
|
|
__proto__: PreviousMap.prototype
|
|
};
|
|
}
|
|
inputs.push(inputHydrated);
|
|
}
|
|
}
|
|
if (defaults.nodes) {
|
|
defaults.nodes = json.nodes.map((n) => fromJSON(n, inputs));
|
|
}
|
|
if (defaults.source) {
|
|
let { inputId, ...source } = defaults.source;
|
|
defaults.source = source;
|
|
if (inputId != null) {
|
|
defaults.source.input = inputs[inputId];
|
|
}
|
|
}
|
|
if (defaults.type === "root") {
|
|
return new Root(defaults);
|
|
} else if (defaults.type === "decl") {
|
|
return new Declaration(defaults);
|
|
} else if (defaults.type === "rule") {
|
|
return new Rule(defaults);
|
|
} else if (defaults.type === "comment") {
|
|
return new Comment(defaults);
|
|
} else if (defaults.type === "atrule") {
|
|
return new AtRule(defaults);
|
|
} else {
|
|
throw new Error("Unknown node type: " + json.type);
|
|
}
|
|
}
|
|
module.exports = fromJSON;
|
|
fromJSON.default = fromJSON;
|
|
});
|
|
|
|
// node_modules/postcss/lib/map-generator.js
|
|
var require_map_generator = __commonJS((exports, module) => {
|
|
var { dirname, relative, resolve, sep } = __require("path");
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
var { pathToFileURL } = __require("url");
|
|
var Input = require_input();
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(dirname && resolve && relative && sep);
|
|
|
|
class MapGenerator {
|
|
constructor(stringify, root, opts, cssString) {
|
|
this.stringify = stringify;
|
|
this.mapOpts = opts.map || {};
|
|
this.root = root;
|
|
this.opts = opts;
|
|
this.css = cssString;
|
|
this.originalCSS = cssString;
|
|
this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
|
|
this.memoizedFileURLs = new Map;
|
|
this.memoizedPaths = new Map;
|
|
this.memoizedURLs = new Map;
|
|
}
|
|
addAnnotation() {
|
|
let content;
|
|
if (this.isInline()) {
|
|
content = "data:application/json;base64," + this.toBase64(this.map.toString());
|
|
} else if (typeof this.mapOpts.annotation === "string") {
|
|
content = this.mapOpts.annotation;
|
|
} else if (typeof this.mapOpts.annotation === "function") {
|
|
content = this.mapOpts.annotation(this.opts.to, this.root);
|
|
} else {
|
|
content = this.outputFile() + ".map";
|
|
}
|
|
let eol = "\n";
|
|
if (this.css.includes("\r\n"))
|
|
eol = "\r\n";
|
|
this.css += eol + "/*# sourceMappingURL=" + content + " */";
|
|
}
|
|
applyPrevMaps() {
|
|
for (let prev of this.previous()) {
|
|
let from = this.toUrl(this.path(prev.file));
|
|
let root = prev.root || dirname(prev.file);
|
|
let map;
|
|
if (this.mapOpts.sourcesContent === false) {
|
|
map = new SourceMapConsumer(prev.text);
|
|
if (map.sourcesContent) {
|
|
map.sourcesContent = null;
|
|
}
|
|
} else {
|
|
map = prev.consumer();
|
|
}
|
|
this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
|
|
}
|
|
}
|
|
clearAnnotation() {
|
|
if (this.mapOpts.annotation === false)
|
|
return;
|
|
if (this.root) {
|
|
let node;
|
|
for (let i = this.root.nodes.length - 1;i >= 0; i--) {
|
|
node = this.root.nodes[i];
|
|
if (node.type !== "comment")
|
|
continue;
|
|
if (node.text.startsWith("# sourceMappingURL=")) {
|
|
this.root.removeChild(i);
|
|
}
|
|
}
|
|
} else if (this.css) {
|
|
this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, "");
|
|
}
|
|
}
|
|
generate() {
|
|
this.clearAnnotation();
|
|
if (pathAvailable && sourceMapAvailable && this.isMap()) {
|
|
return this.generateMap();
|
|
} else {
|
|
let result = "";
|
|
this.stringify(this.root, (i) => {
|
|
result += i;
|
|
});
|
|
return [result];
|
|
}
|
|
}
|
|
generateMap() {
|
|
if (this.root) {
|
|
this.generateString();
|
|
} else if (this.previous().length === 1) {
|
|
let prev = this.previous()[0].consumer();
|
|
prev.file = this.outputFile();
|
|
this.map = SourceMapGenerator.fromSourceMap(prev, {
|
|
ignoreInvalidMapping: true
|
|
});
|
|
} else {
|
|
this.map = new SourceMapGenerator({
|
|
file: this.outputFile(),
|
|
ignoreInvalidMapping: true
|
|
});
|
|
this.map.addMapping({
|
|
generated: { column: 0, line: 1 },
|
|
original: { column: 0, line: 1 },
|
|
source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
|
|
});
|
|
}
|
|
if (this.isSourcesContent())
|
|
this.setSourcesContent();
|
|
if (this.root && this.previous().length > 0)
|
|
this.applyPrevMaps();
|
|
if (this.isAnnotation())
|
|
this.addAnnotation();
|
|
if (this.isInline()) {
|
|
return [this.css];
|
|
} else {
|
|
return [this.css, this.map];
|
|
}
|
|
}
|
|
generateString() {
|
|
this.css = "";
|
|
this.map = new SourceMapGenerator({
|
|
file: this.outputFile(),
|
|
ignoreInvalidMapping: true
|
|
});
|
|
let line = 1;
|
|
let column = 1;
|
|
let noSource = "<no source>";
|
|
let mapping = {
|
|
generated: { column: 0, line: 0 },
|
|
original: { column: 0, line: 0 },
|
|
source: ""
|
|
};
|
|
let last, lines;
|
|
this.stringify(this.root, (str, node, type) => {
|
|
this.css += str;
|
|
if (node && type !== "end") {
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 1;
|
|
if (node.source && node.source.start) {
|
|
mapping.source = this.sourcePath(node);
|
|
mapping.original.line = node.source.start.line;
|
|
mapping.original.column = node.source.start.column - 1;
|
|
this.map.addMapping(mapping);
|
|
} else {
|
|
mapping.source = noSource;
|
|
mapping.original.line = 1;
|
|
mapping.original.column = 0;
|
|
this.map.addMapping(mapping);
|
|
}
|
|
}
|
|
lines = str.match(/\n/g);
|
|
if (lines) {
|
|
line += lines.length;
|
|
last = str.lastIndexOf("\n");
|
|
column = str.length - last;
|
|
} else {
|
|
column += str.length;
|
|
}
|
|
if (node && type !== "start") {
|
|
let p = node.parent || { raws: {} };
|
|
let childless = node.type === "decl" || node.type === "atrule" && !node.nodes;
|
|
if (!childless || node !== p.last || p.raws.semicolon) {
|
|
if (node.source && node.source.end) {
|
|
mapping.source = this.sourcePath(node);
|
|
mapping.original.line = node.source.end.line;
|
|
mapping.original.column = node.source.end.column - 1;
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 2;
|
|
this.map.addMapping(mapping);
|
|
} else {
|
|
mapping.source = noSource;
|
|
mapping.original.line = 1;
|
|
mapping.original.column = 0;
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 1;
|
|
this.map.addMapping(mapping);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
isAnnotation() {
|
|
if (this.isInline()) {
|
|
return true;
|
|
}
|
|
if (typeof this.mapOpts.annotation !== "undefined") {
|
|
return this.mapOpts.annotation;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.annotation);
|
|
}
|
|
return true;
|
|
}
|
|
isInline() {
|
|
if (typeof this.mapOpts.inline !== "undefined") {
|
|
return this.mapOpts.inline;
|
|
}
|
|
let annotation = this.mapOpts.annotation;
|
|
if (typeof annotation !== "undefined" && annotation !== true) {
|
|
return false;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.inline);
|
|
}
|
|
return true;
|
|
}
|
|
isMap() {
|
|
if (typeof this.opts.map !== "undefined") {
|
|
return !!this.opts.map;
|
|
}
|
|
return this.previous().length > 0;
|
|
}
|
|
isSourcesContent() {
|
|
if (typeof this.mapOpts.sourcesContent !== "undefined") {
|
|
return this.mapOpts.sourcesContent;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.withContent());
|
|
}
|
|
return true;
|
|
}
|
|
outputFile() {
|
|
if (this.opts.to) {
|
|
return this.path(this.opts.to);
|
|
} else if (this.opts.from) {
|
|
return this.path(this.opts.from);
|
|
} else {
|
|
return "to.css";
|
|
}
|
|
}
|
|
path(file) {
|
|
if (this.mapOpts.absolute)
|
|
return file;
|
|
if (file.charCodeAt(0) === 60)
|
|
return file;
|
|
if (/^\w+:\/\//.test(file))
|
|
return file;
|
|
let cached = this.memoizedPaths.get(file);
|
|
if (cached)
|
|
return cached;
|
|
let from = this.opts.to ? dirname(this.opts.to) : ".";
|
|
if (typeof this.mapOpts.annotation === "string") {
|
|
from = dirname(resolve(from, this.mapOpts.annotation));
|
|
}
|
|
let path = relative(from, file);
|
|
this.memoizedPaths.set(file, path);
|
|
return path;
|
|
}
|
|
previous() {
|
|
if (!this.previousMaps) {
|
|
this.previousMaps = [];
|
|
if (this.root) {
|
|
this.root.walk((node) => {
|
|
if (node.source && node.source.input.map) {
|
|
let map = node.source.input.map;
|
|
if (!this.previousMaps.includes(map)) {
|
|
this.previousMaps.push(map);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
let input = new Input(this.originalCSS, this.opts);
|
|
if (input.map)
|
|
this.previousMaps.push(input.map);
|
|
}
|
|
}
|
|
return this.previousMaps;
|
|
}
|
|
setSourcesContent() {
|
|
let already = {};
|
|
if (this.root) {
|
|
this.root.walk((node) => {
|
|
if (node.source) {
|
|
let from = node.source.input.from;
|
|
if (from && !already[from]) {
|
|
already[from] = true;
|
|
let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
|
|
this.map.setSourceContent(fromUrl, node.source.input.css);
|
|
}
|
|
}
|
|
});
|
|
} else if (this.css) {
|
|
let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
|
|
this.map.setSourceContent(from, this.css);
|
|
}
|
|
}
|
|
sourcePath(node) {
|
|
if (this.mapOpts.from) {
|
|
return this.toUrl(this.mapOpts.from);
|
|
} else if (this.usesFileUrls) {
|
|
return this.toFileUrl(node.source.input.from);
|
|
} else {
|
|
return this.toUrl(this.path(node.source.input.from));
|
|
}
|
|
}
|
|
toBase64(str) {
|
|
if (Buffer) {
|
|
return Buffer.from(str).toString("base64");
|
|
} else {
|
|
return window.btoa(unescape(encodeURIComponent(str)));
|
|
}
|
|
}
|
|
toFileUrl(path) {
|
|
let cached = this.memoizedFileURLs.get(path);
|
|
if (cached)
|
|
return cached;
|
|
if (pathToFileURL) {
|
|
let fileURL = pathToFileURL(path).toString();
|
|
this.memoizedFileURLs.set(path, fileURL);
|
|
return fileURL;
|
|
} else {
|
|
throw new Error("`map.absolute` option is not available in this PostCSS build");
|
|
}
|
|
}
|
|
toUrl(path) {
|
|
let cached = this.memoizedURLs.get(path);
|
|
if (cached)
|
|
return cached;
|
|
if (sep === "\\") {
|
|
path = path.replace(/\\/g, "/");
|
|
}
|
|
let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
|
|
this.memoizedURLs.set(path, url);
|
|
return url;
|
|
}
|
|
}
|
|
module.exports = MapGenerator;
|
|
});
|
|
|
|
// node_modules/postcss/lib/parser.js
|
|
var require_parser = __commonJS((exports, module) => {
|
|
var AtRule = require_at_rule();
|
|
var Comment = require_comment();
|
|
var Declaration = require_declaration();
|
|
var Root = require_root();
|
|
var Rule = require_rule();
|
|
var tokenizer = require_tokenize();
|
|
var SAFE_COMMENT_NEIGHBOR = {
|
|
empty: true,
|
|
space: true
|
|
};
|
|
function findLastWithPosition(tokens) {
|
|
for (let i = tokens.length - 1;i >= 0; i--) {
|
|
let token = tokens[i];
|
|
let pos = token[3] || token[2];
|
|
if (pos)
|
|
return pos;
|
|
}
|
|
}
|
|
|
|
class Parser {
|
|
constructor(input) {
|
|
this.input = input;
|
|
this.root = new Root;
|
|
this.current = this.root;
|
|
this.spaces = "";
|
|
this.semicolon = false;
|
|
this.createTokenizer();
|
|
this.root.source = { input, start: { column: 1, line: 1, offset: 0 } };
|
|
}
|
|
atrule(token) {
|
|
let node = new AtRule;
|
|
node.name = token[1].slice(1);
|
|
if (node.name === "") {
|
|
this.unnamedAtrule(node, token);
|
|
}
|
|
this.init(node, token[2]);
|
|
let type;
|
|
let prev;
|
|
let shift;
|
|
let last = false;
|
|
let open = false;
|
|
let params = [];
|
|
let brackets = [];
|
|
while (!this.tokenizer.endOfFile()) {
|
|
token = this.tokenizer.nextToken();
|
|
type = token[0];
|
|
if (type === "(" || type === "[") {
|
|
brackets.push(type === "(" ? ")" : "]");
|
|
} else if (type === "{" && brackets.length > 0) {
|
|
brackets.push("}");
|
|
} else if (type === brackets[brackets.length - 1]) {
|
|
brackets.pop();
|
|
}
|
|
if (brackets.length === 0) {
|
|
if (type === ";") {
|
|
node.source.end = this.getPosition(token[2]);
|
|
node.source.end.offset++;
|
|
this.semicolon = true;
|
|
break;
|
|
} else if (type === "{") {
|
|
open = true;
|
|
break;
|
|
} else if (type === "}") {
|
|
if (params.length > 0) {
|
|
shift = params.length - 1;
|
|
prev = params[shift];
|
|
while (prev && prev[0] === "space") {
|
|
prev = params[--shift];
|
|
}
|
|
if (prev) {
|
|
node.source.end = this.getPosition(prev[3] || prev[2]);
|
|
node.source.end.offset++;
|
|
}
|
|
}
|
|
this.end(token);
|
|
break;
|
|
} else {
|
|
params.push(token);
|
|
}
|
|
} else {
|
|
params.push(token);
|
|
}
|
|
if (this.tokenizer.endOfFile()) {
|
|
last = true;
|
|
break;
|
|
}
|
|
}
|
|
node.raws.between = this.spacesAndCommentsFromEnd(params);
|
|
if (params.length) {
|
|
node.raws.afterName = this.spacesAndCommentsFromStart(params);
|
|
this.raw(node, "params", params);
|
|
if (last) {
|
|
token = params[params.length - 1];
|
|
node.source.end = this.getPosition(token[3] || token[2]);
|
|
node.source.end.offset++;
|
|
this.spaces = node.raws.between;
|
|
node.raws.between = "";
|
|
}
|
|
} else {
|
|
node.raws.afterName = "";
|
|
node.params = "";
|
|
}
|
|
if (open) {
|
|
node.nodes = [];
|
|
this.current = node;
|
|
}
|
|
}
|
|
checkMissedSemicolon(tokens) {
|
|
let colon = this.colon(tokens);
|
|
if (colon === false)
|
|
return;
|
|
let founded = 0;
|
|
let token;
|
|
for (let j = colon - 1;j >= 0; j--) {
|
|
token = tokens[j];
|
|
if (token[0] !== "space") {
|
|
founded += 1;
|
|
if (founded === 2)
|
|
break;
|
|
}
|
|
}
|
|
throw this.input.error("Missed semicolon", token[0] === "word" ? token[3] + 1 : token[2]);
|
|
}
|
|
colon(tokens) {
|
|
let brackets = 0;
|
|
let prev, token, type;
|
|
for (let [i, element] of tokens.entries()) {
|
|
token = element;
|
|
type = token[0];
|
|
if (type === "(") {
|
|
brackets += 1;
|
|
}
|
|
if (type === ")") {
|
|
brackets -= 1;
|
|
}
|
|
if (brackets === 0 && type === ":") {
|
|
if (!prev) {
|
|
this.doubleColon(token);
|
|
} else if (prev[0] === "word" && prev[1] === "progid") {
|
|
continue;
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
prev = token;
|
|
}
|
|
return false;
|
|
}
|
|
comment(token) {
|
|
let node = new Comment;
|
|
this.init(node, token[2]);
|
|
node.source.end = this.getPosition(token[3] || token[2]);
|
|
node.source.end.offset++;
|
|
let text = token[1].slice(2, -2);
|
|
if (/^\s*$/.test(text)) {
|
|
node.text = "";
|
|
node.raws.left = text;
|
|
node.raws.right = "";
|
|
} else {
|
|
let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
|
|
node.text = match[2];
|
|
node.raws.left = match[1];
|
|
node.raws.right = match[3];
|
|
}
|
|
}
|
|
createTokenizer() {
|
|
this.tokenizer = tokenizer(this.input);
|
|
}
|
|
decl(tokens, customProperty) {
|
|
let node = new Declaration;
|
|
this.init(node, tokens[0][2]);
|
|
let last = tokens[tokens.length - 1];
|
|
if (last[0] === ";") {
|
|
this.semicolon = true;
|
|
tokens.pop();
|
|
}
|
|
node.source.end = this.getPosition(last[3] || last[2] || findLastWithPosition(tokens));
|
|
node.source.end.offset++;
|
|
while (tokens[0][0] !== "word") {
|
|
if (tokens.length === 1)
|
|
this.unknownWord(tokens);
|
|
node.raws.before += tokens.shift()[1];
|
|
}
|
|
node.source.start = this.getPosition(tokens[0][2]);
|
|
node.prop = "";
|
|
while (tokens.length) {
|
|
let type = tokens[0][0];
|
|
if (type === ":" || type === "space" || type === "comment") {
|
|
break;
|
|
}
|
|
node.prop += tokens.shift()[1];
|
|
}
|
|
node.raws.between = "";
|
|
let token;
|
|
while (tokens.length) {
|
|
token = tokens.shift();
|
|
if (token[0] === ":") {
|
|
node.raws.between += token[1];
|
|
break;
|
|
} else {
|
|
if (token[0] === "word" && /\w/.test(token[1])) {
|
|
this.unknownWord([token]);
|
|
}
|
|
node.raws.between += token[1];
|
|
}
|
|
}
|
|
if (node.prop[0] === "_" || node.prop[0] === "*") {
|
|
node.raws.before += node.prop[0];
|
|
node.prop = node.prop.slice(1);
|
|
}
|
|
let firstSpaces = [];
|
|
let next;
|
|
while (tokens.length) {
|
|
next = tokens[0][0];
|
|
if (next !== "space" && next !== "comment")
|
|
break;
|
|
firstSpaces.push(tokens.shift());
|
|
}
|
|
this.precheckMissedSemicolon(tokens);
|
|
for (let i = tokens.length - 1;i >= 0; i--) {
|
|
token = tokens[i];
|
|
if (token[1].toLowerCase() === "!important") {
|
|
node.important = true;
|
|
let string = this.stringFrom(tokens, i);
|
|
string = this.spacesFromEnd(tokens) + string;
|
|
if (string !== " !important")
|
|
node.raws.important = string;
|
|
break;
|
|
} else if (token[1].toLowerCase() === "important") {
|
|
let cache = tokens.slice(0);
|
|
let str = "";
|
|
for (let j = i;j > 0; j--) {
|
|
let type = cache[j][0];
|
|
if (str.trim().startsWith("!") && type !== "space") {
|
|
break;
|
|
}
|
|
str = cache.pop()[1] + str;
|
|
}
|
|
if (str.trim().startsWith("!")) {
|
|
node.important = true;
|
|
node.raws.important = str;
|
|
tokens = cache;
|
|
}
|
|
}
|
|
if (token[0] !== "space" && token[0] !== "comment") {
|
|
break;
|
|
}
|
|
}
|
|
let hasWord = tokens.some((i) => i[0] !== "space" && i[0] !== "comment");
|
|
if (hasWord) {
|
|
node.raws.between += firstSpaces.map((i) => i[1]).join("");
|
|
firstSpaces = [];
|
|
}
|
|
this.raw(node, "value", firstSpaces.concat(tokens), customProperty);
|
|
if (node.value.includes(":") && !customProperty) {
|
|
this.checkMissedSemicolon(tokens);
|
|
}
|
|
}
|
|
doubleColon(token) {
|
|
throw this.input.error("Double colon", { offset: token[2] }, { offset: token[2] + token[1].length });
|
|
}
|
|
emptyRule(token) {
|
|
let node = new Rule;
|
|
this.init(node, token[2]);
|
|
node.selector = "";
|
|
node.raws.between = "";
|
|
this.current = node;
|
|
}
|
|
end(token) {
|
|
if (this.current.nodes && this.current.nodes.length) {
|
|
this.current.raws.semicolon = this.semicolon;
|
|
}
|
|
this.semicolon = false;
|
|
this.current.raws.after = (this.current.raws.after || "") + this.spaces;
|
|
this.spaces = "";
|
|
if (this.current.parent) {
|
|
this.current.source.end = this.getPosition(token[2]);
|
|
this.current.source.end.offset++;
|
|
this.current = this.current.parent;
|
|
} else {
|
|
this.unexpectedClose(token);
|
|
}
|
|
}
|
|
endFile() {
|
|
if (this.current.parent)
|
|
this.unclosedBlock();
|
|
if (this.current.nodes && this.current.nodes.length) {
|
|
this.current.raws.semicolon = this.semicolon;
|
|
}
|
|
this.current.raws.after = (this.current.raws.after || "") + this.spaces;
|
|
this.root.source.end = this.getPosition(this.tokenizer.position());
|
|
}
|
|
freeSemicolon(token) {
|
|
this.spaces += token[1];
|
|
if (this.current.nodes) {
|
|
let prev = this.current.nodes[this.current.nodes.length - 1];
|
|
if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
|
|
prev.raws.ownSemicolon = this.spaces;
|
|
this.spaces = "";
|
|
}
|
|
}
|
|
}
|
|
getPosition(offset) {
|
|
let pos = this.input.fromOffset(offset);
|
|
return {
|
|
column: pos.col,
|
|
line: pos.line,
|
|
offset
|
|
};
|
|
}
|
|
init(node, offset) {
|
|
this.current.push(node);
|
|
node.source = {
|
|
input: this.input,
|
|
start: this.getPosition(offset)
|
|
};
|
|
node.raws.before = this.spaces;
|
|
this.spaces = "";
|
|
if (node.type !== "comment")
|
|
this.semicolon = false;
|
|
}
|
|
other(start) {
|
|
let end = false;
|
|
let type = null;
|
|
let colon = false;
|
|
let bracket = null;
|
|
let brackets = [];
|
|
let customProperty = start[1].startsWith("--");
|
|
let tokens = [];
|
|
let token = start;
|
|
while (token) {
|
|
type = token[0];
|
|
tokens.push(token);
|
|
if (type === "(" || type === "[") {
|
|
if (!bracket)
|
|
bracket = token;
|
|
brackets.push(type === "(" ? ")" : "]");
|
|
} else if (customProperty && colon && type === "{") {
|
|
if (!bracket)
|
|
bracket = token;
|
|
brackets.push("}");
|
|
} else if (brackets.length === 0) {
|
|
if (type === ";") {
|
|
if (colon) {
|
|
this.decl(tokens, customProperty);
|
|
return;
|
|
} else {
|
|
break;
|
|
}
|
|
} else if (type === "{") {
|
|
this.rule(tokens);
|
|
return;
|
|
} else if (type === "}") {
|
|
this.tokenizer.back(tokens.pop());
|
|
end = true;
|
|
break;
|
|
} else if (type === ":") {
|
|
colon = true;
|
|
}
|
|
} else if (type === brackets[brackets.length - 1]) {
|
|
brackets.pop();
|
|
if (brackets.length === 0)
|
|
bracket = null;
|
|
}
|
|
token = this.tokenizer.nextToken();
|
|
}
|
|
if (this.tokenizer.endOfFile())
|
|
end = true;
|
|
if (brackets.length > 0)
|
|
this.unclosedBracket(bracket);
|
|
if (end && colon) {
|
|
if (!customProperty) {
|
|
while (tokens.length) {
|
|
token = tokens[tokens.length - 1][0];
|
|
if (token !== "space" && token !== "comment")
|
|
break;
|
|
this.tokenizer.back(tokens.pop());
|
|
}
|
|
}
|
|
this.decl(tokens, customProperty);
|
|
} else {
|
|
this.unknownWord(tokens);
|
|
}
|
|
}
|
|
parse() {
|
|
let token;
|
|
while (!this.tokenizer.endOfFile()) {
|
|
token = this.tokenizer.nextToken();
|
|
switch (token[0]) {
|
|
case "space":
|
|
this.spaces += token[1];
|
|
break;
|
|
case ";":
|
|
this.freeSemicolon(token);
|
|
break;
|
|
case "}":
|
|
this.end(token);
|
|
break;
|
|
case "comment":
|
|
this.comment(token);
|
|
break;
|
|
case "at-word":
|
|
this.atrule(token);
|
|
break;
|
|
case "{":
|
|
this.emptyRule(token);
|
|
break;
|
|
default:
|
|
this.other(token);
|
|
break;
|
|
}
|
|
}
|
|
this.endFile();
|
|
}
|
|
precheckMissedSemicolon() {
|
|
}
|
|
raw(node, prop, tokens, customProperty) {
|
|
let token, type;
|
|
let length = tokens.length;
|
|
let value = "";
|
|
let clean = true;
|
|
let next, prev;
|
|
for (let i = 0;i < length; i += 1) {
|
|
token = tokens[i];
|
|
type = token[0];
|
|
if (type === "space" && i === length - 1 && !customProperty) {
|
|
clean = false;
|
|
} else if (type === "comment") {
|
|
prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
|
|
next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
|
|
if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
|
|
if (value.slice(-1) === ",") {
|
|
clean = false;
|
|
} else {
|
|
value += token[1];
|
|
}
|
|
} else {
|
|
clean = false;
|
|
}
|
|
} else {
|
|
value += token[1];
|
|
}
|
|
}
|
|
if (!clean) {
|
|
let raw = tokens.reduce((all, i) => all + i[1], "");
|
|
node.raws[prop] = { raw, value };
|
|
}
|
|
node[prop] = value;
|
|
}
|
|
rule(tokens) {
|
|
tokens.pop();
|
|
let node = new Rule;
|
|
this.init(node, tokens[0][2]);
|
|
node.raws.between = this.spacesAndCommentsFromEnd(tokens);
|
|
this.raw(node, "selector", tokens);
|
|
this.current = node;
|
|
}
|
|
spacesAndCommentsFromEnd(tokens) {
|
|
let lastTokenType;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
lastTokenType = tokens[tokens.length - 1][0];
|
|
if (lastTokenType !== "space" && lastTokenType !== "comment")
|
|
break;
|
|
spaces = tokens.pop()[1] + spaces;
|
|
}
|
|
return spaces;
|
|
}
|
|
spacesAndCommentsFromStart(tokens) {
|
|
let next;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
next = tokens[0][0];
|
|
if (next !== "space" && next !== "comment")
|
|
break;
|
|
spaces += tokens.shift()[1];
|
|
}
|
|
return spaces;
|
|
}
|
|
spacesFromEnd(tokens) {
|
|
let lastTokenType;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
lastTokenType = tokens[tokens.length - 1][0];
|
|
if (lastTokenType !== "space")
|
|
break;
|
|
spaces = tokens.pop()[1] + spaces;
|
|
}
|
|
return spaces;
|
|
}
|
|
stringFrom(tokens, from) {
|
|
let result = "";
|
|
for (let i = from;i < tokens.length; i++) {
|
|
result += tokens[i][1];
|
|
}
|
|
tokens.splice(from, tokens.length - from);
|
|
return result;
|
|
}
|
|
unclosedBlock() {
|
|
let pos = this.current.source.start;
|
|
throw this.input.error("Unclosed block", pos.line, pos.column);
|
|
}
|
|
unclosedBracket(bracket) {
|
|
throw this.input.error("Unclosed bracket", { offset: bracket[2] }, { offset: bracket[2] + 1 });
|
|
}
|
|
unexpectedClose(token) {
|
|
throw this.input.error("Unexpected }", { offset: token[2] }, { offset: token[2] + 1 });
|
|
}
|
|
unknownWord(tokens) {
|
|
throw this.input.error("Unknown word", { offset: tokens[0][2] }, { offset: tokens[0][2] + tokens[0][1].length });
|
|
}
|
|
unnamedAtrule(node, token) {
|
|
throw this.input.error("At-rule without name", { offset: token[2] }, { offset: token[2] + token[1].length });
|
|
}
|
|
}
|
|
module.exports = Parser;
|
|
});
|
|
|
|
// node_modules/postcss/lib/parse.js
|
|
var require_parse = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
var Input = require_input();
|
|
var Parser = require_parser();
|
|
function parse(css, opts) {
|
|
let input = new Input(css, opts);
|
|
let parser = new Parser(input);
|
|
try {
|
|
parser.parse();
|
|
} catch (e) {
|
|
if (true) {
|
|
if (e.name === "CssSyntaxError" && opts && opts.from) {
|
|
if (/\.scss$/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse SCSS with " + "the standard CSS parser; " + "try again with the postcss-scss parser";
|
|
} else if (/\.sass/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse Sass with " + "the standard CSS parser; " + "try again with the postcss-sass parser";
|
|
} else if (/\.less$/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse Less with " + "the standard CSS parser; " + "try again with the postcss-less parser";
|
|
}
|
|
}
|
|
}
|
|
throw e;
|
|
}
|
|
return parser.root;
|
|
}
|
|
module.exports = parse;
|
|
parse.default = parse;
|
|
Container.registerParse(parse);
|
|
});
|
|
|
|
// node_modules/postcss/lib/warning.js
|
|
var require_warning = __commonJS((exports, module) => {
|
|
class Warning {
|
|
constructor(text, opts = {}) {
|
|
this.type = "warning";
|
|
this.text = text;
|
|
if (opts.node && opts.node.source) {
|
|
let range = opts.node.rangeBy(opts);
|
|
this.line = range.start.line;
|
|
this.column = range.start.column;
|
|
this.endLine = range.end.line;
|
|
this.endColumn = range.end.column;
|
|
}
|
|
for (let opt in opts)
|
|
this[opt] = opts[opt];
|
|
}
|
|
toString() {
|
|
if (this.node) {
|
|
return this.node.error(this.text, {
|
|
index: this.index,
|
|
plugin: this.plugin,
|
|
word: this.word
|
|
}).message;
|
|
}
|
|
if (this.plugin) {
|
|
return this.plugin + ": " + this.text;
|
|
}
|
|
return this.text;
|
|
}
|
|
}
|
|
module.exports = Warning;
|
|
Warning.default = Warning;
|
|
});
|
|
|
|
// node_modules/postcss/lib/result.js
|
|
var require_result = __commonJS((exports, module) => {
|
|
var Warning = require_warning();
|
|
|
|
class Result {
|
|
constructor(processor, root, opts) {
|
|
this.processor = processor;
|
|
this.messages = [];
|
|
this.root = root;
|
|
this.opts = opts;
|
|
this.css = undefined;
|
|
this.map = undefined;
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
warn(text, opts = {}) {
|
|
if (!opts.plugin) {
|
|
if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
|
|
opts.plugin = this.lastPlugin.postcssPlugin;
|
|
}
|
|
}
|
|
let warning = new Warning(text, opts);
|
|
this.messages.push(warning);
|
|
return warning;
|
|
}
|
|
warnings() {
|
|
return this.messages.filter((i) => i.type === "warning");
|
|
}
|
|
get content() {
|
|
return this.css;
|
|
}
|
|
}
|
|
module.exports = Result;
|
|
Result.default = Result;
|
|
});
|
|
|
|
// node_modules/postcss/lib/warn-once.js
|
|
var require_warn_once = __commonJS((exports, module) => {
|
|
var printed = {};
|
|
module.exports = function warnOnce(message) {
|
|
if (printed[message])
|
|
return;
|
|
printed[message] = true;
|
|
if (typeof console !== "undefined" && console.warn) {
|
|
console.warn(message);
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/postcss/lib/lazy-result.js
|
|
var require_lazy_result = __commonJS((exports, module) => {
|
|
var Container = require_container();
|
|
var Document = require_document();
|
|
var MapGenerator = require_map_generator();
|
|
var parse = require_parse();
|
|
var Result = require_result();
|
|
var Root = require_root();
|
|
var stringify = require_stringify2();
|
|
var { isClean, my } = require_symbols();
|
|
var warnOnce = require_warn_once();
|
|
var TYPE_TO_CLASS_NAME = {
|
|
atrule: "AtRule",
|
|
comment: "Comment",
|
|
decl: "Declaration",
|
|
document: "Document",
|
|
root: "Root",
|
|
rule: "Rule"
|
|
};
|
|
var PLUGIN_PROPS = {
|
|
AtRule: true,
|
|
AtRuleExit: true,
|
|
Comment: true,
|
|
CommentExit: true,
|
|
Declaration: true,
|
|
DeclarationExit: true,
|
|
Document: true,
|
|
DocumentExit: true,
|
|
Once: true,
|
|
OnceExit: true,
|
|
postcssPlugin: true,
|
|
prepare: true,
|
|
Root: true,
|
|
RootExit: true,
|
|
Rule: true,
|
|
RuleExit: true
|
|
};
|
|
var NOT_VISITORS = {
|
|
Once: true,
|
|
postcssPlugin: true,
|
|
prepare: true
|
|
};
|
|
var CHILDREN = 0;
|
|
function isPromise(obj) {
|
|
return typeof obj === "object" && typeof obj.then === "function";
|
|
}
|
|
function getEvents(node) {
|
|
let key = false;
|
|
let type = TYPE_TO_CLASS_NAME[node.type];
|
|
if (node.type === "decl") {
|
|
key = node.prop.toLowerCase();
|
|
} else if (node.type === "atrule") {
|
|
key = node.name.toLowerCase();
|
|
}
|
|
if (key && node.append) {
|
|
return [
|
|
type,
|
|
type + "-" + key,
|
|
CHILDREN,
|
|
type + "Exit",
|
|
type + "Exit-" + key
|
|
];
|
|
} else if (key) {
|
|
return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
|
|
} else if (node.append) {
|
|
return [type, CHILDREN, type + "Exit"];
|
|
} else {
|
|
return [type, type + "Exit"];
|
|
}
|
|
}
|
|
function toStack(node) {
|
|
let events;
|
|
if (node.type === "document") {
|
|
events = ["Document", CHILDREN, "DocumentExit"];
|
|
} else if (node.type === "root") {
|
|
events = ["Root", CHILDREN, "RootExit"];
|
|
} else {
|
|
events = getEvents(node);
|
|
}
|
|
return {
|
|
eventIndex: 0,
|
|
events,
|
|
iterator: 0,
|
|
node,
|
|
visitorIndex: 0,
|
|
visitors: []
|
|
};
|
|
}
|
|
function cleanMarks(node) {
|
|
node[isClean] = false;
|
|
if (node.nodes)
|
|
node.nodes.forEach((i) => cleanMarks(i));
|
|
return node;
|
|
}
|
|
var postcss = {};
|
|
|
|
class LazyResult {
|
|
constructor(processor, css, opts) {
|
|
this.stringified = false;
|
|
this.processed = false;
|
|
let root;
|
|
if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
|
|
root = cleanMarks(css);
|
|
} else if (css instanceof LazyResult || css instanceof Result) {
|
|
root = cleanMarks(css.root);
|
|
if (css.map) {
|
|
if (typeof opts.map === "undefined")
|
|
opts.map = {};
|
|
if (!opts.map.inline)
|
|
opts.map.inline = false;
|
|
opts.map.prev = css.map;
|
|
}
|
|
} else {
|
|
let parser = parse;
|
|
if (opts.syntax)
|
|
parser = opts.syntax.parse;
|
|
if (opts.parser)
|
|
parser = opts.parser;
|
|
if (parser.parse)
|
|
parser = parser.parse;
|
|
try {
|
|
root = parser(css, opts);
|
|
} catch (error) {
|
|
this.processed = true;
|
|
this.error = error;
|
|
}
|
|
if (root && !root[my]) {
|
|
Container.rebuild(root);
|
|
}
|
|
}
|
|
this.result = new Result(processor, root, opts);
|
|
this.helpers = { ...postcss, postcss, result: this.result };
|
|
this.plugins = this.processor.plugins.map((plugin) => {
|
|
if (typeof plugin === "object" && plugin.prepare) {
|
|
return { ...plugin, ...plugin.prepare(this.result) };
|
|
} else {
|
|
return plugin;
|
|
}
|
|
});
|
|
}
|
|
async() {
|
|
if (this.error)
|
|
return Promise.reject(this.error);
|
|
if (this.processed)
|
|
return Promise.resolve(this.result);
|
|
if (!this.processing) {
|
|
this.processing = this.runAsync();
|
|
}
|
|
return this.processing;
|
|
}
|
|
catch(onRejected) {
|
|
return this.async().catch(onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.async().then(onFinally, onFinally);
|
|
}
|
|
getAsyncError() {
|
|
throw new Error("Use process(css).then(cb) to work with async plugins");
|
|
}
|
|
handleError(error, node) {
|
|
let plugin = this.result.lastPlugin;
|
|
try {
|
|
if (node)
|
|
node.addToError(error);
|
|
this.error = error;
|
|
if (error.name === "CssSyntaxError" && !error.plugin) {
|
|
error.plugin = plugin.postcssPlugin;
|
|
error.setMessage();
|
|
} else if (plugin.postcssVersion) {
|
|
if (true) {
|
|
let pluginName = plugin.postcssPlugin;
|
|
let pluginVer = plugin.postcssVersion;
|
|
let runtimeVer = this.result.processor.version;
|
|
let a = pluginVer.split(".");
|
|
let b = runtimeVer.split(".");
|
|
if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
|
|
console.error("Unknown error from PostCSS plugin. Your current PostCSS " + "version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below.");
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
if (console && console.error)
|
|
console.error(err);
|
|
}
|
|
return error;
|
|
}
|
|
prepareVisitors() {
|
|
this.listeners = {};
|
|
let add = (plugin, type, cb) => {
|
|
if (!this.listeners[type])
|
|
this.listeners[type] = [];
|
|
this.listeners[type].push([plugin, cb]);
|
|
};
|
|
for (let plugin of this.plugins) {
|
|
if (typeof plugin === "object") {
|
|
for (let event in plugin) {
|
|
if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
|
|
throw new Error(`Unknown event ${event} in ${plugin.postcssPlugin}. ` + `Try to update PostCSS (${this.processor.version} now).`);
|
|
}
|
|
if (!NOT_VISITORS[event]) {
|
|
if (typeof plugin[event] === "object") {
|
|
for (let filter in plugin[event]) {
|
|
if (filter === "*") {
|
|
add(plugin, event, plugin[event][filter]);
|
|
} else {
|
|
add(plugin, event + "-" + filter.toLowerCase(), plugin[event][filter]);
|
|
}
|
|
}
|
|
} else if (typeof plugin[event] === "function") {
|
|
add(plugin, event, plugin[event]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.hasListener = Object.keys(this.listeners).length > 0;
|
|
}
|
|
async runAsync() {
|
|
this.plugin = 0;
|
|
for (let i = 0;i < this.plugins.length; i++) {
|
|
let plugin = this.plugins[i];
|
|
let promise = this.runOnRoot(plugin);
|
|
if (isPromise(promise)) {
|
|
try {
|
|
await promise;
|
|
} catch (error) {
|
|
throw this.handleError(error);
|
|
}
|
|
}
|
|
}
|
|
this.prepareVisitors();
|
|
if (this.hasListener) {
|
|
let root = this.result.root;
|
|
while (!root[isClean]) {
|
|
root[isClean] = true;
|
|
let stack = [toStack(root)];
|
|
while (stack.length > 0) {
|
|
let promise = this.visitTick(stack);
|
|
if (isPromise(promise)) {
|
|
try {
|
|
await promise;
|
|
} catch (e) {
|
|
let node = stack[stack.length - 1].node;
|
|
throw this.handleError(e, node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.listeners.OnceExit) {
|
|
for (let [plugin, visitor] of this.listeners.OnceExit) {
|
|
this.result.lastPlugin = plugin;
|
|
try {
|
|
if (root.type === "document") {
|
|
let roots = root.nodes.map((subRoot) => visitor(subRoot, this.helpers));
|
|
await Promise.all(roots);
|
|
} else {
|
|
await visitor(root, this.helpers);
|
|
}
|
|
} catch (e) {
|
|
throw this.handleError(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.processed = true;
|
|
return this.stringify();
|
|
}
|
|
runOnRoot(plugin) {
|
|
this.result.lastPlugin = plugin;
|
|
try {
|
|
if (typeof plugin === "object" && plugin.Once) {
|
|
if (this.result.root.type === "document") {
|
|
let roots = this.result.root.nodes.map((root) => plugin.Once(root, this.helpers));
|
|
if (isPromise(roots[0])) {
|
|
return Promise.all(roots);
|
|
}
|
|
return roots;
|
|
}
|
|
return plugin.Once(this.result.root, this.helpers);
|
|
} else if (typeof plugin === "function") {
|
|
return plugin(this.result.root, this.result);
|
|
}
|
|
} catch (error) {
|
|
throw this.handleError(error);
|
|
}
|
|
}
|
|
stringify() {
|
|
if (this.error)
|
|
throw this.error;
|
|
if (this.stringified)
|
|
return this.result;
|
|
this.stringified = true;
|
|
this.sync();
|
|
let opts = this.result.opts;
|
|
let str = stringify;
|
|
if (opts.syntax)
|
|
str = opts.syntax.stringify;
|
|
if (opts.stringifier)
|
|
str = opts.stringifier;
|
|
if (str.stringify)
|
|
str = str.stringify;
|
|
let map = new MapGenerator(str, this.result.root, this.result.opts);
|
|
let data = map.generate();
|
|
this.result.css = data[0];
|
|
this.result.map = data[1];
|
|
return this.result;
|
|
}
|
|
sync() {
|
|
if (this.error)
|
|
throw this.error;
|
|
if (this.processed)
|
|
return this.result;
|
|
this.processed = true;
|
|
if (this.processing) {
|
|
throw this.getAsyncError();
|
|
}
|
|
for (let plugin of this.plugins) {
|
|
let promise = this.runOnRoot(plugin);
|
|
if (isPromise(promise)) {
|
|
throw this.getAsyncError();
|
|
}
|
|
}
|
|
this.prepareVisitors();
|
|
if (this.hasListener) {
|
|
let root = this.result.root;
|
|
while (!root[isClean]) {
|
|
root[isClean] = true;
|
|
this.walkSync(root);
|
|
}
|
|
if (this.listeners.OnceExit) {
|
|
if (root.type === "document") {
|
|
for (let subRoot of root.nodes) {
|
|
this.visitSync(this.listeners.OnceExit, subRoot);
|
|
}
|
|
} else {
|
|
this.visitSync(this.listeners.OnceExit, root);
|
|
}
|
|
}
|
|
}
|
|
return this.result;
|
|
}
|
|
then(onFulfilled, onRejected) {
|
|
if (true) {
|
|
if (!("from" in this.opts)) {
|
|
warnOnce("Without `from` option PostCSS could generate wrong source map " + "and will not find Browserslist config. Set it to CSS file path " + "or to `undefined` to prevent this warning.");
|
|
}
|
|
}
|
|
return this.async().then(onFulfilled, onRejected);
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
visitSync(visitors, node) {
|
|
for (let [plugin, visitor] of visitors) {
|
|
this.result.lastPlugin = plugin;
|
|
let promise;
|
|
try {
|
|
promise = visitor(node, this.helpers);
|
|
} catch (e) {
|
|
throw this.handleError(e, node.proxyOf);
|
|
}
|
|
if (node.type !== "root" && node.type !== "document" && !node.parent) {
|
|
return true;
|
|
}
|
|
if (isPromise(promise)) {
|
|
throw this.getAsyncError();
|
|
}
|
|
}
|
|
}
|
|
visitTick(stack) {
|
|
let visit = stack[stack.length - 1];
|
|
let { node, visitors } = visit;
|
|
if (node.type !== "root" && node.type !== "document" && !node.parent) {
|
|
stack.pop();
|
|
return;
|
|
}
|
|
if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
|
|
let [plugin, visitor] = visitors[visit.visitorIndex];
|
|
visit.visitorIndex += 1;
|
|
if (visit.visitorIndex === visitors.length) {
|
|
visit.visitors = [];
|
|
visit.visitorIndex = 0;
|
|
}
|
|
this.result.lastPlugin = plugin;
|
|
try {
|
|
return visitor(node.toProxy(), this.helpers);
|
|
} catch (e) {
|
|
throw this.handleError(e, node);
|
|
}
|
|
}
|
|
if (visit.iterator !== 0) {
|
|
let iterator = visit.iterator;
|
|
let child;
|
|
while (child = node.nodes[node.indexes[iterator]]) {
|
|
node.indexes[iterator] += 1;
|
|
if (!child[isClean]) {
|
|
child[isClean] = true;
|
|
stack.push(toStack(child));
|
|
return;
|
|
}
|
|
}
|
|
visit.iterator = 0;
|
|
delete node.indexes[iterator];
|
|
}
|
|
let events = visit.events;
|
|
while (visit.eventIndex < events.length) {
|
|
let event = events[visit.eventIndex];
|
|
visit.eventIndex += 1;
|
|
if (event === CHILDREN) {
|
|
if (node.nodes && node.nodes.length) {
|
|
node[isClean] = true;
|
|
visit.iterator = node.getIterator();
|
|
}
|
|
return;
|
|
} else if (this.listeners[event]) {
|
|
visit.visitors = this.listeners[event];
|
|
return;
|
|
}
|
|
}
|
|
stack.pop();
|
|
}
|
|
walkSync(node) {
|
|
node[isClean] = true;
|
|
let events = getEvents(node);
|
|
for (let event of events) {
|
|
if (event === CHILDREN) {
|
|
if (node.nodes) {
|
|
node.each((child) => {
|
|
if (!child[isClean])
|
|
this.walkSync(child);
|
|
});
|
|
}
|
|
} else {
|
|
let visitors = this.listeners[event];
|
|
if (visitors) {
|
|
if (this.visitSync(visitors, node.toProxy()))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
warnings() {
|
|
return this.sync().warnings();
|
|
}
|
|
get content() {
|
|
return this.stringify().content;
|
|
}
|
|
get css() {
|
|
return this.stringify().css;
|
|
}
|
|
get map() {
|
|
return this.stringify().map;
|
|
}
|
|
get messages() {
|
|
return this.sync().messages;
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get root() {
|
|
return this.sync().root;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "LazyResult";
|
|
}
|
|
}
|
|
LazyResult.registerPostcss = (dependant) => {
|
|
postcss = dependant;
|
|
};
|
|
module.exports = LazyResult;
|
|
LazyResult.default = LazyResult;
|
|
Root.registerLazyResult(LazyResult);
|
|
Document.registerLazyResult(LazyResult);
|
|
});
|
|
|
|
// node_modules/postcss/lib/no-work-result.js
|
|
var require_no_work_result = __commonJS((exports, module) => {
|
|
var MapGenerator = require_map_generator();
|
|
var parse = require_parse();
|
|
var Result = require_result();
|
|
var stringify = require_stringify2();
|
|
var warnOnce = require_warn_once();
|
|
|
|
class NoWorkResult {
|
|
constructor(processor, css, opts) {
|
|
css = css.toString();
|
|
this.stringified = false;
|
|
this._processor = processor;
|
|
this._css = css;
|
|
this._opts = opts;
|
|
this._map = undefined;
|
|
let root;
|
|
let str = stringify;
|
|
this.result = new Result(this._processor, root, this._opts);
|
|
this.result.css = css;
|
|
let self2 = this;
|
|
Object.defineProperty(this.result, "root", {
|
|
get() {
|
|
return self2.root;
|
|
}
|
|
});
|
|
let map = new MapGenerator(str, root, this._opts, css);
|
|
if (map.isMap()) {
|
|
let [generatedCSS, generatedMap] = map.generate();
|
|
if (generatedCSS) {
|
|
this.result.css = generatedCSS;
|
|
}
|
|
if (generatedMap) {
|
|
this.result.map = generatedMap;
|
|
}
|
|
} else {
|
|
map.clearAnnotation();
|
|
this.result.css = map.css;
|
|
}
|
|
}
|
|
async() {
|
|
if (this.error)
|
|
return Promise.reject(this.error);
|
|
return Promise.resolve(this.result);
|
|
}
|
|
catch(onRejected) {
|
|
return this.async().catch(onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.async().then(onFinally, onFinally);
|
|
}
|
|
sync() {
|
|
if (this.error)
|
|
throw this.error;
|
|
return this.result;
|
|
}
|
|
then(onFulfilled, onRejected) {
|
|
if (true) {
|
|
if (!("from" in this._opts)) {
|
|
warnOnce("Without `from` option PostCSS could generate wrong source map " + "and will not find Browserslist config. Set it to CSS file path " + "or to `undefined` to prevent this warning.");
|
|
}
|
|
}
|
|
return this.async().then(onFulfilled, onRejected);
|
|
}
|
|
toString() {
|
|
return this._css;
|
|
}
|
|
warnings() {
|
|
return [];
|
|
}
|
|
get content() {
|
|
return this.result.css;
|
|
}
|
|
get css() {
|
|
return this.result.css;
|
|
}
|
|
get map() {
|
|
return this.result.map;
|
|
}
|
|
get messages() {
|
|
return [];
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get root() {
|
|
if (this._root) {
|
|
return this._root;
|
|
}
|
|
let root;
|
|
let parser = parse;
|
|
try {
|
|
root = parser(this._css, this._opts);
|
|
} catch (error) {
|
|
this.error = error;
|
|
}
|
|
if (this.error) {
|
|
throw this.error;
|
|
} else {
|
|
this._root = root;
|
|
return root;
|
|
}
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "NoWorkResult";
|
|
}
|
|
}
|
|
module.exports = NoWorkResult;
|
|
NoWorkResult.default = NoWorkResult;
|
|
});
|
|
|
|
// node_modules/postcss/lib/processor.js
|
|
var require_processor = __commonJS((exports, module) => {
|
|
var Document = require_document();
|
|
var LazyResult = require_lazy_result();
|
|
var NoWorkResult = require_no_work_result();
|
|
var Root = require_root();
|
|
|
|
class Processor {
|
|
constructor(plugins = []) {
|
|
this.version = "8.4.47";
|
|
this.plugins = this.normalize(plugins);
|
|
}
|
|
normalize(plugins) {
|
|
let normalized = [];
|
|
for (let i of plugins) {
|
|
if (i.postcss === true) {
|
|
i = i();
|
|
} else if (i.postcss) {
|
|
i = i.postcss;
|
|
}
|
|
if (typeof i === "object" && Array.isArray(i.plugins)) {
|
|
normalized = normalized.concat(i.plugins);
|
|
} else if (typeof i === "object" && i.postcssPlugin) {
|
|
normalized.push(i);
|
|
} else if (typeof i === "function") {
|
|
normalized.push(i);
|
|
} else if (typeof i === "object" && (i.parse || i.stringify)) {
|
|
if (true) {
|
|
throw new Error("PostCSS syntaxes cannot be used as plugins. Instead, please use " + "one of the syntax/parser/stringifier options as outlined " + "in your PostCSS runner documentation.");
|
|
}
|
|
} else {
|
|
throw new Error(i + " is not a PostCSS plugin");
|
|
}
|
|
}
|
|
return normalized;
|
|
}
|
|
process(css, opts = {}) {
|
|
if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
|
|
return new NoWorkResult(this, css, opts);
|
|
} else {
|
|
return new LazyResult(this, css, opts);
|
|
}
|
|
}
|
|
use(plugin) {
|
|
this.plugins = this.plugins.concat(this.normalize([plugin]));
|
|
return this;
|
|
}
|
|
}
|
|
module.exports = Processor;
|
|
Processor.default = Processor;
|
|
Root.registerProcessor(Processor);
|
|
Document.registerProcessor(Processor);
|
|
});
|
|
|
|
// node_modules/postcss/lib/postcss.js
|
|
var require_postcss = __commonJS((exports, module) => {
|
|
var AtRule = require_at_rule();
|
|
var Comment = require_comment();
|
|
var Container = require_container();
|
|
var CssSyntaxError = require_css_syntax_error();
|
|
var Declaration = require_declaration();
|
|
var Document = require_document();
|
|
var fromJSON = require_fromJSON();
|
|
var Input = require_input();
|
|
var LazyResult = require_lazy_result();
|
|
var list = require_list();
|
|
var Node = require_node3();
|
|
var parse = require_parse();
|
|
var Processor = require_processor();
|
|
var Result = require_result();
|
|
var Root = require_root();
|
|
var Rule = require_rule();
|
|
var stringify = require_stringify2();
|
|
var Warning = require_warning();
|
|
function postcss(...plugins) {
|
|
if (plugins.length === 1 && Array.isArray(plugins[0])) {
|
|
plugins = plugins[0];
|
|
}
|
|
return new Processor(plugins);
|
|
}
|
|
postcss.plugin = function plugin(name, initializer) {
|
|
let warningPrinted = false;
|
|
function creator(...args) {
|
|
if (console && console.warn && !warningPrinted) {
|
|
warningPrinted = true;
|
|
console.warn(name + ": postcss.plugin was deprecated. Migration guide:\n" + "https://evilmartians.com/chronicles/postcss-8-plugin-migration");
|
|
if (process.env.LANG && process.env.LANG.startsWith("cn")) {
|
|
console.warn(name + `: \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:
|
|
` + "https://www.w3ctech.com/topic/2226");
|
|
}
|
|
}
|
|
let transformer = initializer(...args);
|
|
transformer.postcssPlugin = name;
|
|
transformer.postcssVersion = new Processor().version;
|
|
return transformer;
|
|
}
|
|
let cache;
|
|
Object.defineProperty(creator, "postcss", {
|
|
get() {
|
|
if (!cache)
|
|
cache = creator();
|
|
return cache;
|
|
}
|
|
});
|
|
creator.process = function(css, processOpts, pluginOpts) {
|
|
return postcss([creator(pluginOpts)]).process(css, processOpts);
|
|
};
|
|
return creator;
|
|
};
|
|
postcss.stringify = stringify;
|
|
postcss.parse = parse;
|
|
postcss.fromJSON = fromJSON;
|
|
postcss.list = list;
|
|
postcss.comment = (defaults) => new Comment(defaults);
|
|
postcss.atRule = (defaults) => new AtRule(defaults);
|
|
postcss.decl = (defaults) => new Declaration(defaults);
|
|
postcss.rule = (defaults) => new Rule(defaults);
|
|
postcss.root = (defaults) => new Root(defaults);
|
|
postcss.document = (defaults) => new Document(defaults);
|
|
postcss.CssSyntaxError = CssSyntaxError;
|
|
postcss.Declaration = Declaration;
|
|
postcss.Container = Container;
|
|
postcss.Processor = Processor;
|
|
postcss.Document = Document;
|
|
postcss.Comment = Comment;
|
|
postcss.Warning = Warning;
|
|
postcss.AtRule = AtRule;
|
|
postcss.Result = Result;
|
|
postcss.Input = Input;
|
|
postcss.Rule = Rule;
|
|
postcss.Root = Root;
|
|
postcss.Node = Node;
|
|
LazyResult.registerPostcss(postcss);
|
|
module.exports = postcss;
|
|
postcss.default = postcss;
|
|
});
|
|
|
|
// node_modules/sanitize-html/index.js
|
|
var require_sanitize_html = __commonJS((exports, module) => {
|
|
var htmlparser = require_lib6();
|
|
var escapeStringRegexp = require_escape_string_regexp();
|
|
var { isPlainObject } = require_is_plain_object();
|
|
var deepmerge = require_cjs();
|
|
var parseSrcset = require_parse_srcset();
|
|
var { parse: postcssParse } = require_postcss();
|
|
var mediaTags = [
|
|
"img",
|
|
"audio",
|
|
"video",
|
|
"picture",
|
|
"svg",
|
|
"object",
|
|
"map",
|
|
"iframe",
|
|
"embed"
|
|
];
|
|
var vulnerableTags = ["script", "style"];
|
|
function each(obj, cb) {
|
|
if (obj) {
|
|
Object.keys(obj).forEach(function(key) {
|
|
cb(obj[key], key);
|
|
});
|
|
}
|
|
}
|
|
function has(obj, key) {
|
|
return {}.hasOwnProperty.call(obj, key);
|
|
}
|
|
function filter(a, cb) {
|
|
const n = [];
|
|
each(a, function(v) {
|
|
if (cb(v)) {
|
|
n.push(v);
|
|
}
|
|
});
|
|
return n;
|
|
}
|
|
function isEmptyObject(obj) {
|
|
for (const key in obj) {
|
|
if (has(obj, key)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function stringifySrcset(parsedSrcset) {
|
|
return parsedSrcset.map(function(part) {
|
|
if (!part.url) {
|
|
throw new Error("URL missing");
|
|
}
|
|
return part.url + (part.w ? ` ${part.w}w` : "") + (part.h ? ` ${part.h}h` : "") + (part.d ? ` ${part.d}x` : "");
|
|
}).join(", ");
|
|
}
|
|
module.exports = sanitizeHtml;
|
|
var VALID_HTML_ATTRIBUTE_NAME = /^[^\0\t\n\f\r /<=>]+$/;
|
|
function sanitizeHtml(html, options, _recursing) {
|
|
if (html == null) {
|
|
return "";
|
|
}
|
|
if (typeof html === "number") {
|
|
html = html.toString();
|
|
}
|
|
let result = "";
|
|
let tempResult = "";
|
|
function Frame(tag, attribs) {
|
|
const that = this;
|
|
this.tag = tag;
|
|
this.attribs = attribs || {};
|
|
this.tagPosition = result.length;
|
|
this.text = "";
|
|
this.mediaChildren = [];
|
|
this.updateParentNodeText = function() {
|
|
if (stack.length) {
|
|
const parentFrame = stack[stack.length - 1];
|
|
parentFrame.text += that.text;
|
|
}
|
|
};
|
|
this.updateParentNodeMediaChildren = function() {
|
|
if (stack.length && mediaTags.includes(this.tag)) {
|
|
const parentFrame = stack[stack.length - 1];
|
|
parentFrame.mediaChildren.push(this.tag);
|
|
}
|
|
};
|
|
}
|
|
options = Object.assign({}, sanitizeHtml.defaults, options);
|
|
options.parser = Object.assign({}, htmlParserDefaults, options.parser);
|
|
const tagAllowed = function(name) {
|
|
return options.allowedTags === false || (options.allowedTags || []).indexOf(name) > -1;
|
|
};
|
|
vulnerableTags.forEach(function(tag) {
|
|
if (tagAllowed(tag) && !options.allowVulnerableTags) {
|
|
console.warn(`
|
|
|
|
\u26A0\uFE0F Your \`allowedTags\` option includes, \`${tag}\`, which is inherently\nvulnerable to XSS attacks. Please remove it from \`allowedTags\`.\nOr, to disable this warning, add the \`allowVulnerableTags\` option\nand ensure you are accounting for this risk.\n\n`);
|
|
}
|
|
});
|
|
const nonTextTagsArray = options.nonTextTags || [
|
|
"script",
|
|
"style",
|
|
"textarea",
|
|
"option"
|
|
];
|
|
let allowedAttributesMap;
|
|
let allowedAttributesGlobMap;
|
|
if (options.allowedAttributes) {
|
|
allowedAttributesMap = {};
|
|
allowedAttributesGlobMap = {};
|
|
each(options.allowedAttributes, function(attributes, tag) {
|
|
allowedAttributesMap[tag] = [];
|
|
const globRegex = [];
|
|
attributes.forEach(function(obj) {
|
|
if (typeof obj === "string" && obj.indexOf("*") >= 0) {
|
|
globRegex.push(escapeStringRegexp(obj).replace(/\\\*/g, ".*"));
|
|
} else {
|
|
allowedAttributesMap[tag].push(obj);
|
|
}
|
|
});
|
|
if (globRegex.length) {
|
|
allowedAttributesGlobMap[tag] = new RegExp("^(" + globRegex.join("|") + ")$");
|
|
}
|
|
});
|
|
}
|
|
const allowedClassesMap = {};
|
|
const allowedClassesGlobMap = {};
|
|
const allowedClassesRegexMap = {};
|
|
each(options.allowedClasses, function(classes, tag) {
|
|
if (allowedAttributesMap) {
|
|
if (!has(allowedAttributesMap, tag)) {
|
|
allowedAttributesMap[tag] = [];
|
|
}
|
|
allowedAttributesMap[tag].push("class");
|
|
}
|
|
allowedClassesMap[tag] = classes;
|
|
if (Array.isArray(classes)) {
|
|
const globRegex = [];
|
|
allowedClassesMap[tag] = [];
|
|
allowedClassesRegexMap[tag] = [];
|
|
classes.forEach(function(obj) {
|
|
if (typeof obj === "string" && obj.indexOf("*") >= 0) {
|
|
globRegex.push(escapeStringRegexp(obj).replace(/\\\*/g, ".*"));
|
|
} else if (obj instanceof RegExp) {
|
|
allowedClassesRegexMap[tag].push(obj);
|
|
} else {
|
|
allowedClassesMap[tag].push(obj);
|
|
}
|
|
});
|
|
if (globRegex.length) {
|
|
allowedClassesGlobMap[tag] = new RegExp("^(" + globRegex.join("|") + ")$");
|
|
}
|
|
}
|
|
});
|
|
const transformTagsMap = {};
|
|
let transformTagsAll;
|
|
each(options.transformTags, function(transform, tag) {
|
|
let transFun;
|
|
if (typeof transform === "function") {
|
|
transFun = transform;
|
|
} else if (typeof transform === "string") {
|
|
transFun = sanitizeHtml.simpleTransform(transform);
|
|
}
|
|
if (tag === "*") {
|
|
transformTagsAll = transFun;
|
|
} else {
|
|
transformTagsMap[tag] = transFun;
|
|
}
|
|
});
|
|
let depth;
|
|
let stack;
|
|
let skipMap;
|
|
let transformMap;
|
|
let skipText;
|
|
let skipTextDepth;
|
|
let addedText = false;
|
|
initializeState();
|
|
const parser = new htmlparser.Parser({
|
|
onopentag: function(name, attribs) {
|
|
if (options.enforceHtmlBoundary && name === "html") {
|
|
initializeState();
|
|
}
|
|
if (skipText) {
|
|
skipTextDepth++;
|
|
return;
|
|
}
|
|
const frame = new Frame(name, attribs);
|
|
stack.push(frame);
|
|
let skip = false;
|
|
const hasText = !!frame.text;
|
|
let transformedTag;
|
|
if (has(transformTagsMap, name)) {
|
|
transformedTag = transformTagsMap[name](name, attribs);
|
|
frame.attribs = attribs = transformedTag.attribs;
|
|
if (transformedTag.text !== undefined) {
|
|
frame.innerText = transformedTag.text;
|
|
}
|
|
if (name !== transformedTag.tagName) {
|
|
frame.name = name = transformedTag.tagName;
|
|
transformMap[depth] = transformedTag.tagName;
|
|
}
|
|
}
|
|
if (transformTagsAll) {
|
|
transformedTag = transformTagsAll(name, attribs);
|
|
frame.attribs = attribs = transformedTag.attribs;
|
|
if (name !== transformedTag.tagName) {
|
|
frame.name = name = transformedTag.tagName;
|
|
transformMap[depth] = transformedTag.tagName;
|
|
}
|
|
}
|
|
if (!tagAllowed(name) || options.disallowedTagsMode === "recursiveEscape" && !isEmptyObject(skipMap) || options.nestingLimit != null && depth >= options.nestingLimit) {
|
|
skip = true;
|
|
skipMap[depth] = true;
|
|
if (options.disallowedTagsMode === "discard" || options.disallowedTagsMode === "completelyDiscard") {
|
|
if (nonTextTagsArray.indexOf(name) !== -1) {
|
|
skipText = true;
|
|
skipTextDepth = 1;
|
|
}
|
|
}
|
|
skipMap[depth] = true;
|
|
}
|
|
depth++;
|
|
if (skip) {
|
|
if (options.disallowedTagsMode === "discard" || options.disallowedTagsMode === "completelyDiscard") {
|
|
return;
|
|
}
|
|
tempResult = result;
|
|
result = "";
|
|
}
|
|
result += "<" + name;
|
|
if (name === "script") {
|
|
if (options.allowedScriptHostnames || options.allowedScriptDomains) {
|
|
frame.innerText = "";
|
|
}
|
|
}
|
|
if (!allowedAttributesMap || has(allowedAttributesMap, name) || allowedAttributesMap["*"]) {
|
|
each(attribs, function(value, a) {
|
|
if (!VALID_HTML_ATTRIBUTE_NAME.test(a)) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
if (value === "" && !options.allowedEmptyAttributes.includes(a) && (options.nonBooleanAttributes.includes(a) || options.nonBooleanAttributes.includes("*"))) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
let passedAllowedAttributesMapCheck = false;
|
|
if (!allowedAttributesMap || has(allowedAttributesMap, name) && allowedAttributesMap[name].indexOf(a) !== -1 || allowedAttributesMap["*"] && allowedAttributesMap["*"].indexOf(a) !== -1 || has(allowedAttributesGlobMap, name) && allowedAttributesGlobMap[name].test(a) || allowedAttributesGlobMap["*"] && allowedAttributesGlobMap["*"].test(a)) {
|
|
passedAllowedAttributesMapCheck = true;
|
|
} else if (allowedAttributesMap && allowedAttributesMap[name]) {
|
|
for (const o of allowedAttributesMap[name]) {
|
|
if (isPlainObject(o) && o.name && o.name === a) {
|
|
passedAllowedAttributesMapCheck = true;
|
|
let newValue = "";
|
|
if (o.multiple === true) {
|
|
const splitStrArray = value.split(" ");
|
|
for (const s of splitStrArray) {
|
|
if (o.values.indexOf(s) !== -1) {
|
|
if (newValue === "") {
|
|
newValue = s;
|
|
} else {
|
|
newValue += " " + s;
|
|
}
|
|
}
|
|
}
|
|
} else if (o.values.indexOf(value) >= 0) {
|
|
newValue = value;
|
|
}
|
|
value = newValue;
|
|
}
|
|
}
|
|
}
|
|
if (passedAllowedAttributesMapCheck) {
|
|
if (options.allowedSchemesAppliedToAttributes.indexOf(a) !== -1) {
|
|
if (naughtyHref(name, value)) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
}
|
|
if (name === "script" && a === "src") {
|
|
let allowed = true;
|
|
try {
|
|
const parsed = parseUrl(value);
|
|
if (options.allowedScriptHostnames || options.allowedScriptDomains) {
|
|
const allowedHostname = (options.allowedScriptHostnames || []).find(function(hostname) {
|
|
return hostname === parsed.url.hostname;
|
|
});
|
|
const allowedDomain = (options.allowedScriptDomains || []).find(function(domain) {
|
|
return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);
|
|
});
|
|
allowed = allowedHostname || allowedDomain;
|
|
}
|
|
} catch (e) {
|
|
allowed = false;
|
|
}
|
|
if (!allowed) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
}
|
|
if (name === "iframe" && a === "src") {
|
|
let allowed = true;
|
|
try {
|
|
const parsed = parseUrl(value);
|
|
if (parsed.isRelativeUrl) {
|
|
allowed = has(options, "allowIframeRelativeUrls") ? options.allowIframeRelativeUrls : !options.allowedIframeHostnames && !options.allowedIframeDomains;
|
|
} else if (options.allowedIframeHostnames || options.allowedIframeDomains) {
|
|
const allowedHostname = (options.allowedIframeHostnames || []).find(function(hostname) {
|
|
return hostname === parsed.url.hostname;
|
|
});
|
|
const allowedDomain = (options.allowedIframeDomains || []).find(function(domain) {
|
|
return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);
|
|
});
|
|
allowed = allowedHostname || allowedDomain;
|
|
}
|
|
} catch (e) {
|
|
allowed = false;
|
|
}
|
|
if (!allowed) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
}
|
|
if (a === "srcset") {
|
|
try {
|
|
let parsed = parseSrcset(value);
|
|
parsed.forEach(function(value2) {
|
|
if (naughtyHref("srcset", value2.url)) {
|
|
value2.evil = true;
|
|
}
|
|
});
|
|
parsed = filter(parsed, function(v) {
|
|
return !v.evil;
|
|
});
|
|
if (!parsed.length) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
} else {
|
|
value = stringifySrcset(filter(parsed, function(v) {
|
|
return !v.evil;
|
|
}));
|
|
frame.attribs[a] = value;
|
|
}
|
|
} catch (e) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
}
|
|
if (a === "class") {
|
|
const allowedSpecificClasses = allowedClassesMap[name];
|
|
const allowedWildcardClasses = allowedClassesMap["*"];
|
|
const allowedSpecificClassesGlob = allowedClassesGlobMap[name];
|
|
const allowedSpecificClassesRegex = allowedClassesRegexMap[name];
|
|
const allowedWildcardClassesRegex = allowedClassesRegexMap["*"];
|
|
const allowedWildcardClassesGlob = allowedClassesGlobMap["*"];
|
|
const allowedClassesGlobs = [
|
|
allowedSpecificClassesGlob,
|
|
allowedWildcardClassesGlob
|
|
].concat(allowedSpecificClassesRegex, allowedWildcardClassesRegex).filter(function(t) {
|
|
return t;
|
|
});
|
|
if (allowedSpecificClasses && allowedWildcardClasses) {
|
|
value = filterClasses(value, deepmerge(allowedSpecificClasses, allowedWildcardClasses), allowedClassesGlobs);
|
|
} else {
|
|
value = filterClasses(value, allowedSpecificClasses || allowedWildcardClasses, allowedClassesGlobs);
|
|
}
|
|
if (!value.length) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
}
|
|
if (a === "style") {
|
|
if (options.parseStyleAttributes) {
|
|
try {
|
|
const abstractSyntaxTree = postcssParse(name + " {" + value + "}", { map: false });
|
|
const filteredAST = filterCss(abstractSyntaxTree, options.allowedStyles);
|
|
value = stringifyStyleAttributes(filteredAST);
|
|
if (value.length === 0) {
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
} catch (e) {
|
|
if (typeof window !== "undefined") {
|
|
console.warn('Failed to parse "' + name + " {" + value + "}" + '", If you\'re running this in a browser, we recommend to disable style parsing: options.parseStyleAttributes: false, since this only works in a node environment due to a postcss dependency, More info: https://github.com/apostrophecms/sanitize-html/issues/547');
|
|
}
|
|
delete frame.attribs[a];
|
|
return;
|
|
}
|
|
} else if (options.allowedStyles) {
|
|
throw new Error("allowedStyles option cannot be used together with parseStyleAttributes: false.");
|
|
}
|
|
}
|
|
result += " " + a;
|
|
if (value && value.length) {
|
|
result += '="' + escapeHtml(value, true) + '"';
|
|
} else if (options.allowedEmptyAttributes.includes(a)) {
|
|
result += '=""';
|
|
}
|
|
} else {
|
|
delete frame.attribs[a];
|
|
}
|
|
});
|
|
}
|
|
if (options.selfClosing.indexOf(name) !== -1) {
|
|
result += " />";
|
|
} else {
|
|
result += ">";
|
|
if (frame.innerText && !hasText && !options.textFilter) {
|
|
result += escapeHtml(frame.innerText);
|
|
addedText = true;
|
|
}
|
|
}
|
|
if (skip) {
|
|
result = tempResult + escapeHtml(result);
|
|
tempResult = "";
|
|
}
|
|
},
|
|
ontext: function(text) {
|
|
if (skipText) {
|
|
return;
|
|
}
|
|
const lastFrame = stack[stack.length - 1];
|
|
let tag;
|
|
if (lastFrame) {
|
|
tag = lastFrame.tag;
|
|
text = lastFrame.innerText !== undefined ? lastFrame.innerText : text;
|
|
}
|
|
if (options.disallowedTagsMode === "completelyDiscard" && !tagAllowed(tag)) {
|
|
text = "";
|
|
} else if ((options.disallowedTagsMode === "discard" || options.disallowedTagsMode === "completelyDiscard") && (tag === "script" || tag === "style")) {
|
|
result += text;
|
|
} else {
|
|
const escaped = escapeHtml(text, false);
|
|
if (options.textFilter && !addedText) {
|
|
result += options.textFilter(escaped, tag);
|
|
} else if (!addedText) {
|
|
result += escaped;
|
|
}
|
|
}
|
|
if (stack.length) {
|
|
const frame = stack[stack.length - 1];
|
|
frame.text += text;
|
|
}
|
|
},
|
|
onclosetag: function(name, isImplied) {
|
|
if (skipText) {
|
|
skipTextDepth--;
|
|
if (!skipTextDepth) {
|
|
skipText = false;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
const frame = stack.pop();
|
|
if (!frame) {
|
|
return;
|
|
}
|
|
if (frame.tag !== name) {
|
|
stack.push(frame);
|
|
return;
|
|
}
|
|
skipText = options.enforceHtmlBoundary ? name === "html" : false;
|
|
depth--;
|
|
const skip = skipMap[depth];
|
|
if (skip) {
|
|
delete skipMap[depth];
|
|
if (options.disallowedTagsMode === "discard" || options.disallowedTagsMode === "completelyDiscard") {
|
|
frame.updateParentNodeText();
|
|
return;
|
|
}
|
|
tempResult = result;
|
|
result = "";
|
|
}
|
|
if (transformMap[depth]) {
|
|
name = transformMap[depth];
|
|
delete transformMap[depth];
|
|
}
|
|
if (options.exclusiveFilter && options.exclusiveFilter(frame)) {
|
|
result = result.substr(0, frame.tagPosition);
|
|
return;
|
|
}
|
|
frame.updateParentNodeMediaChildren();
|
|
frame.updateParentNodeText();
|
|
if (options.selfClosing.indexOf(name) !== -1 || isImplied && !tagAllowed(name) && ["escape", "recursiveEscape"].indexOf(options.disallowedTagsMode) >= 0) {
|
|
if (skip) {
|
|
result = tempResult;
|
|
tempResult = "";
|
|
}
|
|
return;
|
|
}
|
|
result += "</" + name + ">";
|
|
if (skip) {
|
|
result = tempResult + escapeHtml(result);
|
|
tempResult = "";
|
|
}
|
|
addedText = false;
|
|
}
|
|
}, options.parser);
|
|
parser.write(html);
|
|
parser.end();
|
|
return result;
|
|
function initializeState() {
|
|
result = "";
|
|
depth = 0;
|
|
stack = [];
|
|
skipMap = {};
|
|
transformMap = {};
|
|
skipText = false;
|
|
skipTextDepth = 0;
|
|
}
|
|
function escapeHtml(s, quote) {
|
|
if (typeof s !== "string") {
|
|
s = s + "";
|
|
}
|
|
if (options.parser.decodeEntities) {
|
|
s = s.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
if (quote) {
|
|
s = s.replace(/"/g, """);
|
|
}
|
|
}
|
|
s = s.replace(/&(?![a-zA-Z0-9#]{1,20};)/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
if (quote) {
|
|
s = s.replace(/"/g, """);
|
|
}
|
|
return s;
|
|
}
|
|
function naughtyHref(name, href) {
|
|
href = href.replace(/[\x00-\x20]+/g, "");
|
|
while (true) {
|
|
const firstIndex = href.indexOf("<!--");
|
|
if (firstIndex === -1) {
|
|
break;
|
|
}
|
|
const lastIndex = href.indexOf("-->", firstIndex + 4);
|
|
if (lastIndex === -1) {
|
|
break;
|
|
}
|
|
href = href.substring(0, firstIndex) + href.substring(lastIndex + 3);
|
|
}
|
|
const matches = href.match(/^([a-zA-Z][a-zA-Z0-9.\-+]*):/);
|
|
if (!matches) {
|
|
if (href.match(/^[/\\]{2}/)) {
|
|
return !options.allowProtocolRelative;
|
|
}
|
|
return false;
|
|
}
|
|
const scheme = matches[1].toLowerCase();
|
|
if (has(options.allowedSchemesByTag, name)) {
|
|
return options.allowedSchemesByTag[name].indexOf(scheme) === -1;
|
|
}
|
|
return !options.allowedSchemes || options.allowedSchemes.indexOf(scheme) === -1;
|
|
}
|
|
function parseUrl(value) {
|
|
value = value.replace(/^(\w+:)?\s*[\\/]\s*[\\/]/, "$1//");
|
|
if (value.startsWith("relative:")) {
|
|
throw new Error("relative: exploit attempt");
|
|
}
|
|
let base = "relative://relative-site";
|
|
for (let i = 0;i < 100; i++) {
|
|
base += `/${i}`;
|
|
}
|
|
const parsed = new URL(value, base);
|
|
const isRelativeUrl = parsed && parsed.hostname === "relative-site" && parsed.protocol === "relative:";
|
|
return {
|
|
isRelativeUrl,
|
|
url: parsed
|
|
};
|
|
}
|
|
function filterCss(abstractSyntaxTree, allowedStyles) {
|
|
if (!allowedStyles) {
|
|
return abstractSyntaxTree;
|
|
}
|
|
const astRules = abstractSyntaxTree.nodes[0];
|
|
let selectedRule;
|
|
if (allowedStyles[astRules.selector] && allowedStyles["*"]) {
|
|
selectedRule = deepmerge(allowedStyles[astRules.selector], allowedStyles["*"]);
|
|
} else {
|
|
selectedRule = allowedStyles[astRules.selector] || allowedStyles["*"];
|
|
}
|
|
if (selectedRule) {
|
|
abstractSyntaxTree.nodes[0].nodes = astRules.nodes.reduce(filterDeclarations(selectedRule), []);
|
|
}
|
|
return abstractSyntaxTree;
|
|
}
|
|
function stringifyStyleAttributes(filteredAST) {
|
|
return filteredAST.nodes[0].nodes.reduce(function(extractedAttributes, attrObject) {
|
|
extractedAttributes.push(`${attrObject.prop}:${attrObject.value}${attrObject.important ? " !important" : ""}`);
|
|
return extractedAttributes;
|
|
}, []).join(";");
|
|
}
|
|
function filterDeclarations(selectedRule) {
|
|
return function(allowedDeclarationsList, attributeObject) {
|
|
if (has(selectedRule, attributeObject.prop)) {
|
|
const matchesRegex = selectedRule[attributeObject.prop].some(function(regularExpression) {
|
|
return regularExpression.test(attributeObject.value);
|
|
});
|
|
if (matchesRegex) {
|
|
allowedDeclarationsList.push(attributeObject);
|
|
}
|
|
}
|
|
return allowedDeclarationsList;
|
|
};
|
|
}
|
|
function filterClasses(classes, allowed, allowedGlobs) {
|
|
if (!allowed) {
|
|
return classes;
|
|
}
|
|
classes = classes.split(/\s+/);
|
|
return classes.filter(function(clss) {
|
|
return allowed.indexOf(clss) !== -1 || allowedGlobs.some(function(glob) {
|
|
return glob.test(clss);
|
|
});
|
|
}).join(" ");
|
|
}
|
|
}
|
|
var htmlParserDefaults = {
|
|
decodeEntities: true
|
|
};
|
|
sanitizeHtml.defaults = {
|
|
allowedTags: [
|
|
"address",
|
|
"article",
|
|
"aside",
|
|
"footer",
|
|
"header",
|
|
"h1",
|
|
"h2",
|
|
"h3",
|
|
"h4",
|
|
"h5",
|
|
"h6",
|
|
"hgroup",
|
|
"main",
|
|
"nav",
|
|
"section",
|
|
"blockquote",
|
|
"dd",
|
|
"div",
|
|
"dl",
|
|
"dt",
|
|
"figcaption",
|
|
"figure",
|
|
"hr",
|
|
"li",
|
|
"main",
|
|
"ol",
|
|
"p",
|
|
"pre",
|
|
"ul",
|
|
"a",
|
|
"abbr",
|
|
"b",
|
|
"bdi",
|
|
"bdo",
|
|
"br",
|
|
"cite",
|
|
"code",
|
|
"data",
|
|
"dfn",
|
|
"em",
|
|
"i",
|
|
"kbd",
|
|
"mark",
|
|
"q",
|
|
"rb",
|
|
"rp",
|
|
"rt",
|
|
"rtc",
|
|
"ruby",
|
|
"s",
|
|
"samp",
|
|
"small",
|
|
"span",
|
|
"strong",
|
|
"sub",
|
|
"sup",
|
|
"time",
|
|
"u",
|
|
"var",
|
|
"wbr",
|
|
"caption",
|
|
"col",
|
|
"colgroup",
|
|
"table",
|
|
"tbody",
|
|
"td",
|
|
"tfoot",
|
|
"th",
|
|
"thead",
|
|
"tr"
|
|
],
|
|
nonBooleanAttributes: [
|
|
"abbr",
|
|
"accept",
|
|
"accept-charset",
|
|
"accesskey",
|
|
"action",
|
|
"allow",
|
|
"alt",
|
|
"as",
|
|
"autocapitalize",
|
|
"autocomplete",
|
|
"blocking",
|
|
"charset",
|
|
"cite",
|
|
"class",
|
|
"color",
|
|
"cols",
|
|
"colspan",
|
|
"content",
|
|
"contenteditable",
|
|
"coords",
|
|
"crossorigin",
|
|
"data",
|
|
"datetime",
|
|
"decoding",
|
|
"dir",
|
|
"dirname",
|
|
"download",
|
|
"draggable",
|
|
"enctype",
|
|
"enterkeyhint",
|
|
"fetchpriority",
|
|
"for",
|
|
"form",
|
|
"formaction",
|
|
"formenctype",
|
|
"formmethod",
|
|
"formtarget",
|
|
"headers",
|
|
"height",
|
|
"hidden",
|
|
"high",
|
|
"href",
|
|
"hreflang",
|
|
"http-equiv",
|
|
"id",
|
|
"imagesizes",
|
|
"imagesrcset",
|
|
"inputmode",
|
|
"integrity",
|
|
"is",
|
|
"itemid",
|
|
"itemprop",
|
|
"itemref",
|
|
"itemtype",
|
|
"kind",
|
|
"label",
|
|
"lang",
|
|
"list",
|
|
"loading",
|
|
"low",
|
|
"max",
|
|
"maxlength",
|
|
"media",
|
|
"method",
|
|
"min",
|
|
"minlength",
|
|
"name",
|
|
"nonce",
|
|
"optimum",
|
|
"pattern",
|
|
"ping",
|
|
"placeholder",
|
|
"popover",
|
|
"popovertarget",
|
|
"popovertargetaction",
|
|
"poster",
|
|
"preload",
|
|
"referrerpolicy",
|
|
"rel",
|
|
"rows",
|
|
"rowspan",
|
|
"sandbox",
|
|
"scope",
|
|
"shape",
|
|
"size",
|
|
"sizes",
|
|
"slot",
|
|
"span",
|
|
"spellcheck",
|
|
"src",
|
|
"srcdoc",
|
|
"srclang",
|
|
"srcset",
|
|
"start",
|
|
"step",
|
|
"style",
|
|
"tabindex",
|
|
"target",
|
|
"title",
|
|
"translate",
|
|
"type",
|
|
"usemap",
|
|
"value",
|
|
"width",
|
|
"wrap",
|
|
"onauxclick",
|
|
"onafterprint",
|
|
"onbeforematch",
|
|
"onbeforeprint",
|
|
"onbeforeunload",
|
|
"onbeforetoggle",
|
|
"onblur",
|
|
"oncancel",
|
|
"oncanplay",
|
|
"oncanplaythrough",
|
|
"onchange",
|
|
"onclick",
|
|
"onclose",
|
|
"oncontextlost",
|
|
"oncontextmenu",
|
|
"oncontextrestored",
|
|
"oncopy",
|
|
"oncuechange",
|
|
"oncut",
|
|
"ondblclick",
|
|
"ondrag",
|
|
"ondragend",
|
|
"ondragenter",
|
|
"ondragleave",
|
|
"ondragover",
|
|
"ondragstart",
|
|
"ondrop",
|
|
"ondurationchange",
|
|
"onemptied",
|
|
"onended",
|
|
"onerror",
|
|
"onfocus",
|
|
"onformdata",
|
|
"onhashchange",
|
|
"oninput",
|
|
"oninvalid",
|
|
"onkeydown",
|
|
"onkeypress",
|
|
"onkeyup",
|
|
"onlanguagechange",
|
|
"onload",
|
|
"onloadeddata",
|
|
"onloadedmetadata",
|
|
"onloadstart",
|
|
"onmessage",
|
|
"onmessageerror",
|
|
"onmousedown",
|
|
"onmouseenter",
|
|
"onmouseleave",
|
|
"onmousemove",
|
|
"onmouseout",
|
|
"onmouseover",
|
|
"onmouseup",
|
|
"onoffline",
|
|
"ononline",
|
|
"onpagehide",
|
|
"onpageshow",
|
|
"onpaste",
|
|
"onpause",
|
|
"onplay",
|
|
"onplaying",
|
|
"onpopstate",
|
|
"onprogress",
|
|
"onratechange",
|
|
"onreset",
|
|
"onresize",
|
|
"onrejectionhandled",
|
|
"onscroll",
|
|
"onscrollend",
|
|
"onsecuritypolicyviolation",
|
|
"onseeked",
|
|
"onseeking",
|
|
"onselect",
|
|
"onslotchange",
|
|
"onstalled",
|
|
"onstorage",
|
|
"onsubmit",
|
|
"onsuspend",
|
|
"ontimeupdate",
|
|
"ontoggle",
|
|
"onunhandledrejection",
|
|
"onunload",
|
|
"onvolumechange",
|
|
"onwaiting",
|
|
"onwheel"
|
|
],
|
|
disallowedTagsMode: "discard",
|
|
allowedAttributes: {
|
|
a: ["href", "name", "target"],
|
|
img: ["src", "srcset", "alt", "title", "width", "height", "loading"]
|
|
},
|
|
allowedEmptyAttributes: [
|
|
"alt"
|
|
],
|
|
selfClosing: ["img", "br", "hr", "area", "base", "basefont", "input", "link", "meta"],
|
|
allowedSchemes: ["http", "https", "ftp", "mailto", "tel"],
|
|
allowedSchemesByTag: {},
|
|
allowedSchemesAppliedToAttributes: ["href", "src", "cite"],
|
|
allowProtocolRelative: true,
|
|
enforceHtmlBoundary: false,
|
|
parseStyleAttributes: true
|
|
};
|
|
sanitizeHtml.simpleTransform = function(newTagName, newAttribs, merge) {
|
|
merge = merge === undefined ? true : merge;
|
|
newAttribs = newAttribs || {};
|
|
return function(tagName, attribs) {
|
|
let attrib;
|
|
if (merge) {
|
|
for (attrib in newAttribs) {
|
|
attribs[attrib] = newAttribs[attrib];
|
|
}
|
|
} else {
|
|
attribs = newAttribs;
|
|
}
|
|
return {
|
|
tagName: newTagName,
|
|
attribs
|
|
};
|
|
};
|
|
};
|
|
});
|
|
|
|
// package-shared/utils/backend/global-db/DB_HANDLER.ts
|
|
async function DB_HANDLER(...args) {
|
|
try {
|
|
const results = await MASTER.query(...args);
|
|
await MASTER.end();
|
|
return JSON.parse(JSON.stringify(results));
|
|
} catch (error) {
|
|
console.log("DB Error =>", error);
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
var import_serverless_mysql3, MASTER;
|
|
var init_DB_HANDLER = __esm(() => {
|
|
import_serverless_mysql3 = __toESM(require_serverless_mysql(), 1);
|
|
init_grabDbSSL();
|
|
MASTER = import_serverless_mysql3.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_USERNAME,
|
|
password: process.env.DSQL_DB_PASSWORD,
|
|
database: process.env.DSQL_DB_NAME,
|
|
port: process.env.DSQL_DB_PORT ? Number(process.env.DSQL_DB_PORT) : undefined,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
});
|
|
|
|
// package-shared/functions/dsql/encrypt.ts
|
|
var exports_encrypt = {};
|
|
__export(exports_encrypt, {
|
|
default: () => encrypt
|
|
});
|
|
import { scryptSync as scryptSync2, createCipheriv } from "crypto";
|
|
import { Buffer as Buffer3 } from "buffer";
|
|
function encrypt({
|
|
data,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
}) {
|
|
if (!data?.match(/./)) {
|
|
console.log("Encryption string is invalid");
|
|
return data;
|
|
}
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
const finalKeyLen = process.env.DSQL_ENCRYPTION_KEY_LENGTH ? Number(process.env.DSQL_ENCRYPTION_KEY_LENGTH) : 24;
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
console.log("Encryption key is invalid");
|
|
return data;
|
|
}
|
|
if (!finalEncryptionSalt?.match(/.{8,}/)) {
|
|
console.log("Encryption salt is invalid");
|
|
return data;
|
|
}
|
|
const algorithm = "aes-192-cbc";
|
|
const password = finalEncryptionKey;
|
|
let key = scryptSync2(password, finalEncryptionSalt, finalKeyLen);
|
|
let iv = Buffer3.alloc(16, 0);
|
|
const cipher = createCipheriv(algorithm, key, iv);
|
|
try {
|
|
let encrypted = cipher.update(data, "utf8", "hex");
|
|
encrypted += cipher.final("hex");
|
|
return encrypted;
|
|
} catch (error) {
|
|
console.log("Error in encrypting =>", error.message);
|
|
return data;
|
|
}
|
|
}
|
|
var init_encrypt = __esm(() => {
|
|
module_encrypt.exports = encrypt;
|
|
});
|
|
|
|
// package-shared/functions/backend/db/deleteDbEntry.ts
|
|
async function deleteDbEntry({
|
|
dbContext,
|
|
paradigm,
|
|
dbFullName,
|
|
tableName,
|
|
identifierColumnName,
|
|
identifierValue,
|
|
useLocal
|
|
}) {
|
|
try {
|
|
const isMaster = useLocal ? true : dbContext?.match(/dsql.user/i) ? false : dbFullName && !dbFullName.match(/^datasquirel$/) ? false : true;
|
|
const dbHandler = useLocal ? LOCAL_DB_HANDLER : isMaster ? DB_HANDLER : DSQL_USER_DB_HANDLER;
|
|
const query = `DELETE FROM ${tableName} WHERE \`${identifierColumnName}\`=?`;
|
|
const deletedEntry = isMaster ? await dbHandler(query, [identifierValue]) : await dbHandler({
|
|
paradigm,
|
|
queryString: query,
|
|
database: dbFullName,
|
|
queryValues: [identifierValue]
|
|
});
|
|
return deletedEntry;
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
}
|
|
var init_deleteDbEntry = __esm(() => {
|
|
init_DB_HANDLER();
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_LOCAL_DB_HANDLER();
|
|
});
|
|
|
|
// package-shared/utils/ejson.ts
|
|
function parse(string, reviver) {
|
|
if (!string)
|
|
return;
|
|
if (typeof string == "object")
|
|
return string;
|
|
if (typeof string !== "string")
|
|
return;
|
|
try {
|
|
return JSON.parse(string, reviver);
|
|
} catch (error) {
|
|
return;
|
|
}
|
|
}
|
|
function stringify(value, replacer, space) {
|
|
try {
|
|
return JSON.stringify(value, replacer, space);
|
|
} catch (error) {
|
|
return;
|
|
}
|
|
}
|
|
var EJSON, ejson_default;
|
|
var init_ejson = __esm(() => {
|
|
EJSON = {
|
|
parse,
|
|
stringify
|
|
};
|
|
ejson_default = EJSON;
|
|
});
|
|
|
|
// package-shared/data/defaultFields.json
|
|
var require_defaultFields = __commonJS((exports, module) => {
|
|
module.exports = [
|
|
{
|
|
fieldName: "id",
|
|
dataType: "BIGINT",
|
|
notNullValue: true,
|
|
primaryKey: true,
|
|
autoIncrement: true
|
|
},
|
|
{
|
|
fieldName: "uuid",
|
|
dataType: "UUID",
|
|
defaultValueLiteral: "UUID()"
|
|
},
|
|
{
|
|
fieldName: "date_created",
|
|
dataType: "VARCHAR(250)",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "date_created_code",
|
|
dataType: "BIGINT",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "date_created_timestamp",
|
|
dataType: "TIMESTAMP",
|
|
defaultValueLiteral: "CURRENT_TIMESTAMP"
|
|
},
|
|
{
|
|
fieldName: "date_updated",
|
|
dataType: "VARCHAR(250)",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "date_updated_code",
|
|
dataType: "BIGINT",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "date_updated_timestamp",
|
|
dataType: "TIMESTAMP",
|
|
defaultValueLiteral: "CURRENT_TIMESTAMP",
|
|
onUpdateLiteral: "CURRENT_TIMESTAMP"
|
|
}
|
|
];
|
|
});
|
|
|
|
// node_modules/dotenv/package.json
|
|
var require_package = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
name: "dotenv",
|
|
version: "16.3.1",
|
|
description: "Loads environment variables from .env file",
|
|
main: "lib/main.js",
|
|
types: "lib/main.d.ts",
|
|
exports: {
|
|
".": {
|
|
types: "./lib/main.d.ts",
|
|
require: "./lib/main.js",
|
|
default: "./lib/main.js"
|
|
},
|
|
"./config": "./config.js",
|
|
"./config.js": "./config.js",
|
|
"./lib/env-options": "./lib/env-options.js",
|
|
"./lib/env-options.js": "./lib/env-options.js",
|
|
"./lib/cli-options": "./lib/cli-options.js",
|
|
"./lib/cli-options.js": "./lib/cli-options.js",
|
|
"./package.json": "./package.json"
|
|
},
|
|
scripts: {
|
|
"dts-check": "tsc --project tests/types/tsconfig.json",
|
|
lint: "standard",
|
|
"lint-readme": "standard-markdown",
|
|
pretest: "npm run lint && npm run dts-check",
|
|
test: "tap tests/*.js --100 -Rspec",
|
|
prerelease: "npm test",
|
|
release: "standard-version"
|
|
},
|
|
repository: {
|
|
type: "git",
|
|
url: "git://github.com/motdotla/dotenv.git"
|
|
},
|
|
funding: "https://github.com/motdotla/dotenv?sponsor=1",
|
|
keywords: [
|
|
"dotenv",
|
|
"env",
|
|
".env",
|
|
"environment",
|
|
"variables",
|
|
"config",
|
|
"settings"
|
|
],
|
|
readmeFilename: "README.md",
|
|
license: "BSD-2-Clause",
|
|
devDependencies: {
|
|
"@definitelytyped/dtslint": "^0.0.133",
|
|
"@types/node": "^18.11.3",
|
|
decache: "^4.6.1",
|
|
sinon: "^14.0.1",
|
|
standard: "^17.0.0",
|
|
"standard-markdown": "^7.1.0",
|
|
"standard-version": "^9.5.0",
|
|
tap: "^16.3.0",
|
|
tar: "^6.1.11",
|
|
typescript: "^4.8.4"
|
|
},
|
|
engines: {
|
|
node: ">=12"
|
|
},
|
|
browser: {
|
|
fs: false
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/dotenv/lib/main.js
|
|
var require_main = __commonJS((exports, module) => {
|
|
var fs10 = __require("fs");
|
|
var path6 = __require("path");
|
|
var os = __require("os");
|
|
var crypto2 = __require("crypto");
|
|
var packageJson = require_package();
|
|
var version = packageJson.version;
|
|
var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
|
|
function parse2(src) {
|
|
const obj = {};
|
|
let lines = src.toString();
|
|
lines = lines.replace(/\r\n?/mg, "\n");
|
|
let match;
|
|
while ((match = LINE.exec(lines)) != null) {
|
|
const key = match[1];
|
|
let value = match[2] || "";
|
|
value = value.trim();
|
|
const maybeQuote = value[0];
|
|
value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
|
|
if (maybeQuote === '"') {
|
|
value = value.replace(/\\n/g, "\n");
|
|
value = value.replace(/\\r/g, "\r");
|
|
}
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _parseVault(options) {
|
|
const vaultPath = _vaultPath(options);
|
|
const result = DotenvModule.configDotenv({ path: vaultPath });
|
|
if (!result.parsed) {
|
|
throw new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
|
|
}
|
|
const keys = _dotenvKey(options).split(",");
|
|
const length = keys.length;
|
|
let decrypted;
|
|
for (let i = 0;i < length; i++) {
|
|
try {
|
|
const key = keys[i].trim();
|
|
const attrs = _instructions(result, key);
|
|
decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
|
|
break;
|
|
} catch (error) {
|
|
if (i + 1 >= length) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
return DotenvModule.parse(decrypted);
|
|
}
|
|
function _log(message) {
|
|
console.log(`[dotenv@${version}][INFO] ${message}`);
|
|
}
|
|
function _warn(message) {
|
|
console.log(`[dotenv@${version}][WARN] ${message}`);
|
|
}
|
|
function _debug(message) {
|
|
console.log(`[dotenv@${version}][DEBUG] ${message}`);
|
|
}
|
|
function _dotenvKey(options) {
|
|
if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
|
|
return options.DOTENV_KEY;
|
|
}
|
|
if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
|
|
return process.env.DOTENV_KEY;
|
|
}
|
|
return "";
|
|
}
|
|
function _instructions(result, dotenvKey) {
|
|
let uri;
|
|
try {
|
|
uri = new URL(dotenvKey);
|
|
} catch (error) {
|
|
if (error.code === "ERR_INVALID_URL") {
|
|
throw new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenv.org/vault/.env.vault?environment=development");
|
|
}
|
|
throw error;
|
|
}
|
|
const key = uri.password;
|
|
if (!key) {
|
|
throw new Error("INVALID_DOTENV_KEY: Missing key part");
|
|
}
|
|
const environment = uri.searchParams.get("environment");
|
|
if (!environment) {
|
|
throw new Error("INVALID_DOTENV_KEY: Missing environment part");
|
|
}
|
|
const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
|
|
const ciphertext = result.parsed[environmentKey];
|
|
if (!ciphertext) {
|
|
throw new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
|
|
}
|
|
return { ciphertext, key };
|
|
}
|
|
function _vaultPath(options) {
|
|
let dotenvPath = path6.resolve(process.cwd(), ".env");
|
|
if (options && options.path && options.path.length > 0) {
|
|
dotenvPath = options.path;
|
|
}
|
|
return dotenvPath.endsWith(".vault") ? dotenvPath : `${dotenvPath}.vault`;
|
|
}
|
|
function _resolveHome(envPath) {
|
|
return envPath[0] === "~" ? path6.join(os.homedir(), envPath.slice(1)) : envPath;
|
|
}
|
|
function _configVault(options) {
|
|
_log("Loading env from encrypted .env.vault");
|
|
const parsed = DotenvModule._parseVault(options);
|
|
let processEnv = process.env;
|
|
if (options && options.processEnv != null) {
|
|
processEnv = options.processEnv;
|
|
}
|
|
DotenvModule.populate(processEnv, parsed, options);
|
|
return { parsed };
|
|
}
|
|
function configDotenv(options) {
|
|
let dotenvPath = path6.resolve(process.cwd(), ".env");
|
|
let encoding = "utf8";
|
|
const debug = Boolean(options && options.debug);
|
|
if (options) {
|
|
if (options.path != null) {
|
|
dotenvPath = _resolveHome(options.path);
|
|
}
|
|
if (options.encoding != null) {
|
|
encoding = options.encoding;
|
|
}
|
|
}
|
|
try {
|
|
const parsed = DotenvModule.parse(fs10.readFileSync(dotenvPath, { encoding }));
|
|
let processEnv = process.env;
|
|
if (options && options.processEnv != null) {
|
|
processEnv = options.processEnv;
|
|
}
|
|
DotenvModule.populate(processEnv, parsed, options);
|
|
return { parsed };
|
|
} catch (e) {
|
|
if (debug) {
|
|
_debug(`Failed to load ${dotenvPath} ${e.message}`);
|
|
}
|
|
return { error: e };
|
|
}
|
|
}
|
|
function config(options) {
|
|
const vaultPath = _vaultPath(options);
|
|
if (_dotenvKey(options).length === 0) {
|
|
return DotenvModule.configDotenv(options);
|
|
}
|
|
if (!fs10.existsSync(vaultPath)) {
|
|
_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
|
|
return DotenvModule.configDotenv(options);
|
|
}
|
|
return DotenvModule._configVault(options);
|
|
}
|
|
function decrypt2(encrypted, keyStr) {
|
|
const key = Buffer.from(keyStr.slice(-64), "hex");
|
|
let ciphertext = Buffer.from(encrypted, "base64");
|
|
const nonce = ciphertext.slice(0, 12);
|
|
const authTag = ciphertext.slice(-16);
|
|
ciphertext = ciphertext.slice(12, -16);
|
|
try {
|
|
const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
|
|
aesgcm.setAuthTag(authTag);
|
|
return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
|
|
} catch (error) {
|
|
const isRange = error instanceof RangeError;
|
|
const invalidKeyLength = error.message === "Invalid key length";
|
|
const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
|
|
if (isRange || invalidKeyLength) {
|
|
const msg = "INVALID_DOTENV_KEY: It must be 64 characters long (or more)";
|
|
throw new Error(msg);
|
|
} else if (decryptionFailed) {
|
|
const msg = "DECRYPTION_FAILED: Please check your DOTENV_KEY";
|
|
throw new Error(msg);
|
|
} else {
|
|
console.error("Error: ", error.code);
|
|
console.error("Error: ", error.message);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
function populate(processEnv, parsed, options = {}) {
|
|
const debug = Boolean(options && options.debug);
|
|
const override = Boolean(options && options.override);
|
|
if (typeof parsed !== "object") {
|
|
throw new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
|
|
}
|
|
for (const key of Object.keys(parsed)) {
|
|
if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
|
|
if (override === true) {
|
|
processEnv[key] = parsed[key];
|
|
}
|
|
if (debug) {
|
|
if (override === true) {
|
|
_debug(`"${key}" is already defined and WAS overwritten`);
|
|
} else {
|
|
_debug(`"${key}" is already defined and was NOT overwritten`);
|
|
}
|
|
}
|
|
} else {
|
|
processEnv[key] = parsed[key];
|
|
}
|
|
}
|
|
}
|
|
var DotenvModule = {
|
|
configDotenv,
|
|
_configVault,
|
|
_parseVault,
|
|
config,
|
|
decrypt: decrypt2,
|
|
parse: parse2,
|
|
populate
|
|
};
|
|
exports.configDotenv = DotenvModule.configDotenv;
|
|
exports._configVault = DotenvModule._configVault;
|
|
exports._parseVault = DotenvModule._parseVault;
|
|
exports.config = DotenvModule.config;
|
|
exports.decrypt = DotenvModule.decrypt;
|
|
exports.parse = DotenvModule.parse;
|
|
exports.populate = DotenvModule.populate;
|
|
module.exports = DotenvModule;
|
|
});
|
|
|
|
// package-shared/data/possibleFields.json
|
|
var require_possibleFields = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
fieldName: "string",
|
|
dataType: "BIGINT",
|
|
nullValue: true,
|
|
primaryKey: true,
|
|
autoIncrement: true,
|
|
defaultValue: "CURRENT_TIMESTAMP",
|
|
defaultValueLiteral: "CURRENT_TIMESTAMP",
|
|
notNullValue: true,
|
|
foreignKey: {
|
|
foreignKeyName: "Name",
|
|
destinationTableName: "Table Name",
|
|
destinationTableColumnName: "Column Name",
|
|
cascadeDelete: true,
|
|
cascadeUpdate: true
|
|
},
|
|
onUpdate: "CURRENT_TIMESTAMP",
|
|
onUpdateLiteral: "CURRENT_TIMESTAMP",
|
|
onDelete: "CURRENT_TIMESTAMP",
|
|
onDeleteLiteral: "CURRENT_TIMESTAMP",
|
|
encrypted: false
|
|
};
|
|
});
|
|
|
|
// package-shared/data/dataTypes.json
|
|
var require_dataTypes = __commonJS((exports, module) => {
|
|
module.exports = [
|
|
{
|
|
title: "VARCHAR",
|
|
name: "VARCHAR",
|
|
value: "0-255",
|
|
argument: true,
|
|
description: "Varchar is simply letters and numbers within the range 0 - 255",
|
|
maxValue: 255
|
|
},
|
|
{
|
|
title: "TINYINT",
|
|
name: "TINYINT",
|
|
value: "0-100",
|
|
description: "TINYINT means Integers: 0 to 100",
|
|
maxValue: 127
|
|
},
|
|
{
|
|
title: "SMALLINT",
|
|
name: "SMALLINT",
|
|
value: "0-255",
|
|
description: "SMALLINT means Integers: 0 to 240933",
|
|
maxValue: 32767
|
|
},
|
|
{
|
|
title: "MEDIUMINT",
|
|
name: "MEDIUMINT",
|
|
value: "0-255",
|
|
description: "MEDIUMINT means Integers: 0 to 1245568545560",
|
|
maxValue: 8388607
|
|
},
|
|
{
|
|
title: "INT",
|
|
name: "INT",
|
|
value: "0-255",
|
|
description: "INT means Integers: 0 to 12560",
|
|
maxValue: 2147483647
|
|
},
|
|
{
|
|
title: "BIGINT",
|
|
name: "BIGINT",
|
|
value: "0-255",
|
|
description: "BIGINT means Integers: 0 to 1245569056767568545560",
|
|
maxValue: 2000000000000000000000000000000000000000000000000000000000000000
|
|
},
|
|
{
|
|
title: "TINYTEXT",
|
|
name: "TINYTEXT",
|
|
value: "0-255",
|
|
description: "Text with 255 max characters",
|
|
maxValue: 127
|
|
},
|
|
{
|
|
title: "TEXT",
|
|
name: "TEXT",
|
|
value: "0-100",
|
|
description: "MEDIUMTEXT is just text with max length 16,777,215",
|
|
maxValue: 127
|
|
},
|
|
{
|
|
title: "MEDIUMTEXT",
|
|
name: "MEDIUMTEXT",
|
|
value: "0-255",
|
|
description: "MEDIUMTEXT is just text with max length 16,777,215",
|
|
maxValue: 127
|
|
},
|
|
{
|
|
title: "LONGTEXT",
|
|
name: "LONGTEXT",
|
|
value: "0-255",
|
|
description: "LONGTEXT is just text with max length 4,294,967,295",
|
|
maxValue: 127
|
|
},
|
|
{
|
|
title: "UUID",
|
|
name: "UUID",
|
|
valueLiteral: "UUID()",
|
|
description: "A Unique ID"
|
|
}
|
|
];
|
|
});
|
|
|
|
// package-shared/data/presets/users.json
|
|
var require_users = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
tableName: "users",
|
|
tableFullName: "Users",
|
|
fields: [
|
|
{
|
|
fieldName: "first_name",
|
|
dataType: "VARCHAR(100)",
|
|
notNullValue: true
|
|
},
|
|
{
|
|
fieldName: "last_name",
|
|
dataType: "VARCHAR(100)",
|
|
notNullValue: true
|
|
},
|
|
{
|
|
fieldName: "email",
|
|
dataType: "VARCHAR(200)",
|
|
notNullValue: true
|
|
},
|
|
{
|
|
fieldName: "phone",
|
|
dataType: "VARCHAR(50)"
|
|
},
|
|
{
|
|
fieldName: "user_type",
|
|
dataType: "VARCHAR(20)",
|
|
defaultValue: "default"
|
|
},
|
|
{
|
|
fieldName: "username",
|
|
dataType: "VARCHAR(100)",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "password",
|
|
dataType: "TEXT"
|
|
},
|
|
{
|
|
fieldName: "image",
|
|
dataType: "VARCHAR(250)"
|
|
},
|
|
{
|
|
fieldName: "image_thumbnail",
|
|
dataType: "VARCHAR(250)"
|
|
},
|
|
{
|
|
fieldName: "address",
|
|
dataType: "VARCHAR(255)"
|
|
},
|
|
{
|
|
fieldName: "city",
|
|
dataType: "VARCHAR(50)"
|
|
},
|
|
{
|
|
fieldName: "state",
|
|
dataType: "VARCHAR(50)"
|
|
},
|
|
{
|
|
fieldName: "country",
|
|
dataType: "VARCHAR(50)"
|
|
},
|
|
{
|
|
fieldName: "zip_code",
|
|
dataType: "VARCHAR(50)"
|
|
},
|
|
{
|
|
fieldName: "social_login",
|
|
dataType: "TINYINT",
|
|
defaultValue: "0"
|
|
},
|
|
{
|
|
fieldName: "social_platform",
|
|
dataType: "VARCHAR(50)",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "social_id",
|
|
dataType: "VARCHAR(250)",
|
|
nullValue: true
|
|
},
|
|
{
|
|
fieldName: "more_user_data",
|
|
dataType: "BIGINT",
|
|
defaultValue: "0"
|
|
},
|
|
{
|
|
fieldName: "verification_status",
|
|
dataType: "TINYINT",
|
|
defaultValue: "0"
|
|
},
|
|
{
|
|
fieldName: "temp_login_code",
|
|
dataType: "VARCHAR(50)",
|
|
nullValue: true
|
|
}
|
|
]
|
|
};
|
|
});
|
|
|
|
// package-shared/functions/backend/varDatabaseDbHandler.ts
|
|
async function varDatabaseDbHandler2({
|
|
queryString,
|
|
queryValuesArray,
|
|
database,
|
|
tableSchema,
|
|
useLocal
|
|
}) {
|
|
const isMaster = useLocal ? true : database?.match(/^datasquirel$/) ? true : false;
|
|
const FINAL_DB_HANDLER = useLocal ? LOCAL_DB_HANDLER : isMaster ? DB_HANDLER : DSQL_USER_DB_HANDLER;
|
|
let results;
|
|
try {
|
|
if (queryString && queryValuesArray && Array.isArray(queryValuesArray) && queryValuesArray[0]) {
|
|
results = isMaster ? await FINAL_DB_HANDLER(queryString, queryValuesArray) : await FINAL_DB_HANDLER({
|
|
paradigm: "Full Access",
|
|
database,
|
|
queryString,
|
|
queryValues: queryValuesArray
|
|
});
|
|
} else {
|
|
results = isMaster ? await FINAL_DB_HANDLER(queryString) : await FINAL_DB_HANDLER({
|
|
paradigm: "Full Access",
|
|
database,
|
|
queryString
|
|
});
|
|
}
|
|
} catch (error) {
|
|
serverError({
|
|
component: "varDatabaseDbHandler/lines-29-32",
|
|
message: error.message
|
|
});
|
|
}
|
|
if (results && tableSchema) {
|
|
try {
|
|
const unparsedResults = results;
|
|
const parsedResults = await parseDbResults({
|
|
unparsedResults,
|
|
tableSchema
|
|
});
|
|
return parsedResults;
|
|
} catch (error) {
|
|
console.log("\x1B[31mvarDatabaseDbHandler ERROR\x1B[0m =>", database, error);
|
|
serverError({
|
|
component: "varDatabaseDbHandler/lines-52-53",
|
|
message: error.message
|
|
});
|
|
return null;
|
|
}
|
|
} else if (results) {
|
|
return results;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
var init_varDatabaseDbHandler = __esm(() => {
|
|
init_parseDbResults();
|
|
init_serverError();
|
|
init_DB_HANDLER();
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_LOCAL_DB_HANDLER();
|
|
});
|
|
|
|
// package-shared/functions/dsql/hashPassword.ts
|
|
var exports_hashPassword = {};
|
|
__export(exports_hashPassword, {
|
|
default: () => hashPassword
|
|
});
|
|
import { createHmac } from "crypto";
|
|
function hashPassword({
|
|
password,
|
|
encryptionKey
|
|
}) {
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
throw new Error("Encryption key is invalid");
|
|
}
|
|
const hmac = createHmac("sha512", finalEncryptionKey);
|
|
hmac.update(password);
|
|
let hashed = hmac.digest("base64");
|
|
return hashed;
|
|
}
|
|
var init_hashPassword = () => {
|
|
};
|
|
|
|
// package-shared/functions/backend/cookies/get-auth-cookie-names.ts
|
|
function getAuthCookieNames(params) {
|
|
const cookiesPrefix = process.env.DSQL_COOKIES_PREFIX || "dsql_";
|
|
const cookiesKeyName = process.env.DSQL_COOKIES_KEY_NAME || "key";
|
|
const cookiesCSRFName = process.env.DSQL_COOKIES_CSRF_NAME || "csrf";
|
|
const cookieOneTimeCodeName = process.env.DSQL_COOKIES_ONE_TIME_CODE_NAME || "one-time-code";
|
|
const targetDatabase = params?.database?.replace(/^datasquirel_user_\d+_/, "") || process.env.DSQL_DB_NAME?.replace(/^datasquirel_user_\d+_/, "");
|
|
let keyCookieName = cookiesPrefix;
|
|
if (params?.userId)
|
|
keyCookieName += `user_${params.userId}_`;
|
|
if (targetDatabase)
|
|
keyCookieName += `${targetDatabase}_`;
|
|
keyCookieName += cookiesKeyName;
|
|
let csrfCookieName = cookiesPrefix;
|
|
if (params?.userId)
|
|
csrfCookieName += `user_${params.userId}_`;
|
|
if (targetDatabase)
|
|
csrfCookieName += `${targetDatabase}_`;
|
|
csrfCookieName += cookiesCSRFName;
|
|
let oneTimeCodeName = cookiesPrefix;
|
|
if (params?.userId)
|
|
oneTimeCodeName += `user_${params.userId}_`;
|
|
if (targetDatabase)
|
|
oneTimeCodeName += `${targetDatabase}_`;
|
|
oneTimeCodeName += cookieOneTimeCodeName;
|
|
return {
|
|
keyCookieName,
|
|
csrfCookieName,
|
|
oneTimeCodeName
|
|
};
|
|
}
|
|
|
|
// node_modules/nodemailer/lib/fetch/cookies.js
|
|
var require_cookies = __commonJS((exports, module) => {
|
|
var urllib = __require("url");
|
|
var SESSION_TIMEOUT = 1800;
|
|
|
|
class Cookies {
|
|
constructor(options) {
|
|
this.options = options || {};
|
|
this.cookies = [];
|
|
}
|
|
set(cookieStr, url) {
|
|
let urlparts = urllib.parse(url || "");
|
|
let cookie = this.parse(cookieStr);
|
|
let domain;
|
|
if (cookie.domain) {
|
|
domain = cookie.domain.replace(/^\./, "");
|
|
if (urlparts.hostname.length < domain.length || ("." + urlparts.hostname).substr(-domain.length + 1) !== "." + domain) {
|
|
cookie.domain = urlparts.hostname;
|
|
}
|
|
} else {
|
|
cookie.domain = urlparts.hostname;
|
|
}
|
|
if (!cookie.path) {
|
|
cookie.path = this.getPath(urlparts.pathname);
|
|
}
|
|
if (!cookie.expires) {
|
|
cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1000);
|
|
}
|
|
return this.add(cookie);
|
|
}
|
|
get(url) {
|
|
return this.list(url).map((cookie) => cookie.name + "=" + cookie.value).join("; ");
|
|
}
|
|
list(url) {
|
|
let result = [];
|
|
let i;
|
|
let cookie;
|
|
for (i = this.cookies.length - 1;i >= 0; i--) {
|
|
cookie = this.cookies[i];
|
|
if (this.isExpired(cookie)) {
|
|
this.cookies.splice(i, i);
|
|
continue;
|
|
}
|
|
if (this.match(cookie, url)) {
|
|
result.unshift(cookie);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
parse(cookieStr) {
|
|
let cookie = {};
|
|
(cookieStr || "").toString().split(";").forEach((cookiePart) => {
|
|
let valueParts = cookiePart.split("=");
|
|
let key = valueParts.shift().trim().toLowerCase();
|
|
let value = valueParts.join("=").trim();
|
|
let domain;
|
|
if (!key) {
|
|
return;
|
|
}
|
|
switch (key) {
|
|
case "expires":
|
|
value = new Date(value);
|
|
if (value.toString() !== "Invalid Date") {
|
|
cookie.expires = value;
|
|
}
|
|
break;
|
|
case "path":
|
|
cookie.path = value;
|
|
break;
|
|
case "domain":
|
|
domain = value.toLowerCase();
|
|
if (domain.length && domain.charAt(0) !== ".") {
|
|
domain = "." + domain;
|
|
}
|
|
cookie.domain = domain;
|
|
break;
|
|
case "max-age":
|
|
cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1000);
|
|
break;
|
|
case "secure":
|
|
cookie.secure = true;
|
|
break;
|
|
case "httponly":
|
|
cookie.httponly = true;
|
|
break;
|
|
default:
|
|
if (!cookie.name) {
|
|
cookie.name = key;
|
|
cookie.value = value;
|
|
}
|
|
}
|
|
});
|
|
return cookie;
|
|
}
|
|
match(cookie, url) {
|
|
let urlparts = urllib.parse(url || "");
|
|
if (urlparts.hostname !== cookie.domain && (cookie.domain.charAt(0) !== "." || ("." + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
|
|
return false;
|
|
}
|
|
let path11 = this.getPath(urlparts.pathname);
|
|
if (path11.substr(0, cookie.path.length) !== cookie.path) {
|
|
return false;
|
|
}
|
|
if (cookie.secure && urlparts.protocol !== "https:") {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
add(cookie) {
|
|
let i;
|
|
let len;
|
|
if (!cookie || !cookie.name) {
|
|
return false;
|
|
}
|
|
for (i = 0, len = this.cookies.length;i < len; i++) {
|
|
if (this.compare(this.cookies[i], cookie)) {
|
|
if (this.isExpired(cookie)) {
|
|
this.cookies.splice(i, 1);
|
|
return false;
|
|
}
|
|
this.cookies[i] = cookie;
|
|
return true;
|
|
}
|
|
}
|
|
if (!this.isExpired(cookie)) {
|
|
this.cookies.push(cookie);
|
|
}
|
|
return true;
|
|
}
|
|
compare(a, b) {
|
|
return a.name === b.name && a.path === b.path && a.domain === b.domain && a.secure === b.secure && a.httponly === a.httponly;
|
|
}
|
|
isExpired(cookie) {
|
|
return cookie.expires && cookie.expires < new Date || !cookie.value;
|
|
}
|
|
getPath(pathname) {
|
|
let path11 = (pathname || "/").split("/");
|
|
path11.pop();
|
|
path11 = path11.join("/").trim();
|
|
if (path11.charAt(0) !== "/") {
|
|
path11 = "/" + path11;
|
|
}
|
|
if (path11.substr(-1) !== "/") {
|
|
path11 += "/";
|
|
}
|
|
return path11;
|
|
}
|
|
}
|
|
module.exports = Cookies;
|
|
});
|
|
|
|
// node_modules/nodemailer/package.json
|
|
var require_package2 = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
name: "nodemailer",
|
|
version: "6.9.14",
|
|
description: "Easy as cake e-mail sending from your Node.js applications",
|
|
main: "lib/nodemailer.js",
|
|
scripts: {
|
|
test: "node --test --test-concurrency=1 test/**/*.test.js test/**/*-test.js",
|
|
"test:coverage": "c8 node --test --test-concurrency=1 test/**/*.test.js test/**/*-test.js",
|
|
lint: "eslint .",
|
|
update: "rm -rf node_modules/ package-lock.json && ncu -u && npm install"
|
|
},
|
|
repository: {
|
|
type: "git",
|
|
url: "https://github.com/nodemailer/nodemailer.git"
|
|
},
|
|
keywords: [
|
|
"Nodemailer"
|
|
],
|
|
author: "Andris Reinman",
|
|
license: "MIT-0",
|
|
bugs: {
|
|
url: "https://github.com/nodemailer/nodemailer/issues"
|
|
},
|
|
homepage: "https://nodemailer.com/",
|
|
devDependencies: {
|
|
"@aws-sdk/client-ses": "3.600.0",
|
|
bunyan: "1.8.15",
|
|
c8: "10.1.2",
|
|
eslint: "8.57.0",
|
|
"eslint-config-nodemailer": "1.2.0",
|
|
"eslint-config-prettier": "9.1.0",
|
|
libbase64: "1.3.0",
|
|
libmime: "5.3.5",
|
|
libqp: "2.1.0",
|
|
"nodemailer-ntlm-auth": "1.0.4",
|
|
proxy: "1.0.2",
|
|
"proxy-test-server": "1.0.0",
|
|
"smtp-server": "3.13.4"
|
|
},
|
|
engines: {
|
|
node: ">=6.0.0"
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/fetch/index.js
|
|
var require_fetch = __commonJS((exports, module) => {
|
|
var http2 = __require("http");
|
|
var https2 = __require("https");
|
|
var urllib = __require("url");
|
|
var zlib = __require("zlib");
|
|
var PassThrough = __require("stream").PassThrough;
|
|
var Cookies = require_cookies();
|
|
var packageData = require_package2();
|
|
var net = __require("net");
|
|
var MAX_REDIRECTS = 5;
|
|
module.exports = function(url, options) {
|
|
return nmfetch(url, options);
|
|
};
|
|
module.exports.Cookies = Cookies;
|
|
function nmfetch(url, options) {
|
|
options = options || {};
|
|
options.fetchRes = options.fetchRes || new PassThrough;
|
|
options.cookies = options.cookies || new Cookies;
|
|
options.redirects = options.redirects || 0;
|
|
options.maxRedirects = isNaN(options.maxRedirects) ? MAX_REDIRECTS : options.maxRedirects;
|
|
if (options.cookie) {
|
|
[].concat(options.cookie || []).forEach((cookie) => {
|
|
options.cookies.set(cookie, url);
|
|
});
|
|
options.cookie = false;
|
|
}
|
|
let fetchRes = options.fetchRes;
|
|
let parsed = urllib.parse(url);
|
|
let method = (options.method || "").toString().trim().toUpperCase() || "GET";
|
|
let finished = false;
|
|
let cookies;
|
|
let body;
|
|
let handler = parsed.protocol === "https:" ? https2 : http2;
|
|
let headers = {
|
|
"accept-encoding": "gzip,deflate",
|
|
"user-agent": "nodemailer/" + packageData.version
|
|
};
|
|
Object.keys(options.headers || {}).forEach((key) => {
|
|
headers[key.toLowerCase().trim()] = options.headers[key];
|
|
});
|
|
if (options.userAgent) {
|
|
headers["user-agent"] = options.userAgent;
|
|
}
|
|
if (parsed.auth) {
|
|
headers.Authorization = "Basic " + Buffer.from(parsed.auth).toString("base64");
|
|
}
|
|
if (cookies = options.cookies.get(url)) {
|
|
headers.cookie = cookies;
|
|
}
|
|
if (options.body) {
|
|
if (options.contentType !== false) {
|
|
headers["Content-Type"] = options.contentType || "application/x-www-form-urlencoded";
|
|
}
|
|
if (typeof options.body.pipe === "function") {
|
|
headers["Transfer-Encoding"] = "chunked";
|
|
body = options.body;
|
|
body.on("error", (err) => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
});
|
|
} else {
|
|
if (options.body instanceof Buffer) {
|
|
body = options.body;
|
|
} else if (typeof options.body === "object") {
|
|
try {
|
|
body = Buffer.from(Object.keys(options.body).map((key) => {
|
|
let value = options.body[key].toString().trim();
|
|
return encodeURIComponent(key) + "=" + encodeURIComponent(value);
|
|
}).join("&"));
|
|
} catch (E) {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
E.type = "FETCH";
|
|
E.sourceUrl = url;
|
|
fetchRes.emit("error", E);
|
|
return;
|
|
}
|
|
} else {
|
|
body = Buffer.from(options.body.toString().trim());
|
|
}
|
|
headers["Content-Type"] = options.contentType || "application/x-www-form-urlencoded";
|
|
headers["Content-Length"] = body.length;
|
|
}
|
|
method = (options.method || "").toString().trim().toUpperCase() || "POST";
|
|
}
|
|
let req;
|
|
let reqOptions = {
|
|
method,
|
|
host: parsed.hostname,
|
|
path: parsed.path,
|
|
port: parsed.port ? parsed.port : parsed.protocol === "https:" ? 443 : 80,
|
|
headers,
|
|
rejectUnauthorized: false,
|
|
agent: false
|
|
};
|
|
if (options.tls) {
|
|
Object.keys(options.tls).forEach((key) => {
|
|
reqOptions[key] = options.tls[key];
|
|
});
|
|
}
|
|
if (parsed.protocol === "https:" && parsed.hostname && parsed.hostname !== reqOptions.host && !net.isIP(parsed.hostname) && !reqOptions.servername) {
|
|
reqOptions.servername = parsed.hostname;
|
|
}
|
|
try {
|
|
req = handler.request(reqOptions);
|
|
} catch (E) {
|
|
finished = true;
|
|
setImmediate(() => {
|
|
E.type = "FETCH";
|
|
E.sourceUrl = url;
|
|
fetchRes.emit("error", E);
|
|
});
|
|
return fetchRes;
|
|
}
|
|
if (options.timeout) {
|
|
req.setTimeout(options.timeout, () => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
req.abort();
|
|
let err = new Error("Request Timeout");
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
});
|
|
}
|
|
req.on("error", (err) => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
});
|
|
req.on("response", (res) => {
|
|
let inflate;
|
|
if (finished) {
|
|
return;
|
|
}
|
|
switch (res.headers["content-encoding"]) {
|
|
case "gzip":
|
|
case "deflate":
|
|
inflate = zlib.createUnzip();
|
|
break;
|
|
}
|
|
if (res.headers["set-cookie"]) {
|
|
[].concat(res.headers["set-cookie"] || []).forEach((cookie) => {
|
|
options.cookies.set(cookie, url);
|
|
});
|
|
}
|
|
if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
|
|
options.redirects++;
|
|
if (options.redirects > options.maxRedirects) {
|
|
finished = true;
|
|
let err = new Error("Maximum redirect count exceeded");
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
req.abort();
|
|
return;
|
|
}
|
|
options.method = "GET";
|
|
options.body = false;
|
|
return nmfetch(urllib.resolve(url, res.headers.location), options);
|
|
}
|
|
fetchRes.statusCode = res.statusCode;
|
|
fetchRes.headers = res.headers;
|
|
if (res.statusCode >= 300 && !options.allowErrorResponse) {
|
|
finished = true;
|
|
let err = new Error("Invalid status code " + res.statusCode);
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
req.abort();
|
|
return;
|
|
}
|
|
res.on("error", (err) => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
req.abort();
|
|
});
|
|
if (inflate) {
|
|
res.pipe(inflate).pipe(fetchRes);
|
|
inflate.on("error", (err) => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
req.abort();
|
|
});
|
|
} else {
|
|
res.pipe(fetchRes);
|
|
}
|
|
});
|
|
setImmediate(() => {
|
|
if (body) {
|
|
try {
|
|
if (typeof body.pipe === "function") {
|
|
return body.pipe(req);
|
|
} else {
|
|
req.write(body);
|
|
}
|
|
} catch (err) {
|
|
finished = true;
|
|
err.type = "FETCH";
|
|
err.sourceUrl = url;
|
|
fetchRes.emit("error", err);
|
|
return;
|
|
}
|
|
}
|
|
req.end();
|
|
});
|
|
return fetchRes;
|
|
}
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/shared/index.js
|
|
var require_shared = __commonJS((exports, module) => {
|
|
var urllib = __require("url");
|
|
var util = __require("util");
|
|
var fs15 = __require("fs");
|
|
var nmfetch = require_fetch();
|
|
var dns = __require("dns");
|
|
var net = __require("net");
|
|
var os = __require("os");
|
|
var DNS_TTL = 5 * 60 * 1000;
|
|
var networkInterfaces;
|
|
try {
|
|
networkInterfaces = os.networkInterfaces();
|
|
} catch (err) {
|
|
}
|
|
exports.networkInterfaces = networkInterfaces;
|
|
var isFamilySupported = (family, allowInternal) => {
|
|
let networkInterfaces2 = exports.networkInterfaces;
|
|
if (!networkInterfaces2) {
|
|
return true;
|
|
}
|
|
const familySupported = Object.keys(networkInterfaces2).map((key) => networkInterfaces2[key]).reduce((acc, val) => acc.concat(val), []).filter((i) => !i.internal || allowInternal).filter((i) => i.family === "IPv" + family || i.family === family).length > 0;
|
|
return familySupported;
|
|
};
|
|
var resolver = (family, hostname, options, callback) => {
|
|
options = options || {};
|
|
const familySupported = isFamilySupported(family, options.allowInternalNetworkInterfaces);
|
|
if (!familySupported) {
|
|
return callback(null, []);
|
|
}
|
|
const resolver2 = dns.Resolver ? new dns.Resolver(options) : dns;
|
|
resolver2["resolve" + family](hostname, (err, addresses) => {
|
|
if (err) {
|
|
switch (err.code) {
|
|
case dns.NODATA:
|
|
case dns.NOTFOUND:
|
|
case dns.NOTIMP:
|
|
case dns.SERVFAIL:
|
|
case dns.CONNREFUSED:
|
|
case dns.REFUSED:
|
|
case "EAI_AGAIN":
|
|
return callback(null, []);
|
|
}
|
|
return callback(err);
|
|
}
|
|
return callback(null, Array.isArray(addresses) ? addresses : [].concat(addresses || []));
|
|
});
|
|
};
|
|
var dnsCache = exports.dnsCache = new Map;
|
|
var formatDNSValue = (value, extra) => {
|
|
if (!value) {
|
|
return Object.assign({}, extra || {});
|
|
}
|
|
return Object.assign({
|
|
servername: value.servername,
|
|
host: !value.addresses || !value.addresses.length ? null : value.addresses.length === 1 ? value.addresses[0] : value.addresses[Math.floor(Math.random() * value.addresses.length)]
|
|
}, extra || {});
|
|
};
|
|
exports.resolveHostname = (options, callback) => {
|
|
options = options || {};
|
|
if (!options.host && options.servername) {
|
|
options.host = options.servername;
|
|
}
|
|
if (!options.host || net.isIP(options.host)) {
|
|
let value = {
|
|
addresses: [options.host],
|
|
servername: options.servername || false
|
|
};
|
|
return callback(null, formatDNSValue(value, {
|
|
cached: false
|
|
}));
|
|
}
|
|
let cached;
|
|
if (dnsCache.has(options.host)) {
|
|
cached = dnsCache.get(options.host);
|
|
if (!cached.expires || cached.expires >= Date.now()) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true
|
|
}));
|
|
}
|
|
}
|
|
resolver(4, options.host, options, (err, addresses) => {
|
|
if (err) {
|
|
if (cached) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true,
|
|
error: err
|
|
}));
|
|
}
|
|
return callback(err);
|
|
}
|
|
if (addresses && addresses.length) {
|
|
let value = {
|
|
addresses,
|
|
servername: options.servername || options.host
|
|
};
|
|
dnsCache.set(options.host, {
|
|
value,
|
|
expires: Date.now() + (options.dnsTtl || DNS_TTL)
|
|
});
|
|
return callback(null, formatDNSValue(value, {
|
|
cached: false
|
|
}));
|
|
}
|
|
resolver(6, options.host, options, (err2, addresses2) => {
|
|
if (err2) {
|
|
if (cached) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true,
|
|
error: err2
|
|
}));
|
|
}
|
|
return callback(err2);
|
|
}
|
|
if (addresses2 && addresses2.length) {
|
|
let value = {
|
|
addresses: addresses2,
|
|
servername: options.servername || options.host
|
|
};
|
|
dnsCache.set(options.host, {
|
|
value,
|
|
expires: Date.now() + (options.dnsTtl || DNS_TTL)
|
|
});
|
|
return callback(null, formatDNSValue(value, {
|
|
cached: false
|
|
}));
|
|
}
|
|
try {
|
|
dns.lookup(options.host, { all: true }, (err3, addresses3) => {
|
|
if (err3) {
|
|
if (cached) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true,
|
|
error: err3
|
|
}));
|
|
}
|
|
return callback(err3);
|
|
}
|
|
let address = addresses3 ? addresses3.filter((addr) => isFamilySupported(addr.family)).map((addr) => addr.address).shift() : false;
|
|
if (addresses3 && addresses3.length && !address) {
|
|
console.warn(`Failed to resolve IPv${addresses3[0].family} addresses with current network`);
|
|
}
|
|
if (!address && cached) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true
|
|
}));
|
|
}
|
|
let value = {
|
|
addresses: address ? [address] : [options.host],
|
|
servername: options.servername || options.host
|
|
};
|
|
dnsCache.set(options.host, {
|
|
value,
|
|
expires: Date.now() + (options.dnsTtl || DNS_TTL)
|
|
});
|
|
return callback(null, formatDNSValue(value, {
|
|
cached: false
|
|
}));
|
|
});
|
|
} catch (err3) {
|
|
if (cached) {
|
|
return callback(null, formatDNSValue(cached.value, {
|
|
cached: true,
|
|
error: err3
|
|
}));
|
|
}
|
|
return callback(err3);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
exports.parseConnectionUrl = (str) => {
|
|
str = str || "";
|
|
let options = {};
|
|
[urllib.parse(str, true)].forEach((url) => {
|
|
let auth;
|
|
switch (url.protocol) {
|
|
case "smtp:":
|
|
options.secure = false;
|
|
break;
|
|
case "smtps:":
|
|
options.secure = true;
|
|
break;
|
|
case "direct:":
|
|
options.direct = true;
|
|
break;
|
|
}
|
|
if (!isNaN(url.port) && Number(url.port)) {
|
|
options.port = Number(url.port);
|
|
}
|
|
if (url.hostname) {
|
|
options.host = url.hostname;
|
|
}
|
|
if (url.auth) {
|
|
auth = url.auth.split(":");
|
|
if (!options.auth) {
|
|
options.auth = {};
|
|
}
|
|
options.auth.user = auth.shift();
|
|
options.auth.pass = auth.join(":");
|
|
}
|
|
Object.keys(url.query || {}).forEach((key) => {
|
|
let obj = options;
|
|
let lKey = key;
|
|
let value = url.query[key];
|
|
if (!isNaN(value)) {
|
|
value = Number(value);
|
|
}
|
|
switch (value) {
|
|
case "true":
|
|
value = true;
|
|
break;
|
|
case "false":
|
|
value = false;
|
|
break;
|
|
}
|
|
if (key.indexOf("tls.") === 0) {
|
|
lKey = key.substr(4);
|
|
if (!options.tls) {
|
|
options.tls = {};
|
|
}
|
|
obj = options.tls;
|
|
} else if (key.indexOf(".") >= 0) {
|
|
return;
|
|
}
|
|
if (!(lKey in obj)) {
|
|
obj[lKey] = value;
|
|
}
|
|
});
|
|
});
|
|
return options;
|
|
};
|
|
exports._logFunc = (logger, level, defaults, data, message, ...args) => {
|
|
let entry = {};
|
|
Object.keys(defaults || {}).forEach((key) => {
|
|
if (key !== "level") {
|
|
entry[key] = defaults[key];
|
|
}
|
|
});
|
|
Object.keys(data || {}).forEach((key) => {
|
|
if (key !== "level") {
|
|
entry[key] = data[key];
|
|
}
|
|
});
|
|
logger[level](entry, message, ...args);
|
|
};
|
|
exports.getLogger = (options, defaults) => {
|
|
options = options || {};
|
|
let response = {};
|
|
let levels = ["trace", "debug", "info", "warn", "error", "fatal"];
|
|
if (!options.logger) {
|
|
levels.forEach((level) => {
|
|
response[level] = () => false;
|
|
});
|
|
return response;
|
|
}
|
|
let logger = options.logger;
|
|
if (options.logger === true) {
|
|
logger = createDefaultLogger(levels);
|
|
}
|
|
levels.forEach((level) => {
|
|
response[level] = (data, message, ...args) => {
|
|
exports._logFunc(logger, level, defaults, data, message, ...args);
|
|
};
|
|
});
|
|
return response;
|
|
};
|
|
exports.callbackPromise = (resolve, reject) => function() {
|
|
let args = Array.from(arguments);
|
|
let err = args.shift();
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(...args);
|
|
}
|
|
};
|
|
exports.parseDataURI = (uri) => {
|
|
let input = uri;
|
|
let commaPos = input.indexOf(",");
|
|
if (!commaPos) {
|
|
return uri;
|
|
}
|
|
let data = input.substring(commaPos + 1);
|
|
let metaStr = input.substring("data:".length, commaPos);
|
|
let encoding;
|
|
let metaEntries = metaStr.split(";");
|
|
let lastMetaEntry = metaEntries.length > 1 ? metaEntries[metaEntries.length - 1] : false;
|
|
if (lastMetaEntry && lastMetaEntry.indexOf("=") < 0) {
|
|
encoding = lastMetaEntry.toLowerCase();
|
|
metaEntries.pop();
|
|
}
|
|
let contentType = metaEntries.shift() || "application/octet-stream";
|
|
let params = {};
|
|
for (let entry of metaEntries) {
|
|
let sep = entry.indexOf("=");
|
|
if (sep >= 0) {
|
|
let key = entry.substring(0, sep);
|
|
let value = entry.substring(sep + 1);
|
|
params[key] = value;
|
|
}
|
|
}
|
|
switch (encoding) {
|
|
case "base64":
|
|
data = Buffer.from(data, "base64");
|
|
break;
|
|
case "utf8":
|
|
data = Buffer.from(data);
|
|
break;
|
|
default:
|
|
try {
|
|
data = Buffer.from(decodeURIComponent(data));
|
|
} catch (err) {
|
|
data = Buffer.from(data);
|
|
}
|
|
data = Buffer.from(data);
|
|
}
|
|
return { data, encoding, contentType, params };
|
|
};
|
|
exports.resolveContent = (data, key, callback) => {
|
|
let promise;
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = exports.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
let content = data && data[key] && data[key].content || data[key];
|
|
let contentStream;
|
|
let encoding = (typeof data[key] === "object" && data[key].encoding || "utf8").toString().toLowerCase().replace(/[-_\s]/g, "");
|
|
if (!content) {
|
|
return callback(null, content);
|
|
}
|
|
if (typeof content === "object") {
|
|
if (typeof content.pipe === "function") {
|
|
return resolveStream(content, (err, value) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
if (data[key].content) {
|
|
data[key].content = value;
|
|
} else {
|
|
data[key] = value;
|
|
}
|
|
callback(null, value);
|
|
});
|
|
} else if (/^https?:\/\//i.test(content.path || content.href)) {
|
|
contentStream = nmfetch(content.path || content.href);
|
|
return resolveStream(contentStream, callback);
|
|
} else if (/^data:/i.test(content.path || content.href)) {
|
|
let parsedDataUri = exports.parseDataURI(content.path || content.href);
|
|
if (!parsedDataUri || !parsedDataUri.data) {
|
|
return callback(null, Buffer.from(0));
|
|
}
|
|
return callback(null, parsedDataUri.data);
|
|
} else if (content.path) {
|
|
return resolveStream(fs15.createReadStream(content.path), callback);
|
|
}
|
|
}
|
|
if (typeof data[key].content === "string" && !["utf8", "usascii", "ascii"].includes(encoding)) {
|
|
content = Buffer.from(data[key].content, encoding);
|
|
}
|
|
setImmediate(() => callback(null, content));
|
|
return promise;
|
|
};
|
|
exports.assign = function() {
|
|
let args = Array.from(arguments);
|
|
let target = args.shift() || {};
|
|
args.forEach((source) => {
|
|
Object.keys(source || {}).forEach((key) => {
|
|
if (["tls", "auth"].includes(key) && source[key] && typeof source[key] === "object") {
|
|
if (!target[key]) {
|
|
target[key] = {};
|
|
}
|
|
Object.keys(source[key]).forEach((subKey) => {
|
|
target[key][subKey] = source[key][subKey];
|
|
});
|
|
} else {
|
|
target[key] = source[key];
|
|
}
|
|
});
|
|
});
|
|
return target;
|
|
};
|
|
exports.encodeXText = (str) => {
|
|
if (!/[^\x21-\x2A\x2C-\x3C\x3E-\x7E]/.test(str)) {
|
|
return str;
|
|
}
|
|
let buf = Buffer.from(str);
|
|
let result = "";
|
|
for (let i = 0, len = buf.length;i < len; i++) {
|
|
let c = buf[i];
|
|
if (c < 33 || c > 126 || c === 43 || c === 61) {
|
|
result += "+" + (c < 16 ? "0" : "") + c.toString(16).toUpperCase();
|
|
} else {
|
|
result += String.fromCharCode(c);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
function resolveStream(stream, callback) {
|
|
let responded = false;
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
stream.on("error", (err) => {
|
|
if (responded) {
|
|
return;
|
|
}
|
|
responded = true;
|
|
callback(err);
|
|
});
|
|
stream.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = stream.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
stream.on("end", () => {
|
|
if (responded) {
|
|
return;
|
|
}
|
|
responded = true;
|
|
let value;
|
|
try {
|
|
value = Buffer.concat(chunks, chunklen);
|
|
} catch (E) {
|
|
return callback(E);
|
|
}
|
|
callback(null, value);
|
|
});
|
|
}
|
|
function createDefaultLogger(levels) {
|
|
let levelMaxLen = 0;
|
|
let levelNames = new Map;
|
|
levels.forEach((level) => {
|
|
if (level.length > levelMaxLen) {
|
|
levelMaxLen = level.length;
|
|
}
|
|
});
|
|
levels.forEach((level) => {
|
|
let levelName = level.toUpperCase();
|
|
if (levelName.length < levelMaxLen) {
|
|
levelName += " ".repeat(levelMaxLen - levelName.length);
|
|
}
|
|
levelNames.set(level, levelName);
|
|
});
|
|
let print = (level, entry, message, ...args) => {
|
|
let prefix = "";
|
|
if (entry) {
|
|
if (entry.tnx === "server") {
|
|
prefix = "S: ";
|
|
} else if (entry.tnx === "client") {
|
|
prefix = "C: ";
|
|
}
|
|
if (entry.sid) {
|
|
prefix = "[" + entry.sid + "] " + prefix;
|
|
}
|
|
if (entry.cid) {
|
|
prefix = "[#" + entry.cid + "] " + prefix;
|
|
}
|
|
}
|
|
message = util.format(message, ...args);
|
|
message.split(/\r?\n/).forEach((line) => {
|
|
console.log("[%s] %s %s", new Date().toISOString().substr(0, 19).replace(/T/, " "), levelNames.get(level), prefix + line);
|
|
});
|
|
};
|
|
let logger = {};
|
|
levels.forEach((level) => {
|
|
logger[level] = print.bind(null, level);
|
|
});
|
|
return logger;
|
|
}
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-funcs/mime-types.js
|
|
var require_mime_types = __commonJS((exports, module) => {
|
|
var path11 = __require("path");
|
|
var defaultMimeType = "application/octet-stream";
|
|
var defaultExtension = "bin";
|
|
var mimeTypes = new Map([
|
|
["application/acad", "dwg"],
|
|
["application/applixware", "aw"],
|
|
["application/arj", "arj"],
|
|
["application/atom+xml", "xml"],
|
|
["application/atomcat+xml", "atomcat"],
|
|
["application/atomsvc+xml", "atomsvc"],
|
|
["application/base64", ["mm", "mme"]],
|
|
["application/binhex", "hqx"],
|
|
["application/binhex4", "hqx"],
|
|
["application/book", ["book", "boo"]],
|
|
["application/ccxml+xml,", "ccxml"],
|
|
["application/cdf", "cdf"],
|
|
["application/cdmi-capability", "cdmia"],
|
|
["application/cdmi-container", "cdmic"],
|
|
["application/cdmi-domain", "cdmid"],
|
|
["application/cdmi-object", "cdmio"],
|
|
["application/cdmi-queue", "cdmiq"],
|
|
["application/clariscad", "ccad"],
|
|
["application/commonground", "dp"],
|
|
["application/cu-seeme", "cu"],
|
|
["application/davmount+xml", "davmount"],
|
|
["application/drafting", "drw"],
|
|
["application/dsptype", "tsp"],
|
|
["application/dssc+der", "dssc"],
|
|
["application/dssc+xml", "xdssc"],
|
|
["application/dxf", "dxf"],
|
|
["application/ecmascript", ["js", "es"]],
|
|
["application/emma+xml", "emma"],
|
|
["application/envoy", "evy"],
|
|
["application/epub+zip", "epub"],
|
|
["application/excel", ["xls", "xl", "xla", "xlb", "xlc", "xld", "xlk", "xll", "xlm", "xlt", "xlv", "xlw"]],
|
|
["application/exi", "exi"],
|
|
["application/font-tdpfr", "pfr"],
|
|
["application/fractals", "fif"],
|
|
["application/freeloader", "frl"],
|
|
["application/futuresplash", "spl"],
|
|
["application/gnutar", "tgz"],
|
|
["application/groupwise", "vew"],
|
|
["application/hlp", "hlp"],
|
|
["application/hta", "hta"],
|
|
["application/hyperstudio", "stk"],
|
|
["application/i-deas", "unv"],
|
|
["application/iges", ["iges", "igs"]],
|
|
["application/inf", "inf"],
|
|
["application/internet-property-stream", "acx"],
|
|
["application/ipfix", "ipfix"],
|
|
["application/java", "class"],
|
|
["application/java-archive", "jar"],
|
|
["application/java-byte-code", "class"],
|
|
["application/java-serialized-object", "ser"],
|
|
["application/java-vm", "class"],
|
|
["application/javascript", "js"],
|
|
["application/json", "json"],
|
|
["application/lha", "lha"],
|
|
["application/lzx", "lzx"],
|
|
["application/mac-binary", "bin"],
|
|
["application/mac-binhex", "hqx"],
|
|
["application/mac-binhex40", "hqx"],
|
|
["application/mac-compactpro", "cpt"],
|
|
["application/macbinary", "bin"],
|
|
["application/mads+xml", "mads"],
|
|
["application/marc", "mrc"],
|
|
["application/marcxml+xml", "mrcx"],
|
|
["application/mathematica", "ma"],
|
|
["application/mathml+xml", "mathml"],
|
|
["application/mbedlet", "mbd"],
|
|
["application/mbox", "mbox"],
|
|
["application/mcad", "mcd"],
|
|
["application/mediaservercontrol+xml", "mscml"],
|
|
["application/metalink4+xml", "meta4"],
|
|
["application/mets+xml", "mets"],
|
|
["application/mime", "aps"],
|
|
["application/mods+xml", "mods"],
|
|
["application/mp21", "m21"],
|
|
["application/mp4", "mp4"],
|
|
["application/mspowerpoint", ["ppt", "pot", "pps", "ppz"]],
|
|
["application/msword", ["doc", "dot", "w6w", "wiz", "word"]],
|
|
["application/mswrite", "wri"],
|
|
["application/mxf", "mxf"],
|
|
["application/netmc", "mcp"],
|
|
["application/octet-stream", ["*"]],
|
|
["application/oda", "oda"],
|
|
["application/oebps-package+xml", "opf"],
|
|
["application/ogg", "ogx"],
|
|
["application/olescript", "axs"],
|
|
["application/onenote", "onetoc"],
|
|
["application/patch-ops-error+xml", "xer"],
|
|
["application/pdf", "pdf"],
|
|
["application/pgp-encrypted", "asc"],
|
|
["application/pgp-signature", "pgp"],
|
|
["application/pics-rules", "prf"],
|
|
["application/pkcs-12", "p12"],
|
|
["application/pkcs-crl", "crl"],
|
|
["application/pkcs10", "p10"],
|
|
["application/pkcs7-mime", ["p7c", "p7m"]],
|
|
["application/pkcs7-signature", "p7s"],
|
|
["application/pkcs8", "p8"],
|
|
["application/pkix-attr-cert", "ac"],
|
|
["application/pkix-cert", ["cer", "crt"]],
|
|
["application/pkix-crl", "crl"],
|
|
["application/pkix-pkipath", "pkipath"],
|
|
["application/pkixcmp", "pki"],
|
|
["application/plain", "text"],
|
|
["application/pls+xml", "pls"],
|
|
["application/postscript", ["ps", "ai", "eps"]],
|
|
["application/powerpoint", "ppt"],
|
|
["application/pro_eng", ["part", "prt"]],
|
|
["application/prs.cww", "cww"],
|
|
["application/pskc+xml", "pskcxml"],
|
|
["application/rdf+xml", "rdf"],
|
|
["application/reginfo+xml", "rif"],
|
|
["application/relax-ng-compact-syntax", "rnc"],
|
|
["application/resource-lists+xml", "rl"],
|
|
["application/resource-lists-diff+xml", "rld"],
|
|
["application/ringing-tones", "rng"],
|
|
["application/rls-services+xml", "rs"],
|
|
["application/rsd+xml", "rsd"],
|
|
["application/rss+xml", "xml"],
|
|
["application/rtf", ["rtf", "rtx"]],
|
|
["application/sbml+xml", "sbml"],
|
|
["application/scvp-cv-request", "scq"],
|
|
["application/scvp-cv-response", "scs"],
|
|
["application/scvp-vp-request", "spq"],
|
|
["application/scvp-vp-response", "spp"],
|
|
["application/sdp", "sdp"],
|
|
["application/sea", "sea"],
|
|
["application/set", "set"],
|
|
["application/set-payment-initiation", "setpay"],
|
|
["application/set-registration-initiation", "setreg"],
|
|
["application/shf+xml", "shf"],
|
|
["application/sla", "stl"],
|
|
["application/smil", ["smi", "smil"]],
|
|
["application/smil+xml", "smi"],
|
|
["application/solids", "sol"],
|
|
["application/sounder", "sdr"],
|
|
["application/sparql-query", "rq"],
|
|
["application/sparql-results+xml", "srx"],
|
|
["application/srgs", "gram"],
|
|
["application/srgs+xml", "grxml"],
|
|
["application/sru+xml", "sru"],
|
|
["application/ssml+xml", "ssml"],
|
|
["application/step", ["step", "stp"]],
|
|
["application/streamingmedia", "ssm"],
|
|
["application/tei+xml", "tei"],
|
|
["application/thraud+xml", "tfi"],
|
|
["application/timestamped-data", "tsd"],
|
|
["application/toolbook", "tbk"],
|
|
["application/vda", "vda"],
|
|
["application/vnd.3gpp.pic-bw-large", "plb"],
|
|
["application/vnd.3gpp.pic-bw-small", "psb"],
|
|
["application/vnd.3gpp.pic-bw-var", "pvb"],
|
|
["application/vnd.3gpp2.tcap", "tcap"],
|
|
["application/vnd.3m.post-it-notes", "pwn"],
|
|
["application/vnd.accpac.simply.aso", "aso"],
|
|
["application/vnd.accpac.simply.imp", "imp"],
|
|
["application/vnd.acucobol", "acu"],
|
|
["application/vnd.acucorp", "atc"],
|
|
["application/vnd.adobe.air-application-installer-package+zip", "air"],
|
|
["application/vnd.adobe.fxp", "fxp"],
|
|
["application/vnd.adobe.xdp+xml", "xdp"],
|
|
["application/vnd.adobe.xfdf", "xfdf"],
|
|
["application/vnd.ahead.space", "ahead"],
|
|
["application/vnd.airzip.filesecure.azf", "azf"],
|
|
["application/vnd.airzip.filesecure.azs", "azs"],
|
|
["application/vnd.amazon.ebook", "azw"],
|
|
["application/vnd.americandynamics.acc", "acc"],
|
|
["application/vnd.amiga.ami", "ami"],
|
|
["application/vnd.android.package-archive", "apk"],
|
|
["application/vnd.anser-web-certificate-issue-initiation", "cii"],
|
|
["application/vnd.anser-web-funds-transfer-initiation", "fti"],
|
|
["application/vnd.antix.game-component", "atx"],
|
|
["application/vnd.apple.installer+xml", "mpkg"],
|
|
["application/vnd.apple.mpegurl", "m3u8"],
|
|
["application/vnd.aristanetworks.swi", "swi"],
|
|
["application/vnd.audiograph", "aep"],
|
|
["application/vnd.blueice.multipass", "mpm"],
|
|
["application/vnd.bmi", "bmi"],
|
|
["application/vnd.businessobjects", "rep"],
|
|
["application/vnd.chemdraw+xml", "cdxml"],
|
|
["application/vnd.chipnuts.karaoke-mmd", "mmd"],
|
|
["application/vnd.cinderella", "cdy"],
|
|
["application/vnd.claymore", "cla"],
|
|
["application/vnd.cloanto.rp9", "rp9"],
|
|
["application/vnd.clonk.c4group", "c4g"],
|
|
["application/vnd.cluetrust.cartomobile-config", "c11amc"],
|
|
["application/vnd.cluetrust.cartomobile-config-pkg", "c11amz"],
|
|
["application/vnd.commonspace", "csp"],
|
|
["application/vnd.contact.cmsg", "cdbcmsg"],
|
|
["application/vnd.cosmocaller", "cmc"],
|
|
["application/vnd.crick.clicker", "clkx"],
|
|
["application/vnd.crick.clicker.keyboard", "clkk"],
|
|
["application/vnd.crick.clicker.palette", "clkp"],
|
|
["application/vnd.crick.clicker.template", "clkt"],
|
|
["application/vnd.crick.clicker.wordbank", "clkw"],
|
|
["application/vnd.criticaltools.wbs+xml", "wbs"],
|
|
["application/vnd.ctc-posml", "pml"],
|
|
["application/vnd.cups-ppd", "ppd"],
|
|
["application/vnd.curl.car", "car"],
|
|
["application/vnd.curl.pcurl", "pcurl"],
|
|
["application/vnd.data-vision.rdz", "rdz"],
|
|
["application/vnd.denovo.fcselayout-link", "fe_launch"],
|
|
["application/vnd.dna", "dna"],
|
|
["application/vnd.dolby.mlp", "mlp"],
|
|
["application/vnd.dpgraph", "dpg"],
|
|
["application/vnd.dreamfactory", "dfac"],
|
|
["application/vnd.dvb.ait", "ait"],
|
|
["application/vnd.dvb.service", "svc"],
|
|
["application/vnd.dynageo", "geo"],
|
|
["application/vnd.ecowin.chart", "mag"],
|
|
["application/vnd.enliven", "nml"],
|
|
["application/vnd.epson.esf", "esf"],
|
|
["application/vnd.epson.msf", "msf"],
|
|
["application/vnd.epson.quickanime", "qam"],
|
|
["application/vnd.epson.salt", "slt"],
|
|
["application/vnd.epson.ssf", "ssf"],
|
|
["application/vnd.eszigno3+xml", "es3"],
|
|
["application/vnd.ezpix-album", "ez2"],
|
|
["application/vnd.ezpix-package", "ez3"],
|
|
["application/vnd.fdf", "fdf"],
|
|
["application/vnd.fdsn.seed", "seed"],
|
|
["application/vnd.flographit", "gph"],
|
|
["application/vnd.fluxtime.clip", "ftc"],
|
|
["application/vnd.framemaker", "fm"],
|
|
["application/vnd.frogans.fnc", "fnc"],
|
|
["application/vnd.frogans.ltf", "ltf"],
|
|
["application/vnd.fsc.weblaunch", "fsc"],
|
|
["application/vnd.fujitsu.oasys", "oas"],
|
|
["application/vnd.fujitsu.oasys2", "oa2"],
|
|
["application/vnd.fujitsu.oasys3", "oa3"],
|
|
["application/vnd.fujitsu.oasysgp", "fg5"],
|
|
["application/vnd.fujitsu.oasysprs", "bh2"],
|
|
["application/vnd.fujixerox.ddd", "ddd"],
|
|
["application/vnd.fujixerox.docuworks", "xdw"],
|
|
["application/vnd.fujixerox.docuworks.binder", "xbd"],
|
|
["application/vnd.fuzzysheet", "fzs"],
|
|
["application/vnd.genomatix.tuxedo", "txd"],
|
|
["application/vnd.geogebra.file", "ggb"],
|
|
["application/vnd.geogebra.tool", "ggt"],
|
|
["application/vnd.geometry-explorer", "gex"],
|
|
["application/vnd.geonext", "gxt"],
|
|
["application/vnd.geoplan", "g2w"],
|
|
["application/vnd.geospace", "g3w"],
|
|
["application/vnd.gmx", "gmx"],
|
|
["application/vnd.google-earth.kml+xml", "kml"],
|
|
["application/vnd.google-earth.kmz", "kmz"],
|
|
["application/vnd.grafeq", "gqf"],
|
|
["application/vnd.groove-account", "gac"],
|
|
["application/vnd.groove-help", "ghf"],
|
|
["application/vnd.groove-identity-message", "gim"],
|
|
["application/vnd.groove-injector", "grv"],
|
|
["application/vnd.groove-tool-message", "gtm"],
|
|
["application/vnd.groove-tool-template", "tpl"],
|
|
["application/vnd.groove-vcard", "vcg"],
|
|
["application/vnd.hal+xml", "hal"],
|
|
["application/vnd.handheld-entertainment+xml", "zmm"],
|
|
["application/vnd.hbci", "hbci"],
|
|
["application/vnd.hhe.lesson-player", "les"],
|
|
["application/vnd.hp-hpgl", ["hgl", "hpg", "hpgl"]],
|
|
["application/vnd.hp-hpid", "hpid"],
|
|
["application/vnd.hp-hps", "hps"],
|
|
["application/vnd.hp-jlyt", "jlt"],
|
|
["application/vnd.hp-pcl", "pcl"],
|
|
["application/vnd.hp-pclxl", "pclxl"],
|
|
["application/vnd.hydrostatix.sof-data", "sfd-hdstx"],
|
|
["application/vnd.hzn-3d-crossword", "x3d"],
|
|
["application/vnd.ibm.minipay", "mpy"],
|
|
["application/vnd.ibm.modcap", "afp"],
|
|
["application/vnd.ibm.rights-management", "irm"],
|
|
["application/vnd.ibm.secure-container", "sc"],
|
|
["application/vnd.iccprofile", "icc"],
|
|
["application/vnd.igloader", "igl"],
|
|
["application/vnd.immervision-ivp", "ivp"],
|
|
["application/vnd.immervision-ivu", "ivu"],
|
|
["application/vnd.insors.igm", "igm"],
|
|
["application/vnd.intercon.formnet", "xpw"],
|
|
["application/vnd.intergeo", "i2g"],
|
|
["application/vnd.intu.qbo", "qbo"],
|
|
["application/vnd.intu.qfx", "qfx"],
|
|
["application/vnd.ipunplugged.rcprofile", "rcprofile"],
|
|
["application/vnd.irepository.package+xml", "irp"],
|
|
["application/vnd.is-xpr", "xpr"],
|
|
["application/vnd.isac.fcs", "fcs"],
|
|
["application/vnd.jam", "jam"],
|
|
["application/vnd.jcp.javame.midlet-rms", "rms"],
|
|
["application/vnd.jisp", "jisp"],
|
|
["application/vnd.joost.joda-archive", "joda"],
|
|
["application/vnd.kahootz", "ktz"],
|
|
["application/vnd.kde.karbon", "karbon"],
|
|
["application/vnd.kde.kchart", "chrt"],
|
|
["application/vnd.kde.kformula", "kfo"],
|
|
["application/vnd.kde.kivio", "flw"],
|
|
["application/vnd.kde.kontour", "kon"],
|
|
["application/vnd.kde.kpresenter", "kpr"],
|
|
["application/vnd.kde.kspread", "ksp"],
|
|
["application/vnd.kde.kword", "kwd"],
|
|
["application/vnd.kenameaapp", "htke"],
|
|
["application/vnd.kidspiration", "kia"],
|
|
["application/vnd.kinar", "kne"],
|
|
["application/vnd.koan", "skp"],
|
|
["application/vnd.kodak-descriptor", "sse"],
|
|
["application/vnd.las.las+xml", "lasxml"],
|
|
["application/vnd.llamagraphics.life-balance.desktop", "lbd"],
|
|
["application/vnd.llamagraphics.life-balance.exchange+xml", "lbe"],
|
|
["application/vnd.lotus-1-2-3", "123"],
|
|
["application/vnd.lotus-approach", "apr"],
|
|
["application/vnd.lotus-freelance", "pre"],
|
|
["application/vnd.lotus-notes", "nsf"],
|
|
["application/vnd.lotus-organizer", "org"],
|
|
["application/vnd.lotus-screencam", "scm"],
|
|
["application/vnd.lotus-wordpro", "lwp"],
|
|
["application/vnd.macports.portpkg", "portpkg"],
|
|
["application/vnd.mcd", "mcd"],
|
|
["application/vnd.medcalcdata", "mc1"],
|
|
["application/vnd.mediastation.cdkey", "cdkey"],
|
|
["application/vnd.mfer", "mwf"],
|
|
["application/vnd.mfmp", "mfm"],
|
|
["application/vnd.micrografx.flo", "flo"],
|
|
["application/vnd.micrografx.igx", "igx"],
|
|
["application/vnd.mif", "mif"],
|
|
["application/vnd.mobius.daf", "daf"],
|
|
["application/vnd.mobius.dis", "dis"],
|
|
["application/vnd.mobius.mbk", "mbk"],
|
|
["application/vnd.mobius.mqy", "mqy"],
|
|
["application/vnd.mobius.msl", "msl"],
|
|
["application/vnd.mobius.plc", "plc"],
|
|
["application/vnd.mobius.txf", "txf"],
|
|
["application/vnd.mophun.application", "mpn"],
|
|
["application/vnd.mophun.certificate", "mpc"],
|
|
["application/vnd.mozilla.xul+xml", "xul"],
|
|
["application/vnd.ms-artgalry", "cil"],
|
|
["application/vnd.ms-cab-compressed", "cab"],
|
|
["application/vnd.ms-excel", ["xls", "xla", "xlc", "xlm", "xlt", "xlw", "xlb", "xll"]],
|
|
["application/vnd.ms-excel.addin.macroenabled.12", "xlam"],
|
|
["application/vnd.ms-excel.sheet.binary.macroenabled.12", "xlsb"],
|
|
["application/vnd.ms-excel.sheet.macroenabled.12", "xlsm"],
|
|
["application/vnd.ms-excel.template.macroenabled.12", "xltm"],
|
|
["application/vnd.ms-fontobject", "eot"],
|
|
["application/vnd.ms-htmlhelp", "chm"],
|
|
["application/vnd.ms-ims", "ims"],
|
|
["application/vnd.ms-lrm", "lrm"],
|
|
["application/vnd.ms-officetheme", "thmx"],
|
|
["application/vnd.ms-outlook", "msg"],
|
|
["application/vnd.ms-pki.certstore", "sst"],
|
|
["application/vnd.ms-pki.pko", "pko"],
|
|
["application/vnd.ms-pki.seccat", "cat"],
|
|
["application/vnd.ms-pki.stl", "stl"],
|
|
["application/vnd.ms-pkicertstore", "sst"],
|
|
["application/vnd.ms-pkiseccat", "cat"],
|
|
["application/vnd.ms-pkistl", "stl"],
|
|
["application/vnd.ms-powerpoint", ["ppt", "pot", "pps", "ppa", "pwz"]],
|
|
["application/vnd.ms-powerpoint.addin.macroenabled.12", "ppam"],
|
|
["application/vnd.ms-powerpoint.presentation.macroenabled.12", "pptm"],
|
|
["application/vnd.ms-powerpoint.slide.macroenabled.12", "sldm"],
|
|
["application/vnd.ms-powerpoint.slideshow.macroenabled.12", "ppsm"],
|
|
["application/vnd.ms-powerpoint.template.macroenabled.12", "potm"],
|
|
["application/vnd.ms-project", "mpp"],
|
|
["application/vnd.ms-word.document.macroenabled.12", "docm"],
|
|
["application/vnd.ms-word.template.macroenabled.12", "dotm"],
|
|
["application/vnd.ms-works", ["wks", "wcm", "wdb", "wps"]],
|
|
["application/vnd.ms-wpl", "wpl"],
|
|
["application/vnd.ms-xpsdocument", "xps"],
|
|
["application/vnd.mseq", "mseq"],
|
|
["application/vnd.musician", "mus"],
|
|
["application/vnd.muvee.style", "msty"],
|
|
["application/vnd.neurolanguage.nlu", "nlu"],
|
|
["application/vnd.noblenet-directory", "nnd"],
|
|
["application/vnd.noblenet-sealer", "nns"],
|
|
["application/vnd.noblenet-web", "nnw"],
|
|
["application/vnd.nokia.configuration-message", "ncm"],
|
|
["application/vnd.nokia.n-gage.data", "ngdat"],
|
|
["application/vnd.nokia.n-gage.symbian.install", "n-gage"],
|
|
["application/vnd.nokia.radio-preset", "rpst"],
|
|
["application/vnd.nokia.radio-presets", "rpss"],
|
|
["application/vnd.nokia.ringing-tone", "rng"],
|
|
["application/vnd.novadigm.edm", "edm"],
|
|
["application/vnd.novadigm.edx", "edx"],
|
|
["application/vnd.novadigm.ext", "ext"],
|
|
["application/vnd.oasis.opendocument.chart", "odc"],
|
|
["application/vnd.oasis.opendocument.chart-template", "otc"],
|
|
["application/vnd.oasis.opendocument.database", "odb"],
|
|
["application/vnd.oasis.opendocument.formula", "odf"],
|
|
["application/vnd.oasis.opendocument.formula-template", "odft"],
|
|
["application/vnd.oasis.opendocument.graphics", "odg"],
|
|
["application/vnd.oasis.opendocument.graphics-template", "otg"],
|
|
["application/vnd.oasis.opendocument.image", "odi"],
|
|
["application/vnd.oasis.opendocument.image-template", "oti"],
|
|
["application/vnd.oasis.opendocument.presentation", "odp"],
|
|
["application/vnd.oasis.opendocument.presentation-template", "otp"],
|
|
["application/vnd.oasis.opendocument.spreadsheet", "ods"],
|
|
["application/vnd.oasis.opendocument.spreadsheet-template", "ots"],
|
|
["application/vnd.oasis.opendocument.text", "odt"],
|
|
["application/vnd.oasis.opendocument.text-master", "odm"],
|
|
["application/vnd.oasis.opendocument.text-template", "ott"],
|
|
["application/vnd.oasis.opendocument.text-web", "oth"],
|
|
["application/vnd.olpc-sugar", "xo"],
|
|
["application/vnd.oma.dd2+xml", "dd2"],
|
|
["application/vnd.openofficeorg.extension", "oxt"],
|
|
["application/vnd.openxmlformats-officedocument.presentationml.presentation", "pptx"],
|
|
["application/vnd.openxmlformats-officedocument.presentationml.slide", "sldx"],
|
|
["application/vnd.openxmlformats-officedocument.presentationml.slideshow", "ppsx"],
|
|
["application/vnd.openxmlformats-officedocument.presentationml.template", "potx"],
|
|
["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"],
|
|
["application/vnd.openxmlformats-officedocument.spreadsheetml.template", "xltx"],
|
|
["application/vnd.openxmlformats-officedocument.wordprocessingml.document", "docx"],
|
|
["application/vnd.openxmlformats-officedocument.wordprocessingml.template", "dotx"],
|
|
["application/vnd.osgeo.mapguide.package", "mgp"],
|
|
["application/vnd.osgi.dp", "dp"],
|
|
["application/vnd.palm", "pdb"],
|
|
["application/vnd.pawaafile", "paw"],
|
|
["application/vnd.pg.format", "str"],
|
|
["application/vnd.pg.osasli", "ei6"],
|
|
["application/vnd.picsel", "efif"],
|
|
["application/vnd.pmi.widget", "wg"],
|
|
["application/vnd.pocketlearn", "plf"],
|
|
["application/vnd.powerbuilder6", "pbd"],
|
|
["application/vnd.previewsystems.box", "box"],
|
|
["application/vnd.proteus.magazine", "mgz"],
|
|
["application/vnd.publishare-delta-tree", "qps"],
|
|
["application/vnd.pvi.ptid1", "ptid"],
|
|
["application/vnd.quark.quarkxpress", "qxd"],
|
|
["application/vnd.realvnc.bed", "bed"],
|
|
["application/vnd.recordare.musicxml", "mxl"],
|
|
["application/vnd.recordare.musicxml+xml", "musicxml"],
|
|
["application/vnd.rig.cryptonote", "cryptonote"],
|
|
["application/vnd.rim.cod", "cod"],
|
|
["application/vnd.rn-realmedia", "rm"],
|
|
["application/vnd.rn-realplayer", "rnx"],
|
|
["application/vnd.route66.link66+xml", "link66"],
|
|
["application/vnd.sailingtracker.track", "st"],
|
|
["application/vnd.seemail", "see"],
|
|
["application/vnd.sema", "sema"],
|
|
["application/vnd.semd", "semd"],
|
|
["application/vnd.semf", "semf"],
|
|
["application/vnd.shana.informed.formdata", "ifm"],
|
|
["application/vnd.shana.informed.formtemplate", "itp"],
|
|
["application/vnd.shana.informed.interchange", "iif"],
|
|
["application/vnd.shana.informed.package", "ipk"],
|
|
["application/vnd.simtech-mindmapper", "twd"],
|
|
["application/vnd.smaf", "mmf"],
|
|
["application/vnd.smart.teacher", "teacher"],
|
|
["application/vnd.solent.sdkm+xml", "sdkm"],
|
|
["application/vnd.spotfire.dxp", "dxp"],
|
|
["application/vnd.spotfire.sfs", "sfs"],
|
|
["application/vnd.stardivision.calc", "sdc"],
|
|
["application/vnd.stardivision.draw", "sda"],
|
|
["application/vnd.stardivision.impress", "sdd"],
|
|
["application/vnd.stardivision.math", "smf"],
|
|
["application/vnd.stardivision.writer", "sdw"],
|
|
["application/vnd.stardivision.writer-global", "sgl"],
|
|
["application/vnd.stepmania.stepchart", "sm"],
|
|
["application/vnd.sun.xml.calc", "sxc"],
|
|
["application/vnd.sun.xml.calc.template", "stc"],
|
|
["application/vnd.sun.xml.draw", "sxd"],
|
|
["application/vnd.sun.xml.draw.template", "std"],
|
|
["application/vnd.sun.xml.impress", "sxi"],
|
|
["application/vnd.sun.xml.impress.template", "sti"],
|
|
["application/vnd.sun.xml.math", "sxm"],
|
|
["application/vnd.sun.xml.writer", "sxw"],
|
|
["application/vnd.sun.xml.writer.global", "sxg"],
|
|
["application/vnd.sun.xml.writer.template", "stw"],
|
|
["application/vnd.sus-calendar", "sus"],
|
|
["application/vnd.svd", "svd"],
|
|
["application/vnd.symbian.install", "sis"],
|
|
["application/vnd.syncml+xml", "xsm"],
|
|
["application/vnd.syncml.dm+wbxml", "bdm"],
|
|
["application/vnd.syncml.dm+xml", "xdm"],
|
|
["application/vnd.tao.intent-module-archive", "tao"],
|
|
["application/vnd.tmobile-livetv", "tmo"],
|
|
["application/vnd.trid.tpt", "tpt"],
|
|
["application/vnd.triscape.mxs", "mxs"],
|
|
["application/vnd.trueapp", "tra"],
|
|
["application/vnd.ufdl", "ufd"],
|
|
["application/vnd.uiq.theme", "utz"],
|
|
["application/vnd.umajin", "umj"],
|
|
["application/vnd.unity", "unityweb"],
|
|
["application/vnd.uoml+xml", "uoml"],
|
|
["application/vnd.vcx", "vcx"],
|
|
["application/vnd.visio", "vsd"],
|
|
["application/vnd.visionary", "vis"],
|
|
["application/vnd.vsf", "vsf"],
|
|
["application/vnd.wap.wbxml", "wbxml"],
|
|
["application/vnd.wap.wmlc", "wmlc"],
|
|
["application/vnd.wap.wmlscriptc", "wmlsc"],
|
|
["application/vnd.webturbo", "wtb"],
|
|
["application/vnd.wolfram.player", "nbp"],
|
|
["application/vnd.wordperfect", "wpd"],
|
|
["application/vnd.wqd", "wqd"],
|
|
["application/vnd.wt.stf", "stf"],
|
|
["application/vnd.xara", ["web", "xar"]],
|
|
["application/vnd.xfdl", "xfdl"],
|
|
["application/vnd.yamaha.hv-dic", "hvd"],
|
|
["application/vnd.yamaha.hv-script", "hvs"],
|
|
["application/vnd.yamaha.hv-voice", "hvp"],
|
|
["application/vnd.yamaha.openscoreformat", "osf"],
|
|
["application/vnd.yamaha.openscoreformat.osfpvg+xml", "osfpvg"],
|
|
["application/vnd.yamaha.smaf-audio", "saf"],
|
|
["application/vnd.yamaha.smaf-phrase", "spf"],
|
|
["application/vnd.yellowriver-custom-menu", "cmp"],
|
|
["application/vnd.zul", "zir"],
|
|
["application/vnd.zzazz.deck+xml", "zaz"],
|
|
["application/vocaltec-media-desc", "vmd"],
|
|
["application/vocaltec-media-file", "vmf"],
|
|
["application/voicexml+xml", "vxml"],
|
|
["application/widget", "wgt"],
|
|
["application/winhlp", "hlp"],
|
|
["application/wordperfect", ["wp", "wp5", "wp6", "wpd"]],
|
|
["application/wordperfect6.0", ["w60", "wp5"]],
|
|
["application/wordperfect6.1", "w61"],
|
|
["application/wsdl+xml", "wsdl"],
|
|
["application/wspolicy+xml", "wspolicy"],
|
|
["application/x-123", "wk1"],
|
|
["application/x-7z-compressed", "7z"],
|
|
["application/x-abiword", "abw"],
|
|
["application/x-ace-compressed", "ace"],
|
|
["application/x-aim", "aim"],
|
|
["application/x-authorware-bin", "aab"],
|
|
["application/x-authorware-map", "aam"],
|
|
["application/x-authorware-seg", "aas"],
|
|
["application/x-bcpio", "bcpio"],
|
|
["application/x-binary", "bin"],
|
|
["application/x-binhex40", "hqx"],
|
|
["application/x-bittorrent", "torrent"],
|
|
["application/x-bsh", ["bsh", "sh", "shar"]],
|
|
["application/x-bytecode.elisp", "elc"],
|
|
["application/x-bytecode.python", "pyc"],
|
|
["application/x-bzip", "bz"],
|
|
["application/x-bzip2", ["boz", "bz2"]],
|
|
["application/x-cdf", "cdf"],
|
|
["application/x-cdlink", "vcd"],
|
|
["application/x-chat", ["cha", "chat"]],
|
|
["application/x-chess-pgn", "pgn"],
|
|
["application/x-cmu-raster", "ras"],
|
|
["application/x-cocoa", "cco"],
|
|
["application/x-compactpro", "cpt"],
|
|
["application/x-compress", "z"],
|
|
["application/x-compressed", ["tgz", "gz", "z", "zip"]],
|
|
["application/x-conference", "nsc"],
|
|
["application/x-cpio", "cpio"],
|
|
["application/x-cpt", "cpt"],
|
|
["application/x-csh", "csh"],
|
|
["application/x-debian-package", "deb"],
|
|
["application/x-deepv", "deepv"],
|
|
["application/x-director", ["dir", "dcr", "dxr"]],
|
|
["application/x-doom", "wad"],
|
|
["application/x-dtbncx+xml", "ncx"],
|
|
["application/x-dtbook+xml", "dtb"],
|
|
["application/x-dtbresource+xml", "res"],
|
|
["application/x-dvi", "dvi"],
|
|
["application/x-elc", "elc"],
|
|
["application/x-envoy", ["env", "evy"]],
|
|
["application/x-esrehber", "es"],
|
|
["application/x-excel", ["xls", "xla", "xlb", "xlc", "xld", "xlk", "xll", "xlm", "xlt", "xlv", "xlw"]],
|
|
["application/x-font-bdf", "bdf"],
|
|
["application/x-font-ghostscript", "gsf"],
|
|
["application/x-font-linux-psf", "psf"],
|
|
["application/x-font-otf", "otf"],
|
|
["application/x-font-pcf", "pcf"],
|
|
["application/x-font-snf", "snf"],
|
|
["application/x-font-ttf", "ttf"],
|
|
["application/x-font-type1", "pfa"],
|
|
["application/x-font-woff", "woff"],
|
|
["application/x-frame", "mif"],
|
|
["application/x-freelance", "pre"],
|
|
["application/x-futuresplash", "spl"],
|
|
["application/x-gnumeric", "gnumeric"],
|
|
["application/x-gsp", "gsp"],
|
|
["application/x-gss", "gss"],
|
|
["application/x-gtar", "gtar"],
|
|
["application/x-gzip", ["gz", "gzip"]],
|
|
["application/x-hdf", "hdf"],
|
|
["application/x-helpfile", ["help", "hlp"]],
|
|
["application/x-httpd-imap", "imap"],
|
|
["application/x-ima", "ima"],
|
|
["application/x-internet-signup", ["ins", "isp"]],
|
|
["application/x-internett-signup", "ins"],
|
|
["application/x-inventor", "iv"],
|
|
["application/x-ip2", "ip"],
|
|
["application/x-iphone", "iii"],
|
|
["application/x-java-class", "class"],
|
|
["application/x-java-commerce", "jcm"],
|
|
["application/x-java-jnlp-file", "jnlp"],
|
|
["application/x-javascript", "js"],
|
|
["application/x-koan", ["skd", "skm", "skp", "skt"]],
|
|
["application/x-ksh", "ksh"],
|
|
["application/x-latex", ["latex", "ltx"]],
|
|
["application/x-lha", "lha"],
|
|
["application/x-lisp", "lsp"],
|
|
["application/x-livescreen", "ivy"],
|
|
["application/x-lotus", "wq1"],
|
|
["application/x-lotusscreencam", "scm"],
|
|
["application/x-lzh", "lzh"],
|
|
["application/x-lzx", "lzx"],
|
|
["application/x-mac-binhex40", "hqx"],
|
|
["application/x-macbinary", "bin"],
|
|
["application/x-magic-cap-package-1.0", "mc$"],
|
|
["application/x-mathcad", "mcd"],
|
|
["application/x-meme", "mm"],
|
|
["application/x-midi", ["mid", "midi"]],
|
|
["application/x-mif", "mif"],
|
|
["application/x-mix-transfer", "nix"],
|
|
["application/x-mobipocket-ebook", "prc"],
|
|
["application/x-mplayer2", "asx"],
|
|
["application/x-ms-application", "application"],
|
|
["application/x-ms-wmd", "wmd"],
|
|
["application/x-ms-wmz", "wmz"],
|
|
["application/x-ms-xbap", "xbap"],
|
|
["application/x-msaccess", "mdb"],
|
|
["application/x-msbinder", "obd"],
|
|
["application/x-mscardfile", "crd"],
|
|
["application/x-msclip", "clp"],
|
|
["application/x-msdownload", ["exe", "dll"]],
|
|
["application/x-msexcel", ["xls", "xla", "xlw"]],
|
|
["application/x-msmediaview", ["mvb", "m13", "m14"]],
|
|
["application/x-msmetafile", "wmf"],
|
|
["application/x-msmoney", "mny"],
|
|
["application/x-mspowerpoint", "ppt"],
|
|
["application/x-mspublisher", "pub"],
|
|
["application/x-msschedule", "scd"],
|
|
["application/x-msterminal", "trm"],
|
|
["application/x-mswrite", "wri"],
|
|
["application/x-navi-animation", "ani"],
|
|
["application/x-navidoc", "nvd"],
|
|
["application/x-navimap", "map"],
|
|
["application/x-navistyle", "stl"],
|
|
["application/x-netcdf", ["cdf", "nc"]],
|
|
["application/x-newton-compatible-pkg", "pkg"],
|
|
["application/x-nokia-9000-communicator-add-on-software", "aos"],
|
|
["application/x-omc", "omc"],
|
|
["application/x-omcdatamaker", "omcd"],
|
|
["application/x-omcregerator", "omcr"],
|
|
["application/x-pagemaker", ["pm4", "pm5"]],
|
|
["application/x-pcl", "pcl"],
|
|
["application/x-perfmon", ["pma", "pmc", "pml", "pmr", "pmw"]],
|
|
["application/x-pixclscript", "plx"],
|
|
["application/x-pkcs10", "p10"],
|
|
["application/x-pkcs12", ["p12", "pfx"]],
|
|
["application/x-pkcs7-certificates", ["p7b", "spc"]],
|
|
["application/x-pkcs7-certreqresp", "p7r"],
|
|
["application/x-pkcs7-mime", ["p7m", "p7c"]],
|
|
["application/x-pkcs7-signature", ["p7s", "p7a"]],
|
|
["application/x-pointplus", "css"],
|
|
["application/x-portable-anymap", "pnm"],
|
|
["application/x-project", ["mpc", "mpt", "mpv", "mpx"]],
|
|
["application/x-qpro", "wb1"],
|
|
["application/x-rar-compressed", "rar"],
|
|
["application/x-rtf", "rtf"],
|
|
["application/x-sdp", "sdp"],
|
|
["application/x-sea", "sea"],
|
|
["application/x-seelogo", "sl"],
|
|
["application/x-sh", "sh"],
|
|
["application/x-shar", ["shar", "sh"]],
|
|
["application/x-shockwave-flash", "swf"],
|
|
["application/x-silverlight-app", "xap"],
|
|
["application/x-sit", "sit"],
|
|
["application/x-sprite", ["spr", "sprite"]],
|
|
["application/x-stuffit", "sit"],
|
|
["application/x-stuffitx", "sitx"],
|
|
["application/x-sv4cpio", "sv4cpio"],
|
|
["application/x-sv4crc", "sv4crc"],
|
|
["application/x-tar", "tar"],
|
|
["application/x-tbook", ["sbk", "tbk"]],
|
|
["application/x-tcl", "tcl"],
|
|
["application/x-tex", "tex"],
|
|
["application/x-tex-tfm", "tfm"],
|
|
["application/x-texinfo", ["texi", "texinfo"]],
|
|
["application/x-troff", ["roff", "t", "tr"]],
|
|
["application/x-troff-man", "man"],
|
|
["application/x-troff-me", "me"],
|
|
["application/x-troff-ms", "ms"],
|
|
["application/x-troff-msvideo", "avi"],
|
|
["application/x-ustar", "ustar"],
|
|
["application/x-visio", ["vsd", "vst", "vsw"]],
|
|
["application/x-vnd.audioexplosion.mzz", "mzz"],
|
|
["application/x-vnd.ls-xpix", "xpix"],
|
|
["application/x-vrml", "vrml"],
|
|
["application/x-wais-source", ["src", "wsrc"]],
|
|
["application/x-winhelp", "hlp"],
|
|
["application/x-wintalk", "wtk"],
|
|
["application/x-world", ["wrl", "svr"]],
|
|
["application/x-wpwin", "wpd"],
|
|
["application/x-wri", "wri"],
|
|
["application/x-x509-ca-cert", ["cer", "crt", "der"]],
|
|
["application/x-x509-user-cert", "crt"],
|
|
["application/x-xfig", "fig"],
|
|
["application/x-xpinstall", "xpi"],
|
|
["application/x-zip-compressed", "zip"],
|
|
["application/xcap-diff+xml", "xdf"],
|
|
["application/xenc+xml", "xenc"],
|
|
["application/xhtml+xml", "xhtml"],
|
|
["application/xml", "xml"],
|
|
["application/xml-dtd", "dtd"],
|
|
["application/xop+xml", "xop"],
|
|
["application/xslt+xml", "xslt"],
|
|
["application/xspf+xml", "xspf"],
|
|
["application/xv+xml", "mxml"],
|
|
["application/yang", "yang"],
|
|
["application/yin+xml", "yin"],
|
|
["application/ynd.ms-pkipko", "pko"],
|
|
["application/zip", "zip"],
|
|
["audio/adpcm", "adp"],
|
|
["audio/aiff", ["aiff", "aif", "aifc"]],
|
|
["audio/basic", ["snd", "au"]],
|
|
["audio/it", "it"],
|
|
["audio/make", ["funk", "my", "pfunk"]],
|
|
["audio/make.my.funk", "pfunk"],
|
|
["audio/mid", ["mid", "rmi"]],
|
|
["audio/midi", ["midi", "kar", "mid"]],
|
|
["audio/mod", "mod"],
|
|
["audio/mp4", "mp4a"],
|
|
["audio/mpeg", ["mpga", "mp3", "m2a", "mp2", "mpa", "mpg"]],
|
|
["audio/mpeg3", "mp3"],
|
|
["audio/nspaudio", ["la", "lma"]],
|
|
["audio/ogg", "oga"],
|
|
["audio/s3m", "s3m"],
|
|
["audio/tsp-audio", "tsi"],
|
|
["audio/tsplayer", "tsp"],
|
|
["audio/vnd.dece.audio", "uva"],
|
|
["audio/vnd.digital-winds", "eol"],
|
|
["audio/vnd.dra", "dra"],
|
|
["audio/vnd.dts", "dts"],
|
|
["audio/vnd.dts.hd", "dtshd"],
|
|
["audio/vnd.lucent.voice", "lvp"],
|
|
["audio/vnd.ms-playready.media.pya", "pya"],
|
|
["audio/vnd.nuera.ecelp4800", "ecelp4800"],
|
|
["audio/vnd.nuera.ecelp7470", "ecelp7470"],
|
|
["audio/vnd.nuera.ecelp9600", "ecelp9600"],
|
|
["audio/vnd.qcelp", "qcp"],
|
|
["audio/vnd.rip", "rip"],
|
|
["audio/voc", "voc"],
|
|
["audio/voxware", "vox"],
|
|
["audio/wav", "wav"],
|
|
["audio/webm", "weba"],
|
|
["audio/x-aac", "aac"],
|
|
["audio/x-adpcm", "snd"],
|
|
["audio/x-aiff", ["aiff", "aif", "aifc"]],
|
|
["audio/x-au", "au"],
|
|
["audio/x-gsm", ["gsd", "gsm"]],
|
|
["audio/x-jam", "jam"],
|
|
["audio/x-liveaudio", "lam"],
|
|
["audio/x-mid", ["mid", "midi"]],
|
|
["audio/x-midi", ["midi", "mid"]],
|
|
["audio/x-mod", "mod"],
|
|
["audio/x-mpeg", "mp2"],
|
|
["audio/x-mpeg-3", "mp3"],
|
|
["audio/x-mpegurl", "m3u"],
|
|
["audio/x-mpequrl", "m3u"],
|
|
["audio/x-ms-wax", "wax"],
|
|
["audio/x-ms-wma", "wma"],
|
|
["audio/x-nspaudio", ["la", "lma"]],
|
|
["audio/x-pn-realaudio", ["ra", "ram", "rm", "rmm", "rmp"]],
|
|
["audio/x-pn-realaudio-plugin", ["ra", "rmp", "rpm"]],
|
|
["audio/x-psid", "sid"],
|
|
["audio/x-realaudio", "ra"],
|
|
["audio/x-twinvq", "vqf"],
|
|
["audio/x-twinvq-plugin", ["vqe", "vql"]],
|
|
["audio/x-vnd.audioexplosion.mjuicemediafile", "mjf"],
|
|
["audio/x-voc", "voc"],
|
|
["audio/x-wav", "wav"],
|
|
["audio/xm", "xm"],
|
|
["chemical/x-cdx", "cdx"],
|
|
["chemical/x-cif", "cif"],
|
|
["chemical/x-cmdf", "cmdf"],
|
|
["chemical/x-cml", "cml"],
|
|
["chemical/x-csml", "csml"],
|
|
["chemical/x-pdb", ["pdb", "xyz"]],
|
|
["chemical/x-xyz", "xyz"],
|
|
["drawing/x-dwf", "dwf"],
|
|
["i-world/i-vrml", "ivr"],
|
|
["image/bmp", ["bmp", "bm"]],
|
|
["image/cgm", "cgm"],
|
|
["image/cis-cod", "cod"],
|
|
["image/cmu-raster", ["ras", "rast"]],
|
|
["image/fif", "fif"],
|
|
["image/florian", ["flo", "turbot"]],
|
|
["image/g3fax", "g3"],
|
|
["image/gif", "gif"],
|
|
["image/ief", ["ief", "iefs"]],
|
|
["image/jpeg", ["jpeg", "jpe", "jpg", "jfif", "jfif-tbnl"]],
|
|
["image/jutvision", "jut"],
|
|
["image/ktx", "ktx"],
|
|
["image/naplps", ["nap", "naplps"]],
|
|
["image/pict", ["pic", "pict"]],
|
|
["image/pipeg", "jfif"],
|
|
["image/pjpeg", ["jfif", "jpe", "jpeg", "jpg"]],
|
|
["image/png", ["png", "x-png"]],
|
|
["image/prs.btif", "btif"],
|
|
["image/svg+xml", "svg"],
|
|
["image/tiff", ["tif", "tiff"]],
|
|
["image/vasa", "mcf"],
|
|
["image/vnd.adobe.photoshop", "psd"],
|
|
["image/vnd.dece.graphic", "uvi"],
|
|
["image/vnd.djvu", "djvu"],
|
|
["image/vnd.dvb.subtitle", "sub"],
|
|
["image/vnd.dwg", ["dwg", "dxf", "svf"]],
|
|
["image/vnd.dxf", "dxf"],
|
|
["image/vnd.fastbidsheet", "fbs"],
|
|
["image/vnd.fpx", "fpx"],
|
|
["image/vnd.fst", "fst"],
|
|
["image/vnd.fujixerox.edmics-mmr", "mmr"],
|
|
["image/vnd.fujixerox.edmics-rlc", "rlc"],
|
|
["image/vnd.ms-modi", "mdi"],
|
|
["image/vnd.net-fpx", ["fpx", "npx"]],
|
|
["image/vnd.rn-realflash", "rf"],
|
|
["image/vnd.rn-realpix", "rp"],
|
|
["image/vnd.wap.wbmp", "wbmp"],
|
|
["image/vnd.xiff", "xif"],
|
|
["image/webp", "webp"],
|
|
["image/x-cmu-raster", "ras"],
|
|
["image/x-cmx", "cmx"],
|
|
["image/x-dwg", ["dwg", "dxf", "svf"]],
|
|
["image/x-freehand", "fh"],
|
|
["image/x-icon", "ico"],
|
|
["image/x-jg", "art"],
|
|
["image/x-jps", "jps"],
|
|
["image/x-niff", ["niff", "nif"]],
|
|
["image/x-pcx", "pcx"],
|
|
["image/x-pict", ["pct", "pic"]],
|
|
["image/x-portable-anymap", "pnm"],
|
|
["image/x-portable-bitmap", "pbm"],
|
|
["image/x-portable-graymap", "pgm"],
|
|
["image/x-portable-greymap", "pgm"],
|
|
["image/x-portable-pixmap", "ppm"],
|
|
["image/x-quicktime", ["qif", "qti", "qtif"]],
|
|
["image/x-rgb", "rgb"],
|
|
["image/x-tiff", ["tif", "tiff"]],
|
|
["image/x-windows-bmp", "bmp"],
|
|
["image/x-xbitmap", "xbm"],
|
|
["image/x-xbm", "xbm"],
|
|
["image/x-xpixmap", ["xpm", "pm"]],
|
|
["image/x-xwd", "xwd"],
|
|
["image/x-xwindowdump", "xwd"],
|
|
["image/xbm", "xbm"],
|
|
["image/xpm", "xpm"],
|
|
["message/rfc822", ["eml", "mht", "mhtml", "nws", "mime"]],
|
|
["model/iges", ["iges", "igs"]],
|
|
["model/mesh", "msh"],
|
|
["model/vnd.collada+xml", "dae"],
|
|
["model/vnd.dwf", "dwf"],
|
|
["model/vnd.gdl", "gdl"],
|
|
["model/vnd.gtw", "gtw"],
|
|
["model/vnd.mts", "mts"],
|
|
["model/vnd.vtu", "vtu"],
|
|
["model/vrml", ["vrml", "wrl", "wrz"]],
|
|
["model/x-pov", "pov"],
|
|
["multipart/x-gzip", "gzip"],
|
|
["multipart/x-ustar", "ustar"],
|
|
["multipart/x-zip", "zip"],
|
|
["music/crescendo", ["mid", "midi"]],
|
|
["music/x-karaoke", "kar"],
|
|
["paleovu/x-pv", "pvu"],
|
|
["text/asp", "asp"],
|
|
["text/calendar", "ics"],
|
|
["text/css", "css"],
|
|
["text/csv", "csv"],
|
|
["text/ecmascript", "js"],
|
|
["text/h323", "323"],
|
|
["text/html", ["html", "htm", "stm", "acgi", "htmls", "htx", "shtml"]],
|
|
["text/iuls", "uls"],
|
|
["text/javascript", "js"],
|
|
["text/mcf", "mcf"],
|
|
["text/n3", "n3"],
|
|
["text/pascal", "pas"],
|
|
[
|
|
"text/plain",
|
|
[
|
|
"txt",
|
|
"bas",
|
|
"c",
|
|
"h",
|
|
"c++",
|
|
"cc",
|
|
"com",
|
|
"conf",
|
|
"cxx",
|
|
"def",
|
|
"f",
|
|
"f90",
|
|
"for",
|
|
"g",
|
|
"hh",
|
|
"idc",
|
|
"jav",
|
|
"java",
|
|
"list",
|
|
"log",
|
|
"lst",
|
|
"m",
|
|
"mar",
|
|
"pl",
|
|
"sdml",
|
|
"text"
|
|
]
|
|
],
|
|
["text/plain-bas", "par"],
|
|
["text/prs.lines.tag", "dsc"],
|
|
["text/richtext", ["rtx", "rt", "rtf"]],
|
|
["text/scriplet", "wsc"],
|
|
["text/scriptlet", "sct"],
|
|
["text/sgml", ["sgm", "sgml"]],
|
|
["text/tab-separated-values", "tsv"],
|
|
["text/troff", "t"],
|
|
["text/turtle", "ttl"],
|
|
["text/uri-list", ["uni", "unis", "uri", "uris"]],
|
|
["text/vnd.abc", "abc"],
|
|
["text/vnd.curl", "curl"],
|
|
["text/vnd.curl.dcurl", "dcurl"],
|
|
["text/vnd.curl.mcurl", "mcurl"],
|
|
["text/vnd.curl.scurl", "scurl"],
|
|
["text/vnd.fly", "fly"],
|
|
["text/vnd.fmi.flexstor", "flx"],
|
|
["text/vnd.graphviz", "gv"],
|
|
["text/vnd.in3d.3dml", "3dml"],
|
|
["text/vnd.in3d.spot", "spot"],
|
|
["text/vnd.rn-realtext", "rt"],
|
|
["text/vnd.sun.j2me.app-descriptor", "jad"],
|
|
["text/vnd.wap.wml", "wml"],
|
|
["text/vnd.wap.wmlscript", "wmls"],
|
|
["text/webviewhtml", "htt"],
|
|
["text/x-asm", ["asm", "s"]],
|
|
["text/x-audiosoft-intra", "aip"],
|
|
["text/x-c", ["c", "cc", "cpp"]],
|
|
["text/x-component", "htc"],
|
|
["text/x-fortran", ["for", "f", "f77", "f90"]],
|
|
["text/x-h", ["h", "hh"]],
|
|
["text/x-java-source", ["java", "jav"]],
|
|
["text/x-java-source,java", "java"],
|
|
["text/x-la-asf", "lsx"],
|
|
["text/x-m", "m"],
|
|
["text/x-pascal", "p"],
|
|
["text/x-script", "hlb"],
|
|
["text/x-script.csh", "csh"],
|
|
["text/x-script.elisp", "el"],
|
|
["text/x-script.guile", "scm"],
|
|
["text/x-script.ksh", "ksh"],
|
|
["text/x-script.lisp", "lsp"],
|
|
["text/x-script.perl", "pl"],
|
|
["text/x-script.perl-module", "pm"],
|
|
["text/x-script.phyton", "py"],
|
|
["text/x-script.rexx", "rexx"],
|
|
["text/x-script.scheme", "scm"],
|
|
["text/x-script.sh", "sh"],
|
|
["text/x-script.tcl", "tcl"],
|
|
["text/x-script.tcsh", "tcsh"],
|
|
["text/x-script.zsh", "zsh"],
|
|
["text/x-server-parsed-html", ["shtml", "ssi"]],
|
|
["text/x-setext", "etx"],
|
|
["text/x-sgml", ["sgm", "sgml"]],
|
|
["text/x-speech", ["spc", "talk"]],
|
|
["text/x-uil", "uil"],
|
|
["text/x-uuencode", ["uu", "uue"]],
|
|
["text/x-vcalendar", "vcs"],
|
|
["text/x-vcard", "vcf"],
|
|
["text/xml", "xml"],
|
|
["video/3gpp", "3gp"],
|
|
["video/3gpp2", "3g2"],
|
|
["video/animaflex", "afl"],
|
|
["video/avi", "avi"],
|
|
["video/avs-video", "avs"],
|
|
["video/dl", "dl"],
|
|
["video/fli", "fli"],
|
|
["video/gl", "gl"],
|
|
["video/h261", "h261"],
|
|
["video/h263", "h263"],
|
|
["video/h264", "h264"],
|
|
["video/jpeg", "jpgv"],
|
|
["video/jpm", "jpm"],
|
|
["video/mj2", "mj2"],
|
|
["video/mp4", "mp4"],
|
|
["video/mpeg", ["mpeg", "mp2", "mpa", "mpe", "mpg", "mpv2", "m1v", "m2v", "mp3"]],
|
|
["video/msvideo", "avi"],
|
|
["video/ogg", "ogv"],
|
|
["video/quicktime", ["mov", "qt", "moov"]],
|
|
["video/vdo", "vdo"],
|
|
["video/vivo", ["viv", "vivo"]],
|
|
["video/vnd.dece.hd", "uvh"],
|
|
["video/vnd.dece.mobile", "uvm"],
|
|
["video/vnd.dece.pd", "uvp"],
|
|
["video/vnd.dece.sd", "uvs"],
|
|
["video/vnd.dece.video", "uvv"],
|
|
["video/vnd.fvt", "fvt"],
|
|
["video/vnd.mpegurl", "mxu"],
|
|
["video/vnd.ms-playready.media.pyv", "pyv"],
|
|
["video/vnd.rn-realvideo", "rv"],
|
|
["video/vnd.uvvu.mp4", "uvu"],
|
|
["video/vnd.vivo", ["viv", "vivo"]],
|
|
["video/vosaic", "vos"],
|
|
["video/webm", "webm"],
|
|
["video/x-amt-demorun", "xdr"],
|
|
["video/x-amt-showrun", "xsr"],
|
|
["video/x-atomic3d-feature", "fmf"],
|
|
["video/x-dl", "dl"],
|
|
["video/x-dv", ["dif", "dv"]],
|
|
["video/x-f4v", "f4v"],
|
|
["video/x-fli", "fli"],
|
|
["video/x-flv", "flv"],
|
|
["video/x-gl", "gl"],
|
|
["video/x-isvideo", "isu"],
|
|
["video/x-la-asf", ["lsf", "lsx"]],
|
|
["video/x-m4v", "m4v"],
|
|
["video/x-motion-jpeg", "mjpg"],
|
|
["video/x-mpeg", ["mp3", "mp2"]],
|
|
["video/x-mpeq2a", "mp2"],
|
|
["video/x-ms-asf", ["asf", "asr", "asx"]],
|
|
["video/x-ms-asf-plugin", "asx"],
|
|
["video/x-ms-wm", "wm"],
|
|
["video/x-ms-wmv", "wmv"],
|
|
["video/x-ms-wmx", "wmx"],
|
|
["video/x-ms-wvx", "wvx"],
|
|
["video/x-msvideo", "avi"],
|
|
["video/x-qtc", "qtc"],
|
|
["video/x-scm", "scm"],
|
|
["video/x-sgi-movie", ["movie", "mv"]],
|
|
["windows/metafile", "wmf"],
|
|
["www/mime", "mime"],
|
|
["x-conference/x-cooltalk", "ice"],
|
|
["x-music/x-midi", ["mid", "midi"]],
|
|
["x-world/x-3dmf", ["3dm", "3dmf", "qd3", "qd3d"]],
|
|
["x-world/x-svr", "svr"],
|
|
["x-world/x-vrml", ["flr", "vrml", "wrl", "wrz", "xaf", "xof"]],
|
|
["x-world/x-vrt", "vrt"],
|
|
["xgl/drawing", "xgz"],
|
|
["xgl/movie", "xmz"]
|
|
]);
|
|
var extensions = new Map([
|
|
["123", "application/vnd.lotus-1-2-3"],
|
|
["323", "text/h323"],
|
|
["*", "application/octet-stream"],
|
|
["3dm", "x-world/x-3dmf"],
|
|
["3dmf", "x-world/x-3dmf"],
|
|
["3dml", "text/vnd.in3d.3dml"],
|
|
["3g2", "video/3gpp2"],
|
|
["3gp", "video/3gpp"],
|
|
["7z", "application/x-7z-compressed"],
|
|
["a", "application/octet-stream"],
|
|
["aab", "application/x-authorware-bin"],
|
|
["aac", "audio/x-aac"],
|
|
["aam", "application/x-authorware-map"],
|
|
["aas", "application/x-authorware-seg"],
|
|
["abc", "text/vnd.abc"],
|
|
["abw", "application/x-abiword"],
|
|
["ac", "application/pkix-attr-cert"],
|
|
["acc", "application/vnd.americandynamics.acc"],
|
|
["ace", "application/x-ace-compressed"],
|
|
["acgi", "text/html"],
|
|
["acu", "application/vnd.acucobol"],
|
|
["acx", "application/internet-property-stream"],
|
|
["adp", "audio/adpcm"],
|
|
["aep", "application/vnd.audiograph"],
|
|
["afl", "video/animaflex"],
|
|
["afp", "application/vnd.ibm.modcap"],
|
|
["ahead", "application/vnd.ahead.space"],
|
|
["ai", "application/postscript"],
|
|
["aif", ["audio/aiff", "audio/x-aiff"]],
|
|
["aifc", ["audio/aiff", "audio/x-aiff"]],
|
|
["aiff", ["audio/aiff", "audio/x-aiff"]],
|
|
["aim", "application/x-aim"],
|
|
["aip", "text/x-audiosoft-intra"],
|
|
["air", "application/vnd.adobe.air-application-installer-package+zip"],
|
|
["ait", "application/vnd.dvb.ait"],
|
|
["ami", "application/vnd.amiga.ami"],
|
|
["ani", "application/x-navi-animation"],
|
|
["aos", "application/x-nokia-9000-communicator-add-on-software"],
|
|
["apk", "application/vnd.android.package-archive"],
|
|
["application", "application/x-ms-application"],
|
|
["apr", "application/vnd.lotus-approach"],
|
|
["aps", "application/mime"],
|
|
["arc", "application/octet-stream"],
|
|
["arj", ["application/arj", "application/octet-stream"]],
|
|
["art", "image/x-jg"],
|
|
["asf", "video/x-ms-asf"],
|
|
["asm", "text/x-asm"],
|
|
["aso", "application/vnd.accpac.simply.aso"],
|
|
["asp", "text/asp"],
|
|
["asr", "video/x-ms-asf"],
|
|
["asx", ["video/x-ms-asf", "application/x-mplayer2", "video/x-ms-asf-plugin"]],
|
|
["atc", "application/vnd.acucorp"],
|
|
["atomcat", "application/atomcat+xml"],
|
|
["atomsvc", "application/atomsvc+xml"],
|
|
["atx", "application/vnd.antix.game-component"],
|
|
["au", ["audio/basic", "audio/x-au"]],
|
|
["avi", ["video/avi", "video/msvideo", "application/x-troff-msvideo", "video/x-msvideo"]],
|
|
["avs", "video/avs-video"],
|
|
["aw", "application/applixware"],
|
|
["axs", "application/olescript"],
|
|
["azf", "application/vnd.airzip.filesecure.azf"],
|
|
["azs", "application/vnd.airzip.filesecure.azs"],
|
|
["azw", "application/vnd.amazon.ebook"],
|
|
["bas", "text/plain"],
|
|
["bcpio", "application/x-bcpio"],
|
|
["bdf", "application/x-font-bdf"],
|
|
["bdm", "application/vnd.syncml.dm+wbxml"],
|
|
["bed", "application/vnd.realvnc.bed"],
|
|
["bh2", "application/vnd.fujitsu.oasysprs"],
|
|
["bin", ["application/octet-stream", "application/mac-binary", "application/macbinary", "application/x-macbinary", "application/x-binary"]],
|
|
["bm", "image/bmp"],
|
|
["bmi", "application/vnd.bmi"],
|
|
["bmp", ["image/bmp", "image/x-windows-bmp"]],
|
|
["boo", "application/book"],
|
|
["book", "application/book"],
|
|
["box", "application/vnd.previewsystems.box"],
|
|
["boz", "application/x-bzip2"],
|
|
["bsh", "application/x-bsh"],
|
|
["btif", "image/prs.btif"],
|
|
["bz", "application/x-bzip"],
|
|
["bz2", "application/x-bzip2"],
|
|
["c", ["text/plain", "text/x-c"]],
|
|
["c++", "text/plain"],
|
|
["c11amc", "application/vnd.cluetrust.cartomobile-config"],
|
|
["c11amz", "application/vnd.cluetrust.cartomobile-config-pkg"],
|
|
["c4g", "application/vnd.clonk.c4group"],
|
|
["cab", "application/vnd.ms-cab-compressed"],
|
|
["car", "application/vnd.curl.car"],
|
|
["cat", ["application/vnd.ms-pkiseccat", "application/vnd.ms-pki.seccat"]],
|
|
["cc", ["text/plain", "text/x-c"]],
|
|
["ccad", "application/clariscad"],
|
|
["cco", "application/x-cocoa"],
|
|
["ccxml", "application/ccxml+xml,"],
|
|
["cdbcmsg", "application/vnd.contact.cmsg"],
|
|
["cdf", ["application/cdf", "application/x-cdf", "application/x-netcdf"]],
|
|
["cdkey", "application/vnd.mediastation.cdkey"],
|
|
["cdmia", "application/cdmi-capability"],
|
|
["cdmic", "application/cdmi-container"],
|
|
["cdmid", "application/cdmi-domain"],
|
|
["cdmio", "application/cdmi-object"],
|
|
["cdmiq", "application/cdmi-queue"],
|
|
["cdx", "chemical/x-cdx"],
|
|
["cdxml", "application/vnd.chemdraw+xml"],
|
|
["cdy", "application/vnd.cinderella"],
|
|
["cer", ["application/pkix-cert", "application/x-x509-ca-cert"]],
|
|
["cgm", "image/cgm"],
|
|
["cha", "application/x-chat"],
|
|
["chat", "application/x-chat"],
|
|
["chm", "application/vnd.ms-htmlhelp"],
|
|
["chrt", "application/vnd.kde.kchart"],
|
|
["cif", "chemical/x-cif"],
|
|
["cii", "application/vnd.anser-web-certificate-issue-initiation"],
|
|
["cil", "application/vnd.ms-artgalry"],
|
|
["cla", "application/vnd.claymore"],
|
|
["class", ["application/octet-stream", "application/java", "application/java-byte-code", "application/java-vm", "application/x-java-class"]],
|
|
["clkk", "application/vnd.crick.clicker.keyboard"],
|
|
["clkp", "application/vnd.crick.clicker.palette"],
|
|
["clkt", "application/vnd.crick.clicker.template"],
|
|
["clkw", "application/vnd.crick.clicker.wordbank"],
|
|
["clkx", "application/vnd.crick.clicker"],
|
|
["clp", "application/x-msclip"],
|
|
["cmc", "application/vnd.cosmocaller"],
|
|
["cmdf", "chemical/x-cmdf"],
|
|
["cml", "chemical/x-cml"],
|
|
["cmp", "application/vnd.yellowriver-custom-menu"],
|
|
["cmx", "image/x-cmx"],
|
|
["cod", ["image/cis-cod", "application/vnd.rim.cod"]],
|
|
["com", ["application/octet-stream", "text/plain"]],
|
|
["conf", "text/plain"],
|
|
["cpio", "application/x-cpio"],
|
|
["cpp", "text/x-c"],
|
|
["cpt", ["application/mac-compactpro", "application/x-compactpro", "application/x-cpt"]],
|
|
["crd", "application/x-mscardfile"],
|
|
["crl", ["application/pkix-crl", "application/pkcs-crl"]],
|
|
["crt", ["application/pkix-cert", "application/x-x509-user-cert", "application/x-x509-ca-cert"]],
|
|
["cryptonote", "application/vnd.rig.cryptonote"],
|
|
["csh", ["text/x-script.csh", "application/x-csh"]],
|
|
["csml", "chemical/x-csml"],
|
|
["csp", "application/vnd.commonspace"],
|
|
["css", ["text/css", "application/x-pointplus"]],
|
|
["csv", "text/csv"],
|
|
["cu", "application/cu-seeme"],
|
|
["curl", "text/vnd.curl"],
|
|
["cww", "application/prs.cww"],
|
|
["cxx", "text/plain"],
|
|
["dae", "model/vnd.collada+xml"],
|
|
["daf", "application/vnd.mobius.daf"],
|
|
["davmount", "application/davmount+xml"],
|
|
["dcr", "application/x-director"],
|
|
["dcurl", "text/vnd.curl.dcurl"],
|
|
["dd2", "application/vnd.oma.dd2+xml"],
|
|
["ddd", "application/vnd.fujixerox.ddd"],
|
|
["deb", "application/x-debian-package"],
|
|
["deepv", "application/x-deepv"],
|
|
["def", "text/plain"],
|
|
["der", "application/x-x509-ca-cert"],
|
|
["dfac", "application/vnd.dreamfactory"],
|
|
["dif", "video/x-dv"],
|
|
["dir", "application/x-director"],
|
|
["dis", "application/vnd.mobius.dis"],
|
|
["djvu", "image/vnd.djvu"],
|
|
["dl", ["video/dl", "video/x-dl"]],
|
|
["dll", "application/x-msdownload"],
|
|
["dms", "application/octet-stream"],
|
|
["dna", "application/vnd.dna"],
|
|
["doc", "application/msword"],
|
|
["docm", "application/vnd.ms-word.document.macroenabled.12"],
|
|
["docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
|
|
["dot", "application/msword"],
|
|
["dotm", "application/vnd.ms-word.template.macroenabled.12"],
|
|
["dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"],
|
|
["dp", ["application/commonground", "application/vnd.osgi.dp"]],
|
|
["dpg", "application/vnd.dpgraph"],
|
|
["dra", "audio/vnd.dra"],
|
|
["drw", "application/drafting"],
|
|
["dsc", "text/prs.lines.tag"],
|
|
["dssc", "application/dssc+der"],
|
|
["dtb", "application/x-dtbook+xml"],
|
|
["dtd", "application/xml-dtd"],
|
|
["dts", "audio/vnd.dts"],
|
|
["dtshd", "audio/vnd.dts.hd"],
|
|
["dump", "application/octet-stream"],
|
|
["dv", "video/x-dv"],
|
|
["dvi", "application/x-dvi"],
|
|
["dwf", ["model/vnd.dwf", "drawing/x-dwf"]],
|
|
["dwg", ["application/acad", "image/vnd.dwg", "image/x-dwg"]],
|
|
["dxf", ["application/dxf", "image/vnd.dwg", "image/vnd.dxf", "image/x-dwg"]],
|
|
["dxp", "application/vnd.spotfire.dxp"],
|
|
["dxr", "application/x-director"],
|
|
["ecelp4800", "audio/vnd.nuera.ecelp4800"],
|
|
["ecelp7470", "audio/vnd.nuera.ecelp7470"],
|
|
["ecelp9600", "audio/vnd.nuera.ecelp9600"],
|
|
["edm", "application/vnd.novadigm.edm"],
|
|
["edx", "application/vnd.novadigm.edx"],
|
|
["efif", "application/vnd.picsel"],
|
|
["ei6", "application/vnd.pg.osasli"],
|
|
["el", "text/x-script.elisp"],
|
|
["elc", ["application/x-elc", "application/x-bytecode.elisp"]],
|
|
["eml", "message/rfc822"],
|
|
["emma", "application/emma+xml"],
|
|
["env", "application/x-envoy"],
|
|
["eol", "audio/vnd.digital-winds"],
|
|
["eot", "application/vnd.ms-fontobject"],
|
|
["eps", "application/postscript"],
|
|
["epub", "application/epub+zip"],
|
|
["es", ["application/ecmascript", "application/x-esrehber"]],
|
|
["es3", "application/vnd.eszigno3+xml"],
|
|
["esf", "application/vnd.epson.esf"],
|
|
["etx", "text/x-setext"],
|
|
["evy", ["application/envoy", "application/x-envoy"]],
|
|
["exe", ["application/octet-stream", "application/x-msdownload"]],
|
|
["exi", "application/exi"],
|
|
["ext", "application/vnd.novadigm.ext"],
|
|
["ez2", "application/vnd.ezpix-album"],
|
|
["ez3", "application/vnd.ezpix-package"],
|
|
["f", ["text/plain", "text/x-fortran"]],
|
|
["f4v", "video/x-f4v"],
|
|
["f77", "text/x-fortran"],
|
|
["f90", ["text/plain", "text/x-fortran"]],
|
|
["fbs", "image/vnd.fastbidsheet"],
|
|
["fcs", "application/vnd.isac.fcs"],
|
|
["fdf", "application/vnd.fdf"],
|
|
["fe_launch", "application/vnd.denovo.fcselayout-link"],
|
|
["fg5", "application/vnd.fujitsu.oasysgp"],
|
|
["fh", "image/x-freehand"],
|
|
["fif", ["application/fractals", "image/fif"]],
|
|
["fig", "application/x-xfig"],
|
|
["fli", ["video/fli", "video/x-fli"]],
|
|
["flo", ["image/florian", "application/vnd.micrografx.flo"]],
|
|
["flr", "x-world/x-vrml"],
|
|
["flv", "video/x-flv"],
|
|
["flw", "application/vnd.kde.kivio"],
|
|
["flx", "text/vnd.fmi.flexstor"],
|
|
["fly", "text/vnd.fly"],
|
|
["fm", "application/vnd.framemaker"],
|
|
["fmf", "video/x-atomic3d-feature"],
|
|
["fnc", "application/vnd.frogans.fnc"],
|
|
["for", ["text/plain", "text/x-fortran"]],
|
|
["fpx", ["image/vnd.fpx", "image/vnd.net-fpx"]],
|
|
["frl", "application/freeloader"],
|
|
["fsc", "application/vnd.fsc.weblaunch"],
|
|
["fst", "image/vnd.fst"],
|
|
["ftc", "application/vnd.fluxtime.clip"],
|
|
["fti", "application/vnd.anser-web-funds-transfer-initiation"],
|
|
["funk", "audio/make"],
|
|
["fvt", "video/vnd.fvt"],
|
|
["fxp", "application/vnd.adobe.fxp"],
|
|
["fzs", "application/vnd.fuzzysheet"],
|
|
["g", "text/plain"],
|
|
["g2w", "application/vnd.geoplan"],
|
|
["g3", "image/g3fax"],
|
|
["g3w", "application/vnd.geospace"],
|
|
["gac", "application/vnd.groove-account"],
|
|
["gdl", "model/vnd.gdl"],
|
|
["geo", "application/vnd.dynageo"],
|
|
["gex", "application/vnd.geometry-explorer"],
|
|
["ggb", "application/vnd.geogebra.file"],
|
|
["ggt", "application/vnd.geogebra.tool"],
|
|
["ghf", "application/vnd.groove-help"],
|
|
["gif", "image/gif"],
|
|
["gim", "application/vnd.groove-identity-message"],
|
|
["gl", ["video/gl", "video/x-gl"]],
|
|
["gmx", "application/vnd.gmx"],
|
|
["gnumeric", "application/x-gnumeric"],
|
|
["gph", "application/vnd.flographit"],
|
|
["gqf", "application/vnd.grafeq"],
|
|
["gram", "application/srgs"],
|
|
["grv", "application/vnd.groove-injector"],
|
|
["grxml", "application/srgs+xml"],
|
|
["gsd", "audio/x-gsm"],
|
|
["gsf", "application/x-font-ghostscript"],
|
|
["gsm", "audio/x-gsm"],
|
|
["gsp", "application/x-gsp"],
|
|
["gss", "application/x-gss"],
|
|
["gtar", "application/x-gtar"],
|
|
["gtm", "application/vnd.groove-tool-message"],
|
|
["gtw", "model/vnd.gtw"],
|
|
["gv", "text/vnd.graphviz"],
|
|
["gxt", "application/vnd.geonext"],
|
|
["gz", ["application/x-gzip", "application/x-compressed"]],
|
|
["gzip", ["multipart/x-gzip", "application/x-gzip"]],
|
|
["h", ["text/plain", "text/x-h"]],
|
|
["h261", "video/h261"],
|
|
["h263", "video/h263"],
|
|
["h264", "video/h264"],
|
|
["hal", "application/vnd.hal+xml"],
|
|
["hbci", "application/vnd.hbci"],
|
|
["hdf", "application/x-hdf"],
|
|
["help", "application/x-helpfile"],
|
|
["hgl", "application/vnd.hp-hpgl"],
|
|
["hh", ["text/plain", "text/x-h"]],
|
|
["hlb", "text/x-script"],
|
|
["hlp", ["application/winhlp", "application/hlp", "application/x-helpfile", "application/x-winhelp"]],
|
|
["hpg", "application/vnd.hp-hpgl"],
|
|
["hpgl", "application/vnd.hp-hpgl"],
|
|
["hpid", "application/vnd.hp-hpid"],
|
|
["hps", "application/vnd.hp-hps"],
|
|
[
|
|
"hqx",
|
|
[
|
|
"application/mac-binhex40",
|
|
"application/binhex",
|
|
"application/binhex4",
|
|
"application/mac-binhex",
|
|
"application/x-binhex40",
|
|
"application/x-mac-binhex40"
|
|
]
|
|
],
|
|
["hta", "application/hta"],
|
|
["htc", "text/x-component"],
|
|
["htke", "application/vnd.kenameaapp"],
|
|
["htm", "text/html"],
|
|
["html", "text/html"],
|
|
["htmls", "text/html"],
|
|
["htt", "text/webviewhtml"],
|
|
["htx", "text/html"],
|
|
["hvd", "application/vnd.yamaha.hv-dic"],
|
|
["hvp", "application/vnd.yamaha.hv-voice"],
|
|
["hvs", "application/vnd.yamaha.hv-script"],
|
|
["i2g", "application/vnd.intergeo"],
|
|
["icc", "application/vnd.iccprofile"],
|
|
["ice", "x-conference/x-cooltalk"],
|
|
["ico", "image/x-icon"],
|
|
["ics", "text/calendar"],
|
|
["idc", "text/plain"],
|
|
["ief", "image/ief"],
|
|
["iefs", "image/ief"],
|
|
["ifm", "application/vnd.shana.informed.formdata"],
|
|
["iges", ["application/iges", "model/iges"]],
|
|
["igl", "application/vnd.igloader"],
|
|
["igm", "application/vnd.insors.igm"],
|
|
["igs", ["application/iges", "model/iges"]],
|
|
["igx", "application/vnd.micrografx.igx"],
|
|
["iif", "application/vnd.shana.informed.interchange"],
|
|
["iii", "application/x-iphone"],
|
|
["ima", "application/x-ima"],
|
|
["imap", "application/x-httpd-imap"],
|
|
["imp", "application/vnd.accpac.simply.imp"],
|
|
["ims", "application/vnd.ms-ims"],
|
|
["inf", "application/inf"],
|
|
["ins", ["application/x-internet-signup", "application/x-internett-signup"]],
|
|
["ip", "application/x-ip2"],
|
|
["ipfix", "application/ipfix"],
|
|
["ipk", "application/vnd.shana.informed.package"],
|
|
["irm", "application/vnd.ibm.rights-management"],
|
|
["irp", "application/vnd.irepository.package+xml"],
|
|
["isp", "application/x-internet-signup"],
|
|
["isu", "video/x-isvideo"],
|
|
["it", "audio/it"],
|
|
["itp", "application/vnd.shana.informed.formtemplate"],
|
|
["iv", "application/x-inventor"],
|
|
["ivp", "application/vnd.immervision-ivp"],
|
|
["ivr", "i-world/i-vrml"],
|
|
["ivu", "application/vnd.immervision-ivu"],
|
|
["ivy", "application/x-livescreen"],
|
|
["jad", "text/vnd.sun.j2me.app-descriptor"],
|
|
["jam", ["application/vnd.jam", "audio/x-jam"]],
|
|
["jar", "application/java-archive"],
|
|
["jav", ["text/plain", "text/x-java-source"]],
|
|
["java", ["text/plain", "text/x-java-source,java", "text/x-java-source"]],
|
|
["jcm", "application/x-java-commerce"],
|
|
["jfif", ["image/pipeg", "image/jpeg", "image/pjpeg"]],
|
|
["jfif-tbnl", "image/jpeg"],
|
|
["jisp", "application/vnd.jisp"],
|
|
["jlt", "application/vnd.hp-jlyt"],
|
|
["jnlp", "application/x-java-jnlp-file"],
|
|
["joda", "application/vnd.joost.joda-archive"],
|
|
["jpe", ["image/jpeg", "image/pjpeg"]],
|
|
["jpeg", ["image/jpeg", "image/pjpeg"]],
|
|
["jpg", ["image/jpeg", "image/pjpeg"]],
|
|
["jpgv", "video/jpeg"],
|
|
["jpm", "video/jpm"],
|
|
["jps", "image/x-jps"],
|
|
["js", ["application/javascript", "application/ecmascript", "text/javascript", "text/ecmascript", "application/x-javascript"]],
|
|
["json", "application/json"],
|
|
["jut", "image/jutvision"],
|
|
["kar", ["audio/midi", "music/x-karaoke"]],
|
|
["karbon", "application/vnd.kde.karbon"],
|
|
["kfo", "application/vnd.kde.kformula"],
|
|
["kia", "application/vnd.kidspiration"],
|
|
["kml", "application/vnd.google-earth.kml+xml"],
|
|
["kmz", "application/vnd.google-earth.kmz"],
|
|
["kne", "application/vnd.kinar"],
|
|
["kon", "application/vnd.kde.kontour"],
|
|
["kpr", "application/vnd.kde.kpresenter"],
|
|
["ksh", ["application/x-ksh", "text/x-script.ksh"]],
|
|
["ksp", "application/vnd.kde.kspread"],
|
|
["ktx", "image/ktx"],
|
|
["ktz", "application/vnd.kahootz"],
|
|
["kwd", "application/vnd.kde.kword"],
|
|
["la", ["audio/nspaudio", "audio/x-nspaudio"]],
|
|
["lam", "audio/x-liveaudio"],
|
|
["lasxml", "application/vnd.las.las+xml"],
|
|
["latex", "application/x-latex"],
|
|
["lbd", "application/vnd.llamagraphics.life-balance.desktop"],
|
|
["lbe", "application/vnd.llamagraphics.life-balance.exchange+xml"],
|
|
["les", "application/vnd.hhe.lesson-player"],
|
|
["lha", ["application/octet-stream", "application/lha", "application/x-lha"]],
|
|
["lhx", "application/octet-stream"],
|
|
["link66", "application/vnd.route66.link66+xml"],
|
|
["list", "text/plain"],
|
|
["lma", ["audio/nspaudio", "audio/x-nspaudio"]],
|
|
["log", "text/plain"],
|
|
["lrm", "application/vnd.ms-lrm"],
|
|
["lsf", "video/x-la-asf"],
|
|
["lsp", ["application/x-lisp", "text/x-script.lisp"]],
|
|
["lst", "text/plain"],
|
|
["lsx", ["video/x-la-asf", "text/x-la-asf"]],
|
|
["ltf", "application/vnd.frogans.ltf"],
|
|
["ltx", "application/x-latex"],
|
|
["lvp", "audio/vnd.lucent.voice"],
|
|
["lwp", "application/vnd.lotus-wordpro"],
|
|
["lzh", ["application/octet-stream", "application/x-lzh"]],
|
|
["lzx", ["application/lzx", "application/octet-stream", "application/x-lzx"]],
|
|
["m", ["text/plain", "text/x-m"]],
|
|
["m13", "application/x-msmediaview"],
|
|
["m14", "application/x-msmediaview"],
|
|
["m1v", "video/mpeg"],
|
|
["m21", "application/mp21"],
|
|
["m2a", "audio/mpeg"],
|
|
["m2v", "video/mpeg"],
|
|
["m3u", ["audio/x-mpegurl", "audio/x-mpequrl"]],
|
|
["m3u8", "application/vnd.apple.mpegurl"],
|
|
["m4v", "video/x-m4v"],
|
|
["ma", "application/mathematica"],
|
|
["mads", "application/mads+xml"],
|
|
["mag", "application/vnd.ecowin.chart"],
|
|
["man", "application/x-troff-man"],
|
|
["map", "application/x-navimap"],
|
|
["mar", "text/plain"],
|
|
["mathml", "application/mathml+xml"],
|
|
["mbd", "application/mbedlet"],
|
|
["mbk", "application/vnd.mobius.mbk"],
|
|
["mbox", "application/mbox"],
|
|
["mc$", "application/x-magic-cap-package-1.0"],
|
|
["mc1", "application/vnd.medcalcdata"],
|
|
["mcd", ["application/mcad", "application/vnd.mcd", "application/x-mathcad"]],
|
|
["mcf", ["image/vasa", "text/mcf"]],
|
|
["mcp", "application/netmc"],
|
|
["mcurl", "text/vnd.curl.mcurl"],
|
|
["mdb", "application/x-msaccess"],
|
|
["mdi", "image/vnd.ms-modi"],
|
|
["me", "application/x-troff-me"],
|
|
["meta4", "application/metalink4+xml"],
|
|
["mets", "application/mets+xml"],
|
|
["mfm", "application/vnd.mfmp"],
|
|
["mgp", "application/vnd.osgeo.mapguide.package"],
|
|
["mgz", "application/vnd.proteus.magazine"],
|
|
["mht", "message/rfc822"],
|
|
["mhtml", "message/rfc822"],
|
|
["mid", ["audio/mid", "audio/midi", "music/crescendo", "x-music/x-midi", "audio/x-midi", "application/x-midi", "audio/x-mid"]],
|
|
["midi", ["audio/midi", "music/crescendo", "x-music/x-midi", "audio/x-midi", "application/x-midi", "audio/x-mid"]],
|
|
["mif", ["application/vnd.mif", "application/x-mif", "application/x-frame"]],
|
|
["mime", ["message/rfc822", "www/mime"]],
|
|
["mj2", "video/mj2"],
|
|
["mjf", "audio/x-vnd.audioexplosion.mjuicemediafile"],
|
|
["mjpg", "video/x-motion-jpeg"],
|
|
["mlp", "application/vnd.dolby.mlp"],
|
|
["mm", ["application/base64", "application/x-meme"]],
|
|
["mmd", "application/vnd.chipnuts.karaoke-mmd"],
|
|
["mme", "application/base64"],
|
|
["mmf", "application/vnd.smaf"],
|
|
["mmr", "image/vnd.fujixerox.edmics-mmr"],
|
|
["mny", "application/x-msmoney"],
|
|
["mod", ["audio/mod", "audio/x-mod"]],
|
|
["mods", "application/mods+xml"],
|
|
["moov", "video/quicktime"],
|
|
["mov", "video/quicktime"],
|
|
["movie", "video/x-sgi-movie"],
|
|
["mp2", ["video/mpeg", "audio/mpeg", "video/x-mpeg", "audio/x-mpeg", "video/x-mpeq2a"]],
|
|
["mp3", ["audio/mpeg", "audio/mpeg3", "video/mpeg", "audio/x-mpeg-3", "video/x-mpeg"]],
|
|
["mp4", ["video/mp4", "application/mp4"]],
|
|
["mp4a", "audio/mp4"],
|
|
["mpa", ["video/mpeg", "audio/mpeg"]],
|
|
["mpc", ["application/vnd.mophun.certificate", "application/x-project"]],
|
|
["mpe", "video/mpeg"],
|
|
["mpeg", "video/mpeg"],
|
|
["mpg", ["video/mpeg", "audio/mpeg"]],
|
|
["mpga", "audio/mpeg"],
|
|
["mpkg", "application/vnd.apple.installer+xml"],
|
|
["mpm", "application/vnd.blueice.multipass"],
|
|
["mpn", "application/vnd.mophun.application"],
|
|
["mpp", "application/vnd.ms-project"],
|
|
["mpt", "application/x-project"],
|
|
["mpv", "application/x-project"],
|
|
["mpv2", "video/mpeg"],
|
|
["mpx", "application/x-project"],
|
|
["mpy", "application/vnd.ibm.minipay"],
|
|
["mqy", "application/vnd.mobius.mqy"],
|
|
["mrc", "application/marc"],
|
|
["mrcx", "application/marcxml+xml"],
|
|
["ms", "application/x-troff-ms"],
|
|
["mscml", "application/mediaservercontrol+xml"],
|
|
["mseq", "application/vnd.mseq"],
|
|
["msf", "application/vnd.epson.msf"],
|
|
["msg", "application/vnd.ms-outlook"],
|
|
["msh", "model/mesh"],
|
|
["msl", "application/vnd.mobius.msl"],
|
|
["msty", "application/vnd.muvee.style"],
|
|
["mts", "model/vnd.mts"],
|
|
["mus", "application/vnd.musician"],
|
|
["musicxml", "application/vnd.recordare.musicxml+xml"],
|
|
["mv", "video/x-sgi-movie"],
|
|
["mvb", "application/x-msmediaview"],
|
|
["mwf", "application/vnd.mfer"],
|
|
["mxf", "application/mxf"],
|
|
["mxl", "application/vnd.recordare.musicxml"],
|
|
["mxml", "application/xv+xml"],
|
|
["mxs", "application/vnd.triscape.mxs"],
|
|
["mxu", "video/vnd.mpegurl"],
|
|
["my", "audio/make"],
|
|
["mzz", "application/x-vnd.audioexplosion.mzz"],
|
|
["n-gage", "application/vnd.nokia.n-gage.symbian.install"],
|
|
["n3", "text/n3"],
|
|
["nap", "image/naplps"],
|
|
["naplps", "image/naplps"],
|
|
["nbp", "application/vnd.wolfram.player"],
|
|
["nc", "application/x-netcdf"],
|
|
["ncm", "application/vnd.nokia.configuration-message"],
|
|
["ncx", "application/x-dtbncx+xml"],
|
|
["ngdat", "application/vnd.nokia.n-gage.data"],
|
|
["nif", "image/x-niff"],
|
|
["niff", "image/x-niff"],
|
|
["nix", "application/x-mix-transfer"],
|
|
["nlu", "application/vnd.neurolanguage.nlu"],
|
|
["nml", "application/vnd.enliven"],
|
|
["nnd", "application/vnd.noblenet-directory"],
|
|
["nns", "application/vnd.noblenet-sealer"],
|
|
["nnw", "application/vnd.noblenet-web"],
|
|
["npx", "image/vnd.net-fpx"],
|
|
["nsc", "application/x-conference"],
|
|
["nsf", "application/vnd.lotus-notes"],
|
|
["nvd", "application/x-navidoc"],
|
|
["nws", "message/rfc822"],
|
|
["o", "application/octet-stream"],
|
|
["oa2", "application/vnd.fujitsu.oasys2"],
|
|
["oa3", "application/vnd.fujitsu.oasys3"],
|
|
["oas", "application/vnd.fujitsu.oasys"],
|
|
["obd", "application/x-msbinder"],
|
|
["oda", "application/oda"],
|
|
["odb", "application/vnd.oasis.opendocument.database"],
|
|
["odc", "application/vnd.oasis.opendocument.chart"],
|
|
["odf", "application/vnd.oasis.opendocument.formula"],
|
|
["odft", "application/vnd.oasis.opendocument.formula-template"],
|
|
["odg", "application/vnd.oasis.opendocument.graphics"],
|
|
["odi", "application/vnd.oasis.opendocument.image"],
|
|
["odm", "application/vnd.oasis.opendocument.text-master"],
|
|
["odp", "application/vnd.oasis.opendocument.presentation"],
|
|
["ods", "application/vnd.oasis.opendocument.spreadsheet"],
|
|
["odt", "application/vnd.oasis.opendocument.text"],
|
|
["oga", "audio/ogg"],
|
|
["ogv", "video/ogg"],
|
|
["ogx", "application/ogg"],
|
|
["omc", "application/x-omc"],
|
|
["omcd", "application/x-omcdatamaker"],
|
|
["omcr", "application/x-omcregerator"],
|
|
["onetoc", "application/onenote"],
|
|
["opf", "application/oebps-package+xml"],
|
|
["org", "application/vnd.lotus-organizer"],
|
|
["osf", "application/vnd.yamaha.openscoreformat"],
|
|
["osfpvg", "application/vnd.yamaha.openscoreformat.osfpvg+xml"],
|
|
["otc", "application/vnd.oasis.opendocument.chart-template"],
|
|
["otf", "application/x-font-otf"],
|
|
["otg", "application/vnd.oasis.opendocument.graphics-template"],
|
|
["oth", "application/vnd.oasis.opendocument.text-web"],
|
|
["oti", "application/vnd.oasis.opendocument.image-template"],
|
|
["otp", "application/vnd.oasis.opendocument.presentation-template"],
|
|
["ots", "application/vnd.oasis.opendocument.spreadsheet-template"],
|
|
["ott", "application/vnd.oasis.opendocument.text-template"],
|
|
["oxt", "application/vnd.openofficeorg.extension"],
|
|
["p", "text/x-pascal"],
|
|
["p10", ["application/pkcs10", "application/x-pkcs10"]],
|
|
["p12", ["application/pkcs-12", "application/x-pkcs12"]],
|
|
["p7a", "application/x-pkcs7-signature"],
|
|
["p7b", "application/x-pkcs7-certificates"],
|
|
["p7c", ["application/pkcs7-mime", "application/x-pkcs7-mime"]],
|
|
["p7m", ["application/pkcs7-mime", "application/x-pkcs7-mime"]],
|
|
["p7r", "application/x-pkcs7-certreqresp"],
|
|
["p7s", ["application/pkcs7-signature", "application/x-pkcs7-signature"]],
|
|
["p8", "application/pkcs8"],
|
|
["par", "text/plain-bas"],
|
|
["part", "application/pro_eng"],
|
|
["pas", "text/pascal"],
|
|
["paw", "application/vnd.pawaafile"],
|
|
["pbd", "application/vnd.powerbuilder6"],
|
|
["pbm", "image/x-portable-bitmap"],
|
|
["pcf", "application/x-font-pcf"],
|
|
["pcl", ["application/vnd.hp-pcl", "application/x-pcl"]],
|
|
["pclxl", "application/vnd.hp-pclxl"],
|
|
["pct", "image/x-pict"],
|
|
["pcurl", "application/vnd.curl.pcurl"],
|
|
["pcx", "image/x-pcx"],
|
|
["pdb", ["application/vnd.palm", "chemical/x-pdb"]],
|
|
["pdf", "application/pdf"],
|
|
["pfa", "application/x-font-type1"],
|
|
["pfr", "application/font-tdpfr"],
|
|
["pfunk", ["audio/make", "audio/make.my.funk"]],
|
|
["pfx", "application/x-pkcs12"],
|
|
["pgm", ["image/x-portable-graymap", "image/x-portable-greymap"]],
|
|
["pgn", "application/x-chess-pgn"],
|
|
["pgp", "application/pgp-signature"],
|
|
["pic", ["image/pict", "image/x-pict"]],
|
|
["pict", "image/pict"],
|
|
["pkg", "application/x-newton-compatible-pkg"],
|
|
["pki", "application/pkixcmp"],
|
|
["pkipath", "application/pkix-pkipath"],
|
|
["pko", ["application/ynd.ms-pkipko", "application/vnd.ms-pki.pko"]],
|
|
["pl", ["text/plain", "text/x-script.perl"]],
|
|
["plb", "application/vnd.3gpp.pic-bw-large"],
|
|
["plc", "application/vnd.mobius.plc"],
|
|
["plf", "application/vnd.pocketlearn"],
|
|
["pls", "application/pls+xml"],
|
|
["plx", "application/x-pixclscript"],
|
|
["pm", ["text/x-script.perl-module", "image/x-xpixmap"]],
|
|
["pm4", "application/x-pagemaker"],
|
|
["pm5", "application/x-pagemaker"],
|
|
["pma", "application/x-perfmon"],
|
|
["pmc", "application/x-perfmon"],
|
|
["pml", ["application/vnd.ctc-posml", "application/x-perfmon"]],
|
|
["pmr", "application/x-perfmon"],
|
|
["pmw", "application/x-perfmon"],
|
|
["png", "image/png"],
|
|
["pnm", ["application/x-portable-anymap", "image/x-portable-anymap"]],
|
|
["portpkg", "application/vnd.macports.portpkg"],
|
|
["pot", ["application/vnd.ms-powerpoint", "application/mspowerpoint"]],
|
|
["potm", "application/vnd.ms-powerpoint.template.macroenabled.12"],
|
|
["potx", "application/vnd.openxmlformats-officedocument.presentationml.template"],
|
|
["pov", "model/x-pov"],
|
|
["ppa", "application/vnd.ms-powerpoint"],
|
|
["ppam", "application/vnd.ms-powerpoint.addin.macroenabled.12"],
|
|
["ppd", "application/vnd.cups-ppd"],
|
|
["ppm", "image/x-portable-pixmap"],
|
|
["pps", ["application/vnd.ms-powerpoint", "application/mspowerpoint"]],
|
|
["ppsm", "application/vnd.ms-powerpoint.slideshow.macroenabled.12"],
|
|
["ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow"],
|
|
["ppt", ["application/vnd.ms-powerpoint", "application/mspowerpoint", "application/powerpoint", "application/x-mspowerpoint"]],
|
|
["pptm", "application/vnd.ms-powerpoint.presentation.macroenabled.12"],
|
|
["pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
|
|
["ppz", "application/mspowerpoint"],
|
|
["prc", "application/x-mobipocket-ebook"],
|
|
["pre", ["application/vnd.lotus-freelance", "application/x-freelance"]],
|
|
["prf", "application/pics-rules"],
|
|
["prt", "application/pro_eng"],
|
|
["ps", "application/postscript"],
|
|
["psb", "application/vnd.3gpp.pic-bw-small"],
|
|
["psd", ["application/octet-stream", "image/vnd.adobe.photoshop"]],
|
|
["psf", "application/x-font-linux-psf"],
|
|
["pskcxml", "application/pskc+xml"],
|
|
["ptid", "application/vnd.pvi.ptid1"],
|
|
["pub", "application/x-mspublisher"],
|
|
["pvb", "application/vnd.3gpp.pic-bw-var"],
|
|
["pvu", "paleovu/x-pv"],
|
|
["pwn", "application/vnd.3m.post-it-notes"],
|
|
["pwz", "application/vnd.ms-powerpoint"],
|
|
["py", "text/x-script.phyton"],
|
|
["pya", "audio/vnd.ms-playready.media.pya"],
|
|
["pyc", "application/x-bytecode.python"],
|
|
["pyv", "video/vnd.ms-playready.media.pyv"],
|
|
["qam", "application/vnd.epson.quickanime"],
|
|
["qbo", "application/vnd.intu.qbo"],
|
|
["qcp", "audio/vnd.qcelp"],
|
|
["qd3", "x-world/x-3dmf"],
|
|
["qd3d", "x-world/x-3dmf"],
|
|
["qfx", "application/vnd.intu.qfx"],
|
|
["qif", "image/x-quicktime"],
|
|
["qps", "application/vnd.publishare-delta-tree"],
|
|
["qt", "video/quicktime"],
|
|
["qtc", "video/x-qtc"],
|
|
["qti", "image/x-quicktime"],
|
|
["qtif", "image/x-quicktime"],
|
|
["qxd", "application/vnd.quark.quarkxpress"],
|
|
["ra", ["audio/x-realaudio", "audio/x-pn-realaudio", "audio/x-pn-realaudio-plugin"]],
|
|
["ram", "audio/x-pn-realaudio"],
|
|
["rar", "application/x-rar-compressed"],
|
|
["ras", ["image/cmu-raster", "application/x-cmu-raster", "image/x-cmu-raster"]],
|
|
["rast", "image/cmu-raster"],
|
|
["rcprofile", "application/vnd.ipunplugged.rcprofile"],
|
|
["rdf", "application/rdf+xml"],
|
|
["rdz", "application/vnd.data-vision.rdz"],
|
|
["rep", "application/vnd.businessobjects"],
|
|
["res", "application/x-dtbresource+xml"],
|
|
["rexx", "text/x-script.rexx"],
|
|
["rf", "image/vnd.rn-realflash"],
|
|
["rgb", "image/x-rgb"],
|
|
["rif", "application/reginfo+xml"],
|
|
["rip", "audio/vnd.rip"],
|
|
["rl", "application/resource-lists+xml"],
|
|
["rlc", "image/vnd.fujixerox.edmics-rlc"],
|
|
["rld", "application/resource-lists-diff+xml"],
|
|
["rm", ["application/vnd.rn-realmedia", "audio/x-pn-realaudio"]],
|
|
["rmi", "audio/mid"],
|
|
["rmm", "audio/x-pn-realaudio"],
|
|
["rmp", ["audio/x-pn-realaudio-plugin", "audio/x-pn-realaudio"]],
|
|
["rms", "application/vnd.jcp.javame.midlet-rms"],
|
|
["rnc", "application/relax-ng-compact-syntax"],
|
|
["rng", ["application/ringing-tones", "application/vnd.nokia.ringing-tone"]],
|
|
["rnx", "application/vnd.rn-realplayer"],
|
|
["roff", "application/x-troff"],
|
|
["rp", "image/vnd.rn-realpix"],
|
|
["rp9", "application/vnd.cloanto.rp9"],
|
|
["rpm", "audio/x-pn-realaudio-plugin"],
|
|
["rpss", "application/vnd.nokia.radio-presets"],
|
|
["rpst", "application/vnd.nokia.radio-preset"],
|
|
["rq", "application/sparql-query"],
|
|
["rs", "application/rls-services+xml"],
|
|
["rsd", "application/rsd+xml"],
|
|
["rt", ["text/richtext", "text/vnd.rn-realtext"]],
|
|
["rtf", ["application/rtf", "text/richtext", "application/x-rtf"]],
|
|
["rtx", ["text/richtext", "application/rtf"]],
|
|
["rv", "video/vnd.rn-realvideo"],
|
|
["s", "text/x-asm"],
|
|
["s3m", "audio/s3m"],
|
|
["saf", "application/vnd.yamaha.smaf-audio"],
|
|
["saveme", "application/octet-stream"],
|
|
["sbk", "application/x-tbook"],
|
|
["sbml", "application/sbml+xml"],
|
|
["sc", "application/vnd.ibm.secure-container"],
|
|
["scd", "application/x-msschedule"],
|
|
["scm", ["application/vnd.lotus-screencam", "video/x-scm", "text/x-script.guile", "application/x-lotusscreencam", "text/x-script.scheme"]],
|
|
["scq", "application/scvp-cv-request"],
|
|
["scs", "application/scvp-cv-response"],
|
|
["sct", "text/scriptlet"],
|
|
["scurl", "text/vnd.curl.scurl"],
|
|
["sda", "application/vnd.stardivision.draw"],
|
|
["sdc", "application/vnd.stardivision.calc"],
|
|
["sdd", "application/vnd.stardivision.impress"],
|
|
["sdkm", "application/vnd.solent.sdkm+xml"],
|
|
["sdml", "text/plain"],
|
|
["sdp", ["application/sdp", "application/x-sdp"]],
|
|
["sdr", "application/sounder"],
|
|
["sdw", "application/vnd.stardivision.writer"],
|
|
["sea", ["application/sea", "application/x-sea"]],
|
|
["see", "application/vnd.seemail"],
|
|
["seed", "application/vnd.fdsn.seed"],
|
|
["sema", "application/vnd.sema"],
|
|
["semd", "application/vnd.semd"],
|
|
["semf", "application/vnd.semf"],
|
|
["ser", "application/java-serialized-object"],
|
|
["set", "application/set"],
|
|
["setpay", "application/set-payment-initiation"],
|
|
["setreg", "application/set-registration-initiation"],
|
|
["sfd-hdstx", "application/vnd.hydrostatix.sof-data"],
|
|
["sfs", "application/vnd.spotfire.sfs"],
|
|
["sgl", "application/vnd.stardivision.writer-global"],
|
|
["sgm", ["text/sgml", "text/x-sgml"]],
|
|
["sgml", ["text/sgml", "text/x-sgml"]],
|
|
["sh", ["application/x-shar", "application/x-bsh", "application/x-sh", "text/x-script.sh"]],
|
|
["shar", ["application/x-bsh", "application/x-shar"]],
|
|
["shf", "application/shf+xml"],
|
|
["shtml", ["text/html", "text/x-server-parsed-html"]],
|
|
["sid", "audio/x-psid"],
|
|
["sis", "application/vnd.symbian.install"],
|
|
["sit", ["application/x-stuffit", "application/x-sit"]],
|
|
["sitx", "application/x-stuffitx"],
|
|
["skd", "application/x-koan"],
|
|
["skm", "application/x-koan"],
|
|
["skp", ["application/vnd.koan", "application/x-koan"]],
|
|
["skt", "application/x-koan"],
|
|
["sl", "application/x-seelogo"],
|
|
["sldm", "application/vnd.ms-powerpoint.slide.macroenabled.12"],
|
|
["sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide"],
|
|
["slt", "application/vnd.epson.salt"],
|
|
["sm", "application/vnd.stepmania.stepchart"],
|
|
["smf", "application/vnd.stardivision.math"],
|
|
["smi", ["application/smil", "application/smil+xml"]],
|
|
["smil", "application/smil"],
|
|
["snd", ["audio/basic", "audio/x-adpcm"]],
|
|
["snf", "application/x-font-snf"],
|
|
["sol", "application/solids"],
|
|
["spc", ["text/x-speech", "application/x-pkcs7-certificates"]],
|
|
["spf", "application/vnd.yamaha.smaf-phrase"],
|
|
["spl", ["application/futuresplash", "application/x-futuresplash"]],
|
|
["spot", "text/vnd.in3d.spot"],
|
|
["spp", "application/scvp-vp-response"],
|
|
["spq", "application/scvp-vp-request"],
|
|
["spr", "application/x-sprite"],
|
|
["sprite", "application/x-sprite"],
|
|
["src", "application/x-wais-source"],
|
|
["sru", "application/sru+xml"],
|
|
["srx", "application/sparql-results+xml"],
|
|
["sse", "application/vnd.kodak-descriptor"],
|
|
["ssf", "application/vnd.epson.ssf"],
|
|
["ssi", "text/x-server-parsed-html"],
|
|
["ssm", "application/streamingmedia"],
|
|
["ssml", "application/ssml+xml"],
|
|
["sst", ["application/vnd.ms-pkicertstore", "application/vnd.ms-pki.certstore"]],
|
|
["st", "application/vnd.sailingtracker.track"],
|
|
["stc", "application/vnd.sun.xml.calc.template"],
|
|
["std", "application/vnd.sun.xml.draw.template"],
|
|
["step", "application/step"],
|
|
["stf", "application/vnd.wt.stf"],
|
|
["sti", "application/vnd.sun.xml.impress.template"],
|
|
["stk", "application/hyperstudio"],
|
|
["stl", ["application/vnd.ms-pkistl", "application/sla", "application/vnd.ms-pki.stl", "application/x-navistyle"]],
|
|
["stm", "text/html"],
|
|
["stp", "application/step"],
|
|
["str", "application/vnd.pg.format"],
|
|
["stw", "application/vnd.sun.xml.writer.template"],
|
|
["sub", "image/vnd.dvb.subtitle"],
|
|
["sus", "application/vnd.sus-calendar"],
|
|
["sv4cpio", "application/x-sv4cpio"],
|
|
["sv4crc", "application/x-sv4crc"],
|
|
["svc", "application/vnd.dvb.service"],
|
|
["svd", "application/vnd.svd"],
|
|
["svf", ["image/vnd.dwg", "image/x-dwg"]],
|
|
["svg", "image/svg+xml"],
|
|
["svr", ["x-world/x-svr", "application/x-world"]],
|
|
["swf", "application/x-shockwave-flash"],
|
|
["swi", "application/vnd.aristanetworks.swi"],
|
|
["sxc", "application/vnd.sun.xml.calc"],
|
|
["sxd", "application/vnd.sun.xml.draw"],
|
|
["sxg", "application/vnd.sun.xml.writer.global"],
|
|
["sxi", "application/vnd.sun.xml.impress"],
|
|
["sxm", "application/vnd.sun.xml.math"],
|
|
["sxw", "application/vnd.sun.xml.writer"],
|
|
["t", ["text/troff", "application/x-troff"]],
|
|
["talk", "text/x-speech"],
|
|
["tao", "application/vnd.tao.intent-module-archive"],
|
|
["tar", "application/x-tar"],
|
|
["tbk", ["application/toolbook", "application/x-tbook"]],
|
|
["tcap", "application/vnd.3gpp2.tcap"],
|
|
["tcl", ["text/x-script.tcl", "application/x-tcl"]],
|
|
["tcsh", "text/x-script.tcsh"],
|
|
["teacher", "application/vnd.smart.teacher"],
|
|
["tei", "application/tei+xml"],
|
|
["tex", "application/x-tex"],
|
|
["texi", "application/x-texinfo"],
|
|
["texinfo", "application/x-texinfo"],
|
|
["text", ["application/plain", "text/plain"]],
|
|
["tfi", "application/thraud+xml"],
|
|
["tfm", "application/x-tex-tfm"],
|
|
["tgz", ["application/gnutar", "application/x-compressed"]],
|
|
["thmx", "application/vnd.ms-officetheme"],
|
|
["tif", ["image/tiff", "image/x-tiff"]],
|
|
["tiff", ["image/tiff", "image/x-tiff"]],
|
|
["tmo", "application/vnd.tmobile-livetv"],
|
|
["torrent", "application/x-bittorrent"],
|
|
["tpl", "application/vnd.groove-tool-template"],
|
|
["tpt", "application/vnd.trid.tpt"],
|
|
["tr", "application/x-troff"],
|
|
["tra", "application/vnd.trueapp"],
|
|
["trm", "application/x-msterminal"],
|
|
["tsd", "application/timestamped-data"],
|
|
["tsi", "audio/tsp-audio"],
|
|
["tsp", ["application/dsptype", "audio/tsplayer"]],
|
|
["tsv", "text/tab-separated-values"],
|
|
["ttf", "application/x-font-ttf"],
|
|
["ttl", "text/turtle"],
|
|
["turbot", "image/florian"],
|
|
["twd", "application/vnd.simtech-mindmapper"],
|
|
["txd", "application/vnd.genomatix.tuxedo"],
|
|
["txf", "application/vnd.mobius.txf"],
|
|
["txt", "text/plain"],
|
|
["ufd", "application/vnd.ufdl"],
|
|
["uil", "text/x-uil"],
|
|
["uls", "text/iuls"],
|
|
["umj", "application/vnd.umajin"],
|
|
["uni", "text/uri-list"],
|
|
["unis", "text/uri-list"],
|
|
["unityweb", "application/vnd.unity"],
|
|
["unv", "application/i-deas"],
|
|
["uoml", "application/vnd.uoml+xml"],
|
|
["uri", "text/uri-list"],
|
|
["uris", "text/uri-list"],
|
|
["ustar", ["application/x-ustar", "multipart/x-ustar"]],
|
|
["utz", "application/vnd.uiq.theme"],
|
|
["uu", ["application/octet-stream", "text/x-uuencode"]],
|
|
["uue", "text/x-uuencode"],
|
|
["uva", "audio/vnd.dece.audio"],
|
|
["uvh", "video/vnd.dece.hd"],
|
|
["uvi", "image/vnd.dece.graphic"],
|
|
["uvm", "video/vnd.dece.mobile"],
|
|
["uvp", "video/vnd.dece.pd"],
|
|
["uvs", "video/vnd.dece.sd"],
|
|
["uvu", "video/vnd.uvvu.mp4"],
|
|
["uvv", "video/vnd.dece.video"],
|
|
["vcd", "application/x-cdlink"],
|
|
["vcf", "text/x-vcard"],
|
|
["vcg", "application/vnd.groove-vcard"],
|
|
["vcs", "text/x-vcalendar"],
|
|
["vcx", "application/vnd.vcx"],
|
|
["vda", "application/vda"],
|
|
["vdo", "video/vdo"],
|
|
["vew", "application/groupwise"],
|
|
["vis", "application/vnd.visionary"],
|
|
["viv", ["video/vivo", "video/vnd.vivo"]],
|
|
["vivo", ["video/vivo", "video/vnd.vivo"]],
|
|
["vmd", "application/vocaltec-media-desc"],
|
|
["vmf", "application/vocaltec-media-file"],
|
|
["voc", ["audio/voc", "audio/x-voc"]],
|
|
["vos", "video/vosaic"],
|
|
["vox", "audio/voxware"],
|
|
["vqe", "audio/x-twinvq-plugin"],
|
|
["vqf", "audio/x-twinvq"],
|
|
["vql", "audio/x-twinvq-plugin"],
|
|
["vrml", ["model/vrml", "x-world/x-vrml", "application/x-vrml"]],
|
|
["vrt", "x-world/x-vrt"],
|
|
["vsd", ["application/vnd.visio", "application/x-visio"]],
|
|
["vsf", "application/vnd.vsf"],
|
|
["vst", "application/x-visio"],
|
|
["vsw", "application/x-visio"],
|
|
["vtu", "model/vnd.vtu"],
|
|
["vxml", "application/voicexml+xml"],
|
|
["w60", "application/wordperfect6.0"],
|
|
["w61", "application/wordperfect6.1"],
|
|
["w6w", "application/msword"],
|
|
["wad", "application/x-doom"],
|
|
["wav", ["audio/wav", "audio/x-wav"]],
|
|
["wax", "audio/x-ms-wax"],
|
|
["wb1", "application/x-qpro"],
|
|
["wbmp", "image/vnd.wap.wbmp"],
|
|
["wbs", "application/vnd.criticaltools.wbs+xml"],
|
|
["wbxml", "application/vnd.wap.wbxml"],
|
|
["wcm", "application/vnd.ms-works"],
|
|
["wdb", "application/vnd.ms-works"],
|
|
["web", "application/vnd.xara"],
|
|
["weba", "audio/webm"],
|
|
["webm", "video/webm"],
|
|
["webp", "image/webp"],
|
|
["wg", "application/vnd.pmi.widget"],
|
|
["wgt", "application/widget"],
|
|
["wiz", "application/msword"],
|
|
["wk1", "application/x-123"],
|
|
["wks", "application/vnd.ms-works"],
|
|
["wm", "video/x-ms-wm"],
|
|
["wma", "audio/x-ms-wma"],
|
|
["wmd", "application/x-ms-wmd"],
|
|
["wmf", ["windows/metafile", "application/x-msmetafile"]],
|
|
["wml", "text/vnd.wap.wml"],
|
|
["wmlc", "application/vnd.wap.wmlc"],
|
|
["wmls", "text/vnd.wap.wmlscript"],
|
|
["wmlsc", "application/vnd.wap.wmlscriptc"],
|
|
["wmv", "video/x-ms-wmv"],
|
|
["wmx", "video/x-ms-wmx"],
|
|
["wmz", "application/x-ms-wmz"],
|
|
["woff", "application/x-font-woff"],
|
|
["word", "application/msword"],
|
|
["wp", "application/wordperfect"],
|
|
["wp5", ["application/wordperfect", "application/wordperfect6.0"]],
|
|
["wp6", "application/wordperfect"],
|
|
["wpd", ["application/wordperfect", "application/vnd.wordperfect", "application/x-wpwin"]],
|
|
["wpl", "application/vnd.ms-wpl"],
|
|
["wps", "application/vnd.ms-works"],
|
|
["wq1", "application/x-lotus"],
|
|
["wqd", "application/vnd.wqd"],
|
|
["wri", ["application/mswrite", "application/x-wri", "application/x-mswrite"]],
|
|
["wrl", ["model/vrml", "x-world/x-vrml", "application/x-world"]],
|
|
["wrz", ["model/vrml", "x-world/x-vrml"]],
|
|
["wsc", "text/scriplet"],
|
|
["wsdl", "application/wsdl+xml"],
|
|
["wspolicy", "application/wspolicy+xml"],
|
|
["wsrc", "application/x-wais-source"],
|
|
["wtb", "application/vnd.webturbo"],
|
|
["wtk", "application/x-wintalk"],
|
|
["wvx", "video/x-ms-wvx"],
|
|
["x-png", "image/png"],
|
|
["x3d", "application/vnd.hzn-3d-crossword"],
|
|
["xaf", "x-world/x-vrml"],
|
|
["xap", "application/x-silverlight-app"],
|
|
["xar", "application/vnd.xara"],
|
|
["xbap", "application/x-ms-xbap"],
|
|
["xbd", "application/vnd.fujixerox.docuworks.binder"],
|
|
["xbm", ["image/xbm", "image/x-xbm", "image/x-xbitmap"]],
|
|
["xdf", "application/xcap-diff+xml"],
|
|
["xdm", "application/vnd.syncml.dm+xml"],
|
|
["xdp", "application/vnd.adobe.xdp+xml"],
|
|
["xdr", "video/x-amt-demorun"],
|
|
["xdssc", "application/dssc+xml"],
|
|
["xdw", "application/vnd.fujixerox.docuworks"],
|
|
["xenc", "application/xenc+xml"],
|
|
["xer", "application/patch-ops-error+xml"],
|
|
["xfdf", "application/vnd.adobe.xfdf"],
|
|
["xfdl", "application/vnd.xfdl"],
|
|
["xgz", "xgl/drawing"],
|
|
["xhtml", "application/xhtml+xml"],
|
|
["xif", "image/vnd.xiff"],
|
|
["xl", "application/excel"],
|
|
["xla", ["application/vnd.ms-excel", "application/excel", "application/x-msexcel", "application/x-excel"]],
|
|
["xlam", "application/vnd.ms-excel.addin.macroenabled.12"],
|
|
["xlb", ["application/excel", "application/vnd.ms-excel", "application/x-excel"]],
|
|
["xlc", ["application/vnd.ms-excel", "application/excel", "application/x-excel"]],
|
|
["xld", ["application/excel", "application/x-excel"]],
|
|
["xlk", ["application/excel", "application/x-excel"]],
|
|
["xll", ["application/excel", "application/vnd.ms-excel", "application/x-excel"]],
|
|
["xlm", ["application/vnd.ms-excel", "application/excel", "application/x-excel"]],
|
|
["xls", ["application/vnd.ms-excel", "application/excel", "application/x-msexcel", "application/x-excel"]],
|
|
["xlsb", "application/vnd.ms-excel.sheet.binary.macroenabled.12"],
|
|
["xlsm", "application/vnd.ms-excel.sheet.macroenabled.12"],
|
|
["xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
|
|
["xlt", ["application/vnd.ms-excel", "application/excel", "application/x-excel"]],
|
|
["xltm", "application/vnd.ms-excel.template.macroenabled.12"],
|
|
["xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"],
|
|
["xlv", ["application/excel", "application/x-excel"]],
|
|
["xlw", ["application/vnd.ms-excel", "application/excel", "application/x-msexcel", "application/x-excel"]],
|
|
["xm", "audio/xm"],
|
|
["xml", ["application/xml", "text/xml", "application/atom+xml", "application/rss+xml"]],
|
|
["xmz", "xgl/movie"],
|
|
["xo", "application/vnd.olpc-sugar"],
|
|
["xof", "x-world/x-vrml"],
|
|
["xop", "application/xop+xml"],
|
|
["xpi", "application/x-xpinstall"],
|
|
["xpix", "application/x-vnd.ls-xpix"],
|
|
["xpm", ["image/xpm", "image/x-xpixmap"]],
|
|
["xpr", "application/vnd.is-xpr"],
|
|
["xps", "application/vnd.ms-xpsdocument"],
|
|
["xpw", "application/vnd.intercon.formnet"],
|
|
["xslt", "application/xslt+xml"],
|
|
["xsm", "application/vnd.syncml+xml"],
|
|
["xspf", "application/xspf+xml"],
|
|
["xsr", "video/x-amt-showrun"],
|
|
["xul", "application/vnd.mozilla.xul+xml"],
|
|
["xwd", ["image/x-xwd", "image/x-xwindowdump"]],
|
|
["xyz", ["chemical/x-xyz", "chemical/x-pdb"]],
|
|
["yang", "application/yang"],
|
|
["yin", "application/yin+xml"],
|
|
["z", ["application/x-compressed", "application/x-compress"]],
|
|
["zaz", "application/vnd.zzazz.deck+xml"],
|
|
["zip", ["application/zip", "multipart/x-zip", "application/x-zip-compressed", "application/x-compressed"]],
|
|
["zir", "application/vnd.zul"],
|
|
["zmm", "application/vnd.handheld-entertainment+xml"],
|
|
["zoo", "application/octet-stream"],
|
|
["zsh", "text/x-script.zsh"]
|
|
]);
|
|
module.exports = {
|
|
detectMimeType(filename) {
|
|
if (!filename) {
|
|
return defaultMimeType;
|
|
}
|
|
let parsed = path11.parse(filename);
|
|
let extension = (parsed.ext.substr(1) || parsed.name || "").split("?").shift().trim().toLowerCase();
|
|
let value = defaultMimeType;
|
|
if (extensions.has(extension)) {
|
|
value = extensions.get(extension);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value[0];
|
|
}
|
|
return value;
|
|
},
|
|
detectExtension(mimeType) {
|
|
if (!mimeType) {
|
|
return defaultExtension;
|
|
}
|
|
let parts = (mimeType || "").toLowerCase().trim().split("/");
|
|
let rootType = parts.shift().trim();
|
|
let subType = parts.join("/").trim();
|
|
if (mimeTypes.has(rootType + "/" + subType)) {
|
|
let value = mimeTypes.get(rootType + "/" + subType);
|
|
if (Array.isArray(value)) {
|
|
return value[0];
|
|
}
|
|
return value;
|
|
}
|
|
switch (rootType) {
|
|
case "text":
|
|
return "txt";
|
|
default:
|
|
return "bin";
|
|
}
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/punycode/index.js
|
|
var require_punycode = __commonJS((exports, module) => {
|
|
var maxInt = 2147483647;
|
|
var base = 36;
|
|
var tMin = 1;
|
|
var tMax = 26;
|
|
var skew = 38;
|
|
var damp = 700;
|
|
var initialBias = 72;
|
|
var initialN = 128;
|
|
var delimiter = "-";
|
|
var regexPunycode = /^xn--/;
|
|
var regexNonASCII = /[^\0-\x7F]/;
|
|
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
|
|
var errors = {
|
|
overflow: "Overflow: input needs wider integers to process",
|
|
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
|
|
"invalid-input": "Invalid input"
|
|
};
|
|
var baseMinusTMin = base - tMin;
|
|
var floor = Math.floor;
|
|
var stringFromCharCode = String.fromCharCode;
|
|
function error(type) {
|
|
throw new RangeError(errors[type]);
|
|
}
|
|
function map(array, callback) {
|
|
const result = [];
|
|
let length = array.length;
|
|
while (length--) {
|
|
result[length] = callback(array[length]);
|
|
}
|
|
return result;
|
|
}
|
|
function mapDomain(domain, callback) {
|
|
const parts = domain.split("@");
|
|
let result = "";
|
|
if (parts.length > 1) {
|
|
result = parts[0] + "@";
|
|
domain = parts[1];
|
|
}
|
|
domain = domain.replace(regexSeparators, ".");
|
|
const labels = domain.split(".");
|
|
const encoded = map(labels, callback).join(".");
|
|
return result + encoded;
|
|
}
|
|
function ucs2decode(string) {
|
|
const output = [];
|
|
let counter = 0;
|
|
const length = string.length;
|
|
while (counter < length) {
|
|
const value = string.charCodeAt(counter++);
|
|
if (value >= 55296 && value <= 56319 && counter < length) {
|
|
const extra = string.charCodeAt(counter++);
|
|
if ((extra & 64512) == 56320) {
|
|
output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
|
|
} else {
|
|
output.push(value);
|
|
counter--;
|
|
}
|
|
} else {
|
|
output.push(value);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
|
|
var basicToDigit = function(codePoint) {
|
|
if (codePoint >= 48 && codePoint < 58) {
|
|
return 26 + (codePoint - 48);
|
|
}
|
|
if (codePoint >= 65 && codePoint < 91) {
|
|
return codePoint - 65;
|
|
}
|
|
if (codePoint >= 97 && codePoint < 123) {
|
|
return codePoint - 97;
|
|
}
|
|
return base;
|
|
};
|
|
var digitToBasic = function(digit, flag) {
|
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
};
|
|
var adapt = function(delta, numPoints, firstTime) {
|
|
let k = 0;
|
|
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
delta += floor(delta / numPoints);
|
|
for (;delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
delta = floor(delta / baseMinusTMin);
|
|
}
|
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
};
|
|
var decode = function(input) {
|
|
const output = [];
|
|
const inputLength = input.length;
|
|
let i = 0;
|
|
let n = initialN;
|
|
let bias = initialBias;
|
|
let basic = input.lastIndexOf(delimiter);
|
|
if (basic < 0) {
|
|
basic = 0;
|
|
}
|
|
for (let j = 0;j < basic; ++j) {
|
|
if (input.charCodeAt(j) >= 128) {
|
|
error("not-basic");
|
|
}
|
|
output.push(input.charCodeAt(j));
|
|
}
|
|
for (let index = basic > 0 ? basic + 1 : 0;index < inputLength; ) {
|
|
const oldi = i;
|
|
for (let w = 1, k = base;; k += base) {
|
|
if (index >= inputLength) {
|
|
error("invalid-input");
|
|
}
|
|
const digit = basicToDigit(input.charCodeAt(index++));
|
|
if (digit >= base) {
|
|
error("invalid-input");
|
|
}
|
|
if (digit > floor((maxInt - i) / w)) {
|
|
error("overflow");
|
|
}
|
|
i += digit * w;
|
|
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
if (digit < t) {
|
|
break;
|
|
}
|
|
const baseMinusT = base - t;
|
|
if (w > floor(maxInt / baseMinusT)) {
|
|
error("overflow");
|
|
}
|
|
w *= baseMinusT;
|
|
}
|
|
const out = output.length + 1;
|
|
bias = adapt(i - oldi, out, oldi == 0);
|
|
if (floor(i / out) > maxInt - n) {
|
|
error("overflow");
|
|
}
|
|
n += floor(i / out);
|
|
i %= out;
|
|
output.splice(i++, 0, n);
|
|
}
|
|
return String.fromCodePoint(...output);
|
|
};
|
|
var encode = function(input) {
|
|
const output = [];
|
|
input = ucs2decode(input);
|
|
const inputLength = input.length;
|
|
let n = initialN;
|
|
let delta = 0;
|
|
let bias = initialBias;
|
|
for (const currentValue of input) {
|
|
if (currentValue < 128) {
|
|
output.push(stringFromCharCode(currentValue));
|
|
}
|
|
}
|
|
const basicLength = output.length;
|
|
let handledCPCount = basicLength;
|
|
if (basicLength) {
|
|
output.push(delimiter);
|
|
}
|
|
while (handledCPCount < inputLength) {
|
|
let m = maxInt;
|
|
for (const currentValue of input) {
|
|
if (currentValue >= n && currentValue < m) {
|
|
m = currentValue;
|
|
}
|
|
}
|
|
const handledCPCountPlusOne = handledCPCount + 1;
|
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
error("overflow");
|
|
}
|
|
delta += (m - n) * handledCPCountPlusOne;
|
|
n = m;
|
|
for (const currentValue of input) {
|
|
if (currentValue < n && ++delta > maxInt) {
|
|
error("overflow");
|
|
}
|
|
if (currentValue === n) {
|
|
let q = delta;
|
|
for (let k = base;; k += base) {
|
|
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
|
if (q < t) {
|
|
break;
|
|
}
|
|
const qMinusT = q - t;
|
|
const baseMinusT = base - t;
|
|
output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
|
|
q = floor(qMinusT / baseMinusT);
|
|
}
|
|
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
|
|
delta = 0;
|
|
++handledCPCount;
|
|
}
|
|
}
|
|
++delta;
|
|
++n;
|
|
}
|
|
return output.join("");
|
|
};
|
|
var toUnicode = function(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
|
|
});
|
|
};
|
|
var toASCII = function(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
|
|
});
|
|
};
|
|
var punycode = {
|
|
version: "2.3.1",
|
|
ucs2: {
|
|
decode: ucs2decode,
|
|
encode: ucs2encode
|
|
},
|
|
decode,
|
|
encode,
|
|
toASCII,
|
|
toUnicode
|
|
};
|
|
module.exports = punycode;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/base64/index.js
|
|
var require_base642 = __commonJS((exports, module) => {
|
|
var Transform = __require("stream").Transform;
|
|
function encode(buffer) {
|
|
if (typeof buffer === "string") {
|
|
buffer = Buffer.from(buffer, "utf-8");
|
|
}
|
|
return buffer.toString("base64");
|
|
}
|
|
function wrap(str, lineLength) {
|
|
str = (str || "").toString();
|
|
lineLength = lineLength || 76;
|
|
if (str.length <= lineLength) {
|
|
return str;
|
|
}
|
|
let result = [];
|
|
let pos = 0;
|
|
let chunkLength = lineLength * 1024;
|
|
while (pos < str.length) {
|
|
let wrappedLines = str.substr(pos, chunkLength).replace(new RegExp(".{" + lineLength + "}", "g"), "$&\r\n").trim();
|
|
result.push(wrappedLines);
|
|
pos += chunkLength;
|
|
}
|
|
return result.join("\r\n").trim();
|
|
}
|
|
|
|
class Encoder extends Transform {
|
|
constructor(options) {
|
|
super();
|
|
this.options = options || {};
|
|
if (this.options.lineLength !== false) {
|
|
this.options.lineLength = this.options.lineLength || 76;
|
|
}
|
|
this._curLine = "";
|
|
this._remainingBytes = false;
|
|
this.inputBytes = 0;
|
|
this.outputBytes = 0;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
if (encoding !== "buffer") {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
}
|
|
if (!chunk || !chunk.length) {
|
|
return setImmediate(done);
|
|
}
|
|
this.inputBytes += chunk.length;
|
|
if (this._remainingBytes && this._remainingBytes.length) {
|
|
chunk = Buffer.concat([this._remainingBytes, chunk], this._remainingBytes.length + chunk.length);
|
|
this._remainingBytes = false;
|
|
}
|
|
if (chunk.length % 3) {
|
|
this._remainingBytes = chunk.slice(chunk.length - chunk.length % 3);
|
|
chunk = chunk.slice(0, chunk.length - chunk.length % 3);
|
|
} else {
|
|
this._remainingBytes = false;
|
|
}
|
|
let b64 = this._curLine + encode(chunk);
|
|
if (this.options.lineLength) {
|
|
b64 = wrap(b64, this.options.lineLength);
|
|
let lastLF = b64.lastIndexOf("\n");
|
|
if (lastLF < 0) {
|
|
this._curLine = b64;
|
|
b64 = "";
|
|
} else if (lastLF === b64.length - 1) {
|
|
this._curLine = "";
|
|
} else {
|
|
this._curLine = b64.substr(lastLF + 1);
|
|
b64 = b64.substr(0, lastLF + 1);
|
|
}
|
|
}
|
|
if (b64) {
|
|
this.outputBytes += b64.length;
|
|
this.push(Buffer.from(b64, "ascii"));
|
|
}
|
|
setImmediate(done);
|
|
}
|
|
_flush(done) {
|
|
if (this._remainingBytes && this._remainingBytes.length) {
|
|
this._curLine += encode(this._remainingBytes);
|
|
}
|
|
if (this._curLine) {
|
|
this._curLine = wrap(this._curLine, this.options.lineLength);
|
|
this.outputBytes += this._curLine.length;
|
|
this.push(this._curLine, "ascii");
|
|
this._curLine = "";
|
|
}
|
|
done();
|
|
}
|
|
}
|
|
module.exports = {
|
|
encode,
|
|
wrap,
|
|
Encoder
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/qp/index.js
|
|
var require_qp = __commonJS((exports, module) => {
|
|
var Transform = __require("stream").Transform;
|
|
function encode(buffer) {
|
|
if (typeof buffer === "string") {
|
|
buffer = Buffer.from(buffer, "utf-8");
|
|
}
|
|
let ranges = [
|
|
[9],
|
|
[10],
|
|
[13],
|
|
[32, 60],
|
|
[62, 126]
|
|
];
|
|
let result = "";
|
|
let ord;
|
|
for (let i = 0, len = buffer.length;i < len; i++) {
|
|
ord = buffer[i];
|
|
if (checkRanges(ord, ranges) && !((ord === 32 || ord === 9) && (i === len - 1 || buffer[i + 1] === 10 || buffer[i + 1] === 13))) {
|
|
result += String.fromCharCode(ord);
|
|
continue;
|
|
}
|
|
result += "=" + (ord < 16 ? "0" : "") + ord.toString(16).toUpperCase();
|
|
}
|
|
return result;
|
|
}
|
|
function wrap(str, lineLength) {
|
|
str = (str || "").toString();
|
|
lineLength = lineLength || 76;
|
|
if (str.length <= lineLength) {
|
|
return str;
|
|
}
|
|
let pos = 0;
|
|
let len = str.length;
|
|
let match, code, line;
|
|
let lineMargin = Math.floor(lineLength / 3);
|
|
let result = "";
|
|
while (pos < len) {
|
|
line = str.substr(pos, lineLength);
|
|
if (match = line.match(/\r\n/)) {
|
|
line = line.substr(0, match.index + match[0].length);
|
|
result += line;
|
|
pos += line.length;
|
|
continue;
|
|
}
|
|
if (line.substr(-1) === "\n") {
|
|
result += line;
|
|
pos += line.length;
|
|
continue;
|
|
} else if (match = line.substr(-lineMargin).match(/\n.*?$/)) {
|
|
line = line.substr(0, line.length - (match[0].length - 1));
|
|
result += line;
|
|
pos += line.length;
|
|
continue;
|
|
} else if (line.length > lineLength - lineMargin && (match = line.substr(-lineMargin).match(/[ \t.,!?][^ \t.,!?]*$/))) {
|
|
line = line.substr(0, line.length - (match[0].length - 1));
|
|
} else if (line.match(/[=][\da-f]{0,2}$/i)) {
|
|
if (match = line.match(/[=][\da-f]{0,1}$/i)) {
|
|
line = line.substr(0, line.length - match[0].length);
|
|
}
|
|
while (line.length > 3 && line.length < len - pos && !line.match(/^(?:=[\da-f]{2}){1,4}$/i) && (match = line.match(/[=][\da-f]{2}$/gi))) {
|
|
code = parseInt(match[0].substr(1, 2), 16);
|
|
if (code < 128) {
|
|
break;
|
|
}
|
|
line = line.substr(0, line.length - 3);
|
|
if (code >= 192) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (pos + line.length < len && line.substr(-1) !== "\n") {
|
|
if (line.length === lineLength && line.match(/[=][\da-f]{2}$/i)) {
|
|
line = line.substr(0, line.length - 3);
|
|
} else if (line.length === lineLength) {
|
|
line = line.substr(0, line.length - 1);
|
|
}
|
|
pos += line.length;
|
|
line += "=\r\n";
|
|
} else {
|
|
pos += line.length;
|
|
}
|
|
result += line;
|
|
}
|
|
return result;
|
|
}
|
|
function checkRanges(nr, ranges) {
|
|
for (let i = ranges.length - 1;i >= 0; i--) {
|
|
if (!ranges[i].length) {
|
|
continue;
|
|
}
|
|
if (ranges[i].length === 1 && nr === ranges[i][0]) {
|
|
return true;
|
|
}
|
|
if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class Encoder extends Transform {
|
|
constructor(options) {
|
|
super();
|
|
this.options = options || {};
|
|
if (this.options.lineLength !== false) {
|
|
this.options.lineLength = this.options.lineLength || 76;
|
|
}
|
|
this._curLine = "";
|
|
this.inputBytes = 0;
|
|
this.outputBytes = 0;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
let qp;
|
|
if (encoding !== "buffer") {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
}
|
|
if (!chunk || !chunk.length) {
|
|
return done();
|
|
}
|
|
this.inputBytes += chunk.length;
|
|
if (this.options.lineLength) {
|
|
qp = this._curLine + encode(chunk);
|
|
qp = wrap(qp, this.options.lineLength);
|
|
qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
|
|
this._curLine = lastLine;
|
|
return lineBreak;
|
|
});
|
|
if (qp) {
|
|
this.outputBytes += qp.length;
|
|
this.push(qp);
|
|
}
|
|
} else {
|
|
qp = encode(chunk);
|
|
this.outputBytes += qp.length;
|
|
this.push(qp, "ascii");
|
|
}
|
|
done();
|
|
}
|
|
_flush(done) {
|
|
if (this._curLine) {
|
|
this.outputBytes += this._curLine.length;
|
|
this.push(this._curLine, "ascii");
|
|
}
|
|
done();
|
|
}
|
|
}
|
|
module.exports = {
|
|
encode,
|
|
wrap,
|
|
Encoder
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-funcs/index.js
|
|
var require_mime_funcs = __commonJS((exports, module) => {
|
|
var base64 = require_base642();
|
|
var qp = require_qp();
|
|
var mimeTypes = require_mime_types();
|
|
module.exports = {
|
|
isPlainText(value, isParam) {
|
|
const re = isParam ? /[\x00-\x08\x0b\x0c\x0e-\x1f"\u0080-\uFFFF]/ : /[\x00-\x08\x0b\x0c\x0e-\x1f\u0080-\uFFFF]/;
|
|
if (typeof value !== "string" || re.test(value)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
},
|
|
hasLongerLines(str, lineLength) {
|
|
if (str.length > 128 * 1024) {
|
|
return true;
|
|
}
|
|
return new RegExp("^.{" + (lineLength + 1) + ",}", "m").test(str);
|
|
},
|
|
encodeWord(data, mimeWordEncoding, maxLength) {
|
|
mimeWordEncoding = (mimeWordEncoding || "Q").toString().toUpperCase().trim().charAt(0);
|
|
maxLength = maxLength || 0;
|
|
let encodedStr;
|
|
let toCharset = "UTF-8";
|
|
if (maxLength && maxLength > 7 + toCharset.length) {
|
|
maxLength -= 7 + toCharset.length;
|
|
}
|
|
if (mimeWordEncoding === "Q") {
|
|
encodedStr = qp.encode(data).replace(/[^a-z0-9!*+\-/=]/gi, (chr) => {
|
|
let ord = chr.charCodeAt(0).toString(16).toUpperCase();
|
|
if (chr === " ") {
|
|
return "_";
|
|
} else {
|
|
return "=" + (ord.length === 1 ? "0" + ord : ord);
|
|
}
|
|
});
|
|
} else if (mimeWordEncoding === "B") {
|
|
encodedStr = typeof data === "string" ? data : base64.encode(data);
|
|
maxLength = maxLength ? Math.max(3, (maxLength - maxLength % 4) / 4 * 3) : 0;
|
|
}
|
|
if (maxLength && (mimeWordEncoding !== "B" ? encodedStr : base64.encode(data)).length > maxLength) {
|
|
if (mimeWordEncoding === "Q") {
|
|
encodedStr = this.splitMimeEncodedString(encodedStr, maxLength).join("?= =?" + toCharset + "?" + mimeWordEncoding + "?");
|
|
} else {
|
|
let parts = [];
|
|
let lpart = "";
|
|
for (let i = 0, len = encodedStr.length;i < len; i++) {
|
|
let chr = encodedStr.charAt(i);
|
|
if (/[\ud83c\ud83d\ud83e]/.test(chr) && i < len - 1) {
|
|
chr += encodedStr.charAt(++i);
|
|
}
|
|
if (Buffer.byteLength(lpart + chr) <= maxLength || i === 0) {
|
|
lpart += chr;
|
|
} else {
|
|
parts.push(base64.encode(lpart));
|
|
lpart = chr;
|
|
}
|
|
}
|
|
if (lpart) {
|
|
parts.push(base64.encode(lpart));
|
|
}
|
|
if (parts.length > 1) {
|
|
encodedStr = parts.join("?= =?" + toCharset + "?" + mimeWordEncoding + "?");
|
|
} else {
|
|
encodedStr = parts.join("");
|
|
}
|
|
}
|
|
} else if (mimeWordEncoding === "B") {
|
|
encodedStr = base64.encode(data);
|
|
}
|
|
return "=?" + toCharset + "?" + mimeWordEncoding + "?" + encodedStr + (encodedStr.substr(-2) === "?=" ? "" : "?=");
|
|
},
|
|
encodeWords(value, mimeWordEncoding, maxLength, encodeAll) {
|
|
maxLength = maxLength || 0;
|
|
let encodedValue;
|
|
let firstMatch = value.match(/(?:^|\s)([^\s]*["\u0080-\uFFFF])/);
|
|
if (!firstMatch) {
|
|
return value;
|
|
}
|
|
if (encodeAll) {
|
|
return this.encodeWord(value, mimeWordEncoding, maxLength);
|
|
}
|
|
let lastMatch = value.match(/(["\u0080-\uFFFF][^\s]*)[^"\u0080-\uFFFF]*$/);
|
|
if (!lastMatch) {
|
|
return value;
|
|
}
|
|
let startIndex = firstMatch.index + (firstMatch[0].match(/[^\s]/) || {
|
|
index: 0
|
|
}).index;
|
|
let endIndex = lastMatch.index + (lastMatch[1] || "").length;
|
|
encodedValue = (startIndex ? value.substr(0, startIndex) : "") + this.encodeWord(value.substring(startIndex, endIndex), mimeWordEncoding || "Q", maxLength) + (endIndex < value.length ? value.substr(endIndex) : "");
|
|
return encodedValue;
|
|
},
|
|
buildHeaderValue(structured) {
|
|
let paramsArray = [];
|
|
Object.keys(structured.params || {}).forEach((param) => {
|
|
let value = structured.params[param];
|
|
if (!this.isPlainText(value, true) || value.length >= 75) {
|
|
this.buildHeaderParam(param, value, 50).forEach((encodedParam) => {
|
|
if (!/[\s"\\;:/=(),<>@[\]?]|^[-']|'$/.test(encodedParam.value) || encodedParam.key.substr(-1) === "*") {
|
|
paramsArray.push(encodedParam.key + "=" + encodedParam.value);
|
|
} else {
|
|
paramsArray.push(encodedParam.key + "=" + JSON.stringify(encodedParam.value));
|
|
}
|
|
});
|
|
} else if (/[\s'"\\;:/=(),<>@[\]?]|^-/.test(value)) {
|
|
paramsArray.push(param + "=" + JSON.stringify(value));
|
|
} else {
|
|
paramsArray.push(param + "=" + value);
|
|
}
|
|
});
|
|
return structured.value + (paramsArray.length ? "; " + paramsArray.join("; ") : "");
|
|
},
|
|
buildHeaderParam(key, data, maxLength) {
|
|
let list = [];
|
|
let encodedStr = typeof data === "string" ? data : (data || "").toString();
|
|
let encodedStrArr;
|
|
let chr, ord;
|
|
let line;
|
|
let startPos = 0;
|
|
let i, len;
|
|
maxLength = maxLength || 50;
|
|
if (this.isPlainText(data, true)) {
|
|
if (encodedStr.length <= maxLength) {
|
|
return [
|
|
{
|
|
key,
|
|
value: encodedStr
|
|
}
|
|
];
|
|
}
|
|
encodedStr = encodedStr.replace(new RegExp(".{" + maxLength + "}", "g"), (str) => {
|
|
list.push({
|
|
line: str
|
|
});
|
|
return "";
|
|
});
|
|
if (encodedStr) {
|
|
list.push({
|
|
line: encodedStr
|
|
});
|
|
}
|
|
} else {
|
|
if (/[\uD800-\uDBFF]/.test(encodedStr)) {
|
|
encodedStrArr = [];
|
|
for (i = 0, len = encodedStr.length;i < len; i++) {
|
|
chr = encodedStr.charAt(i);
|
|
ord = chr.charCodeAt(0);
|
|
if (ord >= 55296 && ord <= 56319 && i < len - 1) {
|
|
chr += encodedStr.charAt(i + 1);
|
|
encodedStrArr.push(chr);
|
|
i++;
|
|
} else {
|
|
encodedStrArr.push(chr);
|
|
}
|
|
}
|
|
encodedStr = encodedStrArr;
|
|
}
|
|
line = "utf-8''";
|
|
let encoded = true;
|
|
startPos = 0;
|
|
for (i = 0, len = encodedStr.length;i < len; i++) {
|
|
chr = encodedStr[i];
|
|
if (encoded) {
|
|
chr = this.safeEncodeURIComponent(chr);
|
|
} else {
|
|
chr = chr === " " ? chr : this.safeEncodeURIComponent(chr);
|
|
if (chr !== encodedStr[i]) {
|
|
if ((this.safeEncodeURIComponent(line) + chr).length >= maxLength) {
|
|
list.push({
|
|
line,
|
|
encoded
|
|
});
|
|
line = "";
|
|
startPos = i - 1;
|
|
} else {
|
|
encoded = true;
|
|
i = startPos;
|
|
line = "";
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if ((line + chr).length >= maxLength) {
|
|
list.push({
|
|
line,
|
|
encoded
|
|
});
|
|
line = chr = encodedStr[i] === " " ? " " : this.safeEncodeURIComponent(encodedStr[i]);
|
|
if (chr === encodedStr[i]) {
|
|
encoded = false;
|
|
startPos = i - 1;
|
|
} else {
|
|
encoded = true;
|
|
}
|
|
} else {
|
|
line += chr;
|
|
}
|
|
}
|
|
if (line) {
|
|
list.push({
|
|
line,
|
|
encoded
|
|
});
|
|
}
|
|
}
|
|
return list.map((item, i2) => ({
|
|
key: key + "*" + i2 + (item.encoded ? "*" : ""),
|
|
value: item.line
|
|
}));
|
|
},
|
|
parseHeaderValue(str) {
|
|
let response = {
|
|
value: false,
|
|
params: {}
|
|
};
|
|
let key = false;
|
|
let value = "";
|
|
let type = "value";
|
|
let quote = false;
|
|
let escaped = false;
|
|
let chr;
|
|
for (let i = 0, len = str.length;i < len; i++) {
|
|
chr = str.charAt(i);
|
|
if (type === "key") {
|
|
if (chr === "=") {
|
|
key = value.trim().toLowerCase();
|
|
type = "value";
|
|
value = "";
|
|
continue;
|
|
}
|
|
value += chr;
|
|
} else {
|
|
if (escaped) {
|
|
value += chr;
|
|
} else if (chr === "\\") {
|
|
escaped = true;
|
|
continue;
|
|
} else if (quote && chr === quote) {
|
|
quote = false;
|
|
} else if (!quote && chr === '"') {
|
|
quote = chr;
|
|
} else if (!quote && chr === ";") {
|
|
if (key === false) {
|
|
response.value = value.trim();
|
|
} else {
|
|
response.params[key] = value.trim();
|
|
}
|
|
type = "key";
|
|
value = "";
|
|
} else {
|
|
value += chr;
|
|
}
|
|
escaped = false;
|
|
}
|
|
}
|
|
if (type === "value") {
|
|
if (key === false) {
|
|
response.value = value.trim();
|
|
} else {
|
|
response.params[key] = value.trim();
|
|
}
|
|
} else if (value.trim()) {
|
|
response.params[value.trim().toLowerCase()] = "";
|
|
}
|
|
Object.keys(response.params).forEach((key2) => {
|
|
let actualKey, nr, match, value2;
|
|
if (match = key2.match(/(\*(\d+)|\*(\d+)\*|\*)$/)) {
|
|
actualKey = key2.substr(0, match.index);
|
|
nr = Number(match[2] || match[3]) || 0;
|
|
if (!response.params[actualKey] || typeof response.params[actualKey] !== "object") {
|
|
response.params[actualKey] = {
|
|
charset: false,
|
|
values: []
|
|
};
|
|
}
|
|
value2 = response.params[key2];
|
|
if (nr === 0 && match[0].substr(-1) === "*" && (match = value2.match(/^([^']*)'[^']*'(.*)$/))) {
|
|
response.params[actualKey].charset = match[1] || "iso-8859-1";
|
|
value2 = match[2];
|
|
}
|
|
response.params[actualKey].values[nr] = value2;
|
|
delete response.params[key2];
|
|
}
|
|
});
|
|
Object.keys(response.params).forEach((key2) => {
|
|
let value2;
|
|
if (response.params[key2] && Array.isArray(response.params[key2].values)) {
|
|
value2 = response.params[key2].values.map((val) => val || "").join("");
|
|
if (response.params[key2].charset) {
|
|
response.params[key2] = "=?" + response.params[key2].charset + "?Q?" + value2.replace(/[=?_\s]/g, (s) => {
|
|
let c = s.charCodeAt(0).toString(16);
|
|
if (s === " ") {
|
|
return "_";
|
|
} else {
|
|
return "%" + (c.length < 2 ? "0" : "") + c;
|
|
}
|
|
}).replace(/%/g, "=") + "?=";
|
|
} else {
|
|
response.params[key2] = value2;
|
|
}
|
|
}
|
|
});
|
|
return response;
|
|
},
|
|
detectExtension: (mimeType) => mimeTypes.detectExtension(mimeType),
|
|
detectMimeType: (extension) => mimeTypes.detectMimeType(extension),
|
|
foldLines(str, lineLength, afterSpace) {
|
|
str = (str || "").toString();
|
|
lineLength = lineLength || 76;
|
|
let pos = 0, len = str.length, result = "", line, match;
|
|
while (pos < len) {
|
|
line = str.substr(pos, lineLength);
|
|
if (line.length < lineLength) {
|
|
result += line;
|
|
break;
|
|
}
|
|
if (match = line.match(/^[^\n\r]*(\r?\n|\r)/)) {
|
|
line = match[0];
|
|
result += line;
|
|
pos += line.length;
|
|
continue;
|
|
} else if ((match = line.match(/(\s+)[^\s]*$/)) && match[0].length - (afterSpace ? (match[1] || "").length : 0) < line.length) {
|
|
line = line.substr(0, line.length - (match[0].length - (afterSpace ? (match[1] || "").length : 0)));
|
|
} else if (match = str.substr(pos + line.length).match(/^[^\s]+(\s*)/)) {
|
|
line = line + match[0].substr(0, match[0].length - (!afterSpace ? (match[1] || "").length : 0));
|
|
}
|
|
result += line;
|
|
pos += line.length;
|
|
if (pos < len) {
|
|
result += "\r\n";
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
splitMimeEncodedString: (str, maxlen) => {
|
|
let curLine, match, chr, done, lines = [];
|
|
maxlen = Math.max(maxlen || 0, 12);
|
|
while (str.length) {
|
|
curLine = str.substr(0, maxlen);
|
|
if (match = curLine.match(/[=][0-9A-F]?$/i)) {
|
|
curLine = curLine.substr(0, match.index);
|
|
}
|
|
done = false;
|
|
while (!done) {
|
|
done = true;
|
|
if (match = str.substr(curLine.length).match(/^[=]([0-9A-F]{2})/i)) {
|
|
chr = parseInt(match[1], 16);
|
|
if (chr < 194 && chr > 127) {
|
|
curLine = curLine.substr(0, curLine.length - 3);
|
|
done = false;
|
|
}
|
|
}
|
|
}
|
|
if (curLine.length) {
|
|
lines.push(curLine);
|
|
}
|
|
str = str.substr(curLine.length);
|
|
}
|
|
return lines;
|
|
},
|
|
encodeURICharComponent: (chr) => {
|
|
let res = "";
|
|
let ord = chr.charCodeAt(0).toString(16).toUpperCase();
|
|
if (ord.length % 2) {
|
|
ord = "0" + ord;
|
|
}
|
|
if (ord.length > 2) {
|
|
for (let i = 0, len = ord.length / 2;i < len; i++) {
|
|
res += "%" + ord.substr(i, 2);
|
|
}
|
|
} else {
|
|
res += "%" + ord;
|
|
}
|
|
return res;
|
|
},
|
|
safeEncodeURIComponent(str) {
|
|
str = (str || "").toString();
|
|
try {
|
|
str = encodeURIComponent(str);
|
|
} catch (E) {
|
|
return str.replace(/[^\x00-\x1F *'()<>@,;:\\"[\]?=\u007F-\uFFFF]+/g, "");
|
|
}
|
|
return str.replace(/[\x00-\x1F *'()<>@,;:\\"[\]?=\u007F-\uFFFF]/g, (chr) => this.encodeURICharComponent(chr));
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/addressparser/index.js
|
|
var require_addressparser = __commonJS((exports, module) => {
|
|
function _handleAddress(tokens) {
|
|
let token;
|
|
let isGroup = false;
|
|
let state = "text";
|
|
let address;
|
|
let addresses = [];
|
|
let data = {
|
|
address: [],
|
|
comment: [],
|
|
group: [],
|
|
text: []
|
|
};
|
|
let i;
|
|
let len;
|
|
for (i = 0, len = tokens.length;i < len; i++) {
|
|
token = tokens[i];
|
|
if (token.type === "operator") {
|
|
switch (token.value) {
|
|
case "<":
|
|
state = "address";
|
|
break;
|
|
case "(":
|
|
state = "comment";
|
|
break;
|
|
case ":":
|
|
state = "group";
|
|
isGroup = true;
|
|
break;
|
|
default:
|
|
state = "text";
|
|
}
|
|
} else if (token.value) {
|
|
if (state === "address") {
|
|
token.value = token.value.replace(/^[^<]*<\s*/, "");
|
|
}
|
|
data[state].push(token.value);
|
|
}
|
|
}
|
|
if (!data.text.length && data.comment.length) {
|
|
data.text = data.comment;
|
|
data.comment = [];
|
|
}
|
|
if (isGroup) {
|
|
data.text = data.text.join(" ");
|
|
addresses.push({
|
|
name: data.text || address && address.name,
|
|
group: data.group.length ? addressparser(data.group.join(",")) : []
|
|
});
|
|
} else {
|
|
if (!data.address.length && data.text.length) {
|
|
for (i = data.text.length - 1;i >= 0; i--) {
|
|
if (data.text[i].match(/^[^@\s]+@[^@\s]+$/)) {
|
|
data.address = data.text.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
let _regexHandler = function(address2) {
|
|
if (!data.address.length) {
|
|
data.address = [address2.trim()];
|
|
return " ";
|
|
} else {
|
|
return address2;
|
|
}
|
|
};
|
|
if (!data.address.length) {
|
|
for (i = data.text.length - 1;i >= 0; i--) {
|
|
data.text[i] = data.text[i].replace(/\s*\b[^@\s]+@[^\s]+\b\s*/, _regexHandler).trim();
|
|
if (data.address.length) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!data.text.length && data.comment.length) {
|
|
data.text = data.comment;
|
|
data.comment = [];
|
|
}
|
|
if (data.address.length > 1) {
|
|
data.text = data.text.concat(data.address.splice(1));
|
|
}
|
|
data.text = data.text.join(" ");
|
|
data.address = data.address.join(" ");
|
|
if (!data.address && isGroup) {
|
|
return [];
|
|
} else {
|
|
address = {
|
|
address: data.address || data.text || "",
|
|
name: data.text || data.address || ""
|
|
};
|
|
if (address.address === address.name) {
|
|
if ((address.address || "").match(/@/)) {
|
|
address.name = "";
|
|
} else {
|
|
address.address = "";
|
|
}
|
|
}
|
|
addresses.push(address);
|
|
}
|
|
}
|
|
return addresses;
|
|
}
|
|
|
|
class Tokenizer {
|
|
constructor(str) {
|
|
this.str = (str || "").toString();
|
|
this.operatorCurrent = "";
|
|
this.operatorExpecting = "";
|
|
this.node = null;
|
|
this.escaped = false;
|
|
this.list = [];
|
|
this.operators = {
|
|
'"': '"',
|
|
"(": ")",
|
|
"<": ">",
|
|
",": "",
|
|
":": ";",
|
|
";": ""
|
|
};
|
|
}
|
|
tokenize() {
|
|
let chr, list = [];
|
|
for (let i = 0, len = this.str.length;i < len; i++) {
|
|
chr = this.str.charAt(i);
|
|
this.checkChar(chr);
|
|
}
|
|
this.list.forEach((node) => {
|
|
node.value = (node.value || "").toString().trim();
|
|
if (node.value) {
|
|
list.push(node);
|
|
}
|
|
});
|
|
return list;
|
|
}
|
|
checkChar(chr) {
|
|
if (this.escaped) {
|
|
} else if (chr === this.operatorExpecting) {
|
|
this.node = {
|
|
type: "operator",
|
|
value: chr
|
|
};
|
|
this.list.push(this.node);
|
|
this.node = null;
|
|
this.operatorExpecting = "";
|
|
this.escaped = false;
|
|
return;
|
|
} else if (!this.operatorExpecting && chr in this.operators) {
|
|
this.node = {
|
|
type: "operator",
|
|
value: chr
|
|
};
|
|
this.list.push(this.node);
|
|
this.node = null;
|
|
this.operatorExpecting = this.operators[chr];
|
|
this.escaped = false;
|
|
return;
|
|
} else if (['"', "'"].includes(this.operatorExpecting) && chr === "\\") {
|
|
this.escaped = true;
|
|
return;
|
|
}
|
|
if (!this.node) {
|
|
this.node = {
|
|
type: "text",
|
|
value: ""
|
|
};
|
|
this.list.push(this.node);
|
|
}
|
|
if (chr === "\n") {
|
|
chr = " ";
|
|
}
|
|
if (chr.charCodeAt(0) >= 33 || [" ", "\t"].includes(chr)) {
|
|
this.node.value += chr;
|
|
}
|
|
this.escaped = false;
|
|
}
|
|
}
|
|
function addressparser(str, options) {
|
|
options = options || {};
|
|
let tokenizer = new Tokenizer(str);
|
|
let tokens = tokenizer.tokenize();
|
|
let addresses = [];
|
|
let address = [];
|
|
let parsedAddresses = [];
|
|
tokens.forEach((token) => {
|
|
if (token.type === "operator" && (token.value === "," || token.value === ";")) {
|
|
if (address.length) {
|
|
addresses.push(address);
|
|
}
|
|
address = [];
|
|
} else {
|
|
address.push(token);
|
|
}
|
|
});
|
|
if (address.length) {
|
|
addresses.push(address);
|
|
}
|
|
addresses.forEach((address2) => {
|
|
address2 = _handleAddress(address2);
|
|
if (address2.length) {
|
|
parsedAddresses = parsedAddresses.concat(address2);
|
|
}
|
|
});
|
|
if (options.flatten) {
|
|
let addresses2 = [];
|
|
let walkAddressList = (list) => {
|
|
list.forEach((address2) => {
|
|
if (address2.group) {
|
|
return walkAddressList(address2.group);
|
|
} else {
|
|
addresses2.push(address2);
|
|
}
|
|
});
|
|
};
|
|
walkAddressList(parsedAddresses);
|
|
return addresses2;
|
|
}
|
|
return parsedAddresses;
|
|
}
|
|
module.exports = addressparser;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-node/last-newline.js
|
|
var require_last_newline = __commonJS((exports, module) => {
|
|
var Transform = __require("stream").Transform;
|
|
|
|
class LastNewline extends Transform {
|
|
constructor() {
|
|
super();
|
|
this.lastByte = false;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
if (chunk.length) {
|
|
this.lastByte = chunk[chunk.length - 1];
|
|
}
|
|
this.push(chunk);
|
|
done();
|
|
}
|
|
_flush(done) {
|
|
if (this.lastByte === 10) {
|
|
return done();
|
|
}
|
|
if (this.lastByte === 13) {
|
|
this.push(Buffer.from("\n"));
|
|
return done();
|
|
}
|
|
this.push(Buffer.from("\r\n"));
|
|
return done();
|
|
}
|
|
}
|
|
module.exports = LastNewline;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-node/le-windows.js
|
|
var require_le_windows = __commonJS((exports, module) => {
|
|
var stream = __require("stream");
|
|
var Transform = stream.Transform;
|
|
|
|
class LeWindows extends Transform {
|
|
constructor(options) {
|
|
super(options);
|
|
this.options = options || {};
|
|
this.lastByte = false;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
let buf;
|
|
let lastPos = 0;
|
|
for (let i = 0, len = chunk.length;i < len; i++) {
|
|
if (chunk[i] === 10) {
|
|
if (i && chunk[i - 1] !== 13 || !i && this.lastByte !== 13) {
|
|
if (i > lastPos) {
|
|
buf = chunk.slice(lastPos, i);
|
|
this.push(buf);
|
|
}
|
|
this.push(Buffer.from("\r\n"));
|
|
lastPos = i + 1;
|
|
}
|
|
}
|
|
}
|
|
if (lastPos && lastPos < chunk.length) {
|
|
buf = chunk.slice(lastPos);
|
|
this.push(buf);
|
|
} else if (!lastPos) {
|
|
this.push(chunk);
|
|
}
|
|
this.lastByte = chunk[chunk.length - 1];
|
|
done();
|
|
}
|
|
}
|
|
module.exports = LeWindows;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-node/le-unix.js
|
|
var require_le_unix = __commonJS((exports, module) => {
|
|
var stream = __require("stream");
|
|
var Transform = stream.Transform;
|
|
|
|
class LeWindows extends Transform {
|
|
constructor(options) {
|
|
super(options);
|
|
this.options = options || {};
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
let buf;
|
|
let lastPos = 0;
|
|
for (let i = 0, len = chunk.length;i < len; i++) {
|
|
if (chunk[i] === 13) {
|
|
buf = chunk.slice(lastPos, i);
|
|
lastPos = i + 1;
|
|
this.push(buf);
|
|
}
|
|
}
|
|
if (lastPos && lastPos < chunk.length) {
|
|
buf = chunk.slice(lastPos);
|
|
this.push(buf);
|
|
} else if (!lastPos) {
|
|
this.push(chunk);
|
|
}
|
|
done();
|
|
}
|
|
}
|
|
module.exports = LeWindows;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mime-node/index.js
|
|
var require_mime_node = __commonJS((exports, module) => {
|
|
var crypto2 = __require("crypto");
|
|
var fs15 = __require("fs");
|
|
var punycode = require_punycode();
|
|
var PassThrough = __require("stream").PassThrough;
|
|
var shared = require_shared();
|
|
var mimeFuncs = require_mime_funcs();
|
|
var qp = require_qp();
|
|
var base64 = require_base642();
|
|
var addressparser = require_addressparser();
|
|
var nmfetch = require_fetch();
|
|
var LastNewline = require_last_newline();
|
|
var LeWindows = require_le_windows();
|
|
var LeUnix = require_le_unix();
|
|
|
|
class MimeNode {
|
|
constructor(contentType, options) {
|
|
this.nodeCounter = 0;
|
|
options = options || {};
|
|
this.baseBoundary = options.baseBoundary || crypto2.randomBytes(8).toString("hex");
|
|
this.boundaryPrefix = options.boundaryPrefix || "--_NmP";
|
|
this.disableFileAccess = !!options.disableFileAccess;
|
|
this.disableUrlAccess = !!options.disableUrlAccess;
|
|
this.normalizeHeaderKey = options.normalizeHeaderKey;
|
|
this.date = new Date;
|
|
this.rootNode = options.rootNode || this;
|
|
this.keepBcc = !!options.keepBcc;
|
|
if (options.filename) {
|
|
this.filename = options.filename;
|
|
if (!contentType) {
|
|
contentType = mimeFuncs.detectMimeType(this.filename.split(".").pop());
|
|
}
|
|
}
|
|
this.textEncoding = (options.textEncoding || "").toString().trim().charAt(0).toUpperCase();
|
|
this.parentNode = options.parentNode;
|
|
this.hostname = options.hostname;
|
|
this.newline = options.newline;
|
|
this.childNodes = [];
|
|
this._nodeId = ++this.rootNode.nodeCounter;
|
|
this._headers = [];
|
|
this._isPlainText = false;
|
|
this._hasLongLines = false;
|
|
this._envelope = false;
|
|
this._raw = false;
|
|
this._transforms = [];
|
|
this._processFuncs = [];
|
|
if (contentType) {
|
|
this.setHeader("Content-Type", contentType);
|
|
}
|
|
}
|
|
createChild(contentType, options) {
|
|
if (!options && typeof contentType === "object") {
|
|
options = contentType;
|
|
contentType = undefined;
|
|
}
|
|
let node = new MimeNode(contentType, options);
|
|
this.appendChild(node);
|
|
return node;
|
|
}
|
|
appendChild(childNode) {
|
|
if (childNode.rootNode !== this.rootNode) {
|
|
childNode.rootNode = this.rootNode;
|
|
childNode._nodeId = ++this.rootNode.nodeCounter;
|
|
}
|
|
childNode.parentNode = this;
|
|
this.childNodes.push(childNode);
|
|
return childNode;
|
|
}
|
|
replace(node) {
|
|
if (node === this) {
|
|
return this;
|
|
}
|
|
this.parentNode.childNodes.forEach((childNode, i) => {
|
|
if (childNode === this) {
|
|
node.rootNode = this.rootNode;
|
|
node.parentNode = this.parentNode;
|
|
node._nodeId = this._nodeId;
|
|
this.rootNode = this;
|
|
this.parentNode = undefined;
|
|
node.parentNode.childNodes[i] = node;
|
|
}
|
|
});
|
|
return node;
|
|
}
|
|
remove() {
|
|
if (!this.parentNode) {
|
|
return this;
|
|
}
|
|
for (let i = this.parentNode.childNodes.length - 1;i >= 0; i--) {
|
|
if (this.parentNode.childNodes[i] === this) {
|
|
this.parentNode.childNodes.splice(i, 1);
|
|
this.parentNode = undefined;
|
|
this.rootNode = this;
|
|
return this;
|
|
}
|
|
}
|
|
}
|
|
setHeader(key, value) {
|
|
let added = false, headerValue;
|
|
if (!value && key && typeof key === "object") {
|
|
if (key.key && "value" in key) {
|
|
this.setHeader(key.key, key.value);
|
|
} else if (Array.isArray(key)) {
|
|
key.forEach((i) => {
|
|
this.setHeader(i.key, i.value);
|
|
});
|
|
} else {
|
|
Object.keys(key).forEach((i) => {
|
|
this.setHeader(i, key[i]);
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
key = this._normalizeHeaderKey(key);
|
|
headerValue = {
|
|
key,
|
|
value
|
|
};
|
|
for (let i = 0, len = this._headers.length;i < len; i++) {
|
|
if (this._headers[i].key === key) {
|
|
if (!added) {
|
|
this._headers[i] = headerValue;
|
|
added = true;
|
|
} else {
|
|
this._headers.splice(i, 1);
|
|
i--;
|
|
len--;
|
|
}
|
|
}
|
|
}
|
|
if (!added) {
|
|
this._headers.push(headerValue);
|
|
}
|
|
return this;
|
|
}
|
|
addHeader(key, value) {
|
|
if (!value && key && typeof key === "object") {
|
|
if (key.key && key.value) {
|
|
this.addHeader(key.key, key.value);
|
|
} else if (Array.isArray(key)) {
|
|
key.forEach((i) => {
|
|
this.addHeader(i.key, i.value);
|
|
});
|
|
} else {
|
|
Object.keys(key).forEach((i) => {
|
|
this.addHeader(i, key[i]);
|
|
});
|
|
}
|
|
return this;
|
|
} else if (Array.isArray(value)) {
|
|
value.forEach((val) => {
|
|
this.addHeader(key, val);
|
|
});
|
|
return this;
|
|
}
|
|
this._headers.push({
|
|
key: this._normalizeHeaderKey(key),
|
|
value
|
|
});
|
|
return this;
|
|
}
|
|
getHeader(key) {
|
|
key = this._normalizeHeaderKey(key);
|
|
for (let i = 0, len = this._headers.length;i < len; i++) {
|
|
if (this._headers[i].key === key) {
|
|
return this._headers[i].value;
|
|
}
|
|
}
|
|
}
|
|
setContent(content) {
|
|
this.content = content;
|
|
if (typeof this.content.pipe === "function") {
|
|
this._contentErrorHandler = (err) => {
|
|
this.content.removeListener("error", this._contentErrorHandler);
|
|
this.content = err;
|
|
};
|
|
this.content.once("error", this._contentErrorHandler);
|
|
} else if (typeof this.content === "string") {
|
|
this._isPlainText = mimeFuncs.isPlainText(this.content);
|
|
if (this._isPlainText && mimeFuncs.hasLongerLines(this.content, 76)) {
|
|
this._hasLongLines = true;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
build(callback) {
|
|
let promise;
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
let stream = this.createReadStream();
|
|
let buf = [];
|
|
let buflen = 0;
|
|
let returned = false;
|
|
stream.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = stream.read()) !== null) {
|
|
buf.push(chunk);
|
|
buflen += chunk.length;
|
|
}
|
|
});
|
|
stream.once("error", (err) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(err);
|
|
});
|
|
stream.once("end", (chunk) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
if (chunk && chunk.length) {
|
|
buf.push(chunk);
|
|
buflen += chunk.length;
|
|
}
|
|
return callback(null, Buffer.concat(buf, buflen));
|
|
});
|
|
return promise;
|
|
}
|
|
getTransferEncoding() {
|
|
let transferEncoding = false;
|
|
let contentType = (this.getHeader("Content-Type") || "").toString().toLowerCase().trim();
|
|
if (this.content) {
|
|
transferEncoding = (this.getHeader("Content-Transfer-Encoding") || "").toString().toLowerCase().trim();
|
|
if (!transferEncoding || !["base64", "quoted-printable"].includes(transferEncoding)) {
|
|
if (/^text\//i.test(contentType)) {
|
|
if (this._isPlainText && !this._hasLongLines) {
|
|
transferEncoding = "7bit";
|
|
} else if (typeof this.content === "string" || this.content instanceof Buffer) {
|
|
transferEncoding = this._getTextEncoding(this.content) === "Q" ? "quoted-printable" : "base64";
|
|
} else {
|
|
transferEncoding = this.textEncoding === "B" ? "base64" : "quoted-printable";
|
|
}
|
|
} else if (!/^(multipart|message)\//i.test(contentType)) {
|
|
transferEncoding = transferEncoding || "base64";
|
|
}
|
|
}
|
|
}
|
|
return transferEncoding;
|
|
}
|
|
buildHeaders() {
|
|
let transferEncoding = this.getTransferEncoding();
|
|
let headers = [];
|
|
if (transferEncoding) {
|
|
this.setHeader("Content-Transfer-Encoding", transferEncoding);
|
|
}
|
|
if (this.filename && !this.getHeader("Content-Disposition")) {
|
|
this.setHeader("Content-Disposition", "attachment");
|
|
}
|
|
if (this.rootNode === this) {
|
|
if (!this.getHeader("Date")) {
|
|
this.setHeader("Date", this.date.toUTCString().replace(/GMT/, "+0000"));
|
|
}
|
|
this.messageId();
|
|
if (!this.getHeader("MIME-Version")) {
|
|
this.setHeader("MIME-Version", "1.0");
|
|
}
|
|
for (let i = this._headers.length - 2;i >= 0; i--) {
|
|
let header = this._headers[i];
|
|
if (header.key === "Content-Type") {
|
|
this._headers.splice(i, 1);
|
|
this._headers.push(header);
|
|
}
|
|
}
|
|
}
|
|
this._headers.forEach((header) => {
|
|
let key = header.key;
|
|
let value = header.value;
|
|
let structured;
|
|
let param;
|
|
let options = {};
|
|
let formattedHeaders = ["From", "Sender", "To", "Cc", "Bcc", "Reply-To", "Date", "References"];
|
|
if (value && typeof value === "object" && !formattedHeaders.includes(key)) {
|
|
Object.keys(value).forEach((key2) => {
|
|
if (key2 !== "value") {
|
|
options[key2] = value[key2];
|
|
}
|
|
});
|
|
value = (value.value || "").toString();
|
|
if (!value.trim()) {
|
|
return;
|
|
}
|
|
}
|
|
if (options.prepared) {
|
|
if (options.foldLines) {
|
|
headers.push(mimeFuncs.foldLines(key + ": " + value));
|
|
} else {
|
|
headers.push(key + ": " + value);
|
|
}
|
|
return;
|
|
}
|
|
switch (header.key) {
|
|
case "Content-Disposition":
|
|
structured = mimeFuncs.parseHeaderValue(value);
|
|
if (this.filename) {
|
|
structured.params.filename = this.filename;
|
|
}
|
|
value = mimeFuncs.buildHeaderValue(structured);
|
|
break;
|
|
case "Content-Type":
|
|
structured = mimeFuncs.parseHeaderValue(value);
|
|
this._handleContentType(structured);
|
|
if (structured.value.match(/^text\/plain\b/) && typeof this.content === "string" && /[\u0080-\uFFFF]/.test(this.content)) {
|
|
structured.params.charset = "utf-8";
|
|
}
|
|
value = mimeFuncs.buildHeaderValue(structured);
|
|
if (this.filename) {
|
|
param = this._encodeWords(this.filename);
|
|
if (param !== this.filename || /[\s'"\\;:/=(),<>@[\]?]|^-/.test(param)) {
|
|
param = '"' + param + '"';
|
|
}
|
|
value += "; name=" + param;
|
|
}
|
|
break;
|
|
case "Bcc":
|
|
if (!this.keepBcc) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
value = this._encodeHeaderValue(key, value);
|
|
if (!(value || "").toString().trim()) {
|
|
return;
|
|
}
|
|
if (typeof this.normalizeHeaderKey === "function") {
|
|
let normalized = this.normalizeHeaderKey(key, value);
|
|
if (normalized && typeof normalized === "string" && normalized.length) {
|
|
key = normalized;
|
|
}
|
|
}
|
|
headers.push(mimeFuncs.foldLines(key + ": " + value, 76));
|
|
});
|
|
return headers.join("\r\n");
|
|
}
|
|
createReadStream(options) {
|
|
options = options || {};
|
|
let stream = new PassThrough(options);
|
|
let outputStream = stream;
|
|
let transform;
|
|
this.stream(stream, options, (err) => {
|
|
if (err) {
|
|
outputStream.emit("error", err);
|
|
return;
|
|
}
|
|
stream.end();
|
|
});
|
|
for (let i = 0, len = this._transforms.length;i < len; i++) {
|
|
transform = typeof this._transforms[i] === "function" ? this._transforms[i]() : this._transforms[i];
|
|
outputStream.once("error", (err) => {
|
|
transform.emit("error", err);
|
|
});
|
|
outputStream = outputStream.pipe(transform);
|
|
}
|
|
transform = new LastNewline;
|
|
outputStream.once("error", (err) => {
|
|
transform.emit("error", err);
|
|
});
|
|
outputStream = outputStream.pipe(transform);
|
|
for (let i = 0, len = this._processFuncs.length;i < len; i++) {
|
|
transform = this._processFuncs[i];
|
|
outputStream = transform(outputStream);
|
|
}
|
|
if (this.newline) {
|
|
const winbreak = ["win", "windows", "dos", "\r\n"].includes(this.newline.toString().toLowerCase());
|
|
const newlineTransform = winbreak ? new LeWindows : new LeUnix;
|
|
const stream2 = outputStream.pipe(newlineTransform);
|
|
outputStream.on("error", (err) => stream2.emit("error", err));
|
|
return stream2;
|
|
}
|
|
return outputStream;
|
|
}
|
|
transform(transform) {
|
|
this._transforms.push(transform);
|
|
}
|
|
processFunc(processFunc) {
|
|
this._processFuncs.push(processFunc);
|
|
}
|
|
stream(outputStream, options, done) {
|
|
let transferEncoding = this.getTransferEncoding();
|
|
let contentStream;
|
|
let localStream;
|
|
let returned = false;
|
|
let callback = (err) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
done(err);
|
|
};
|
|
let finalize = () => {
|
|
let childId = 0;
|
|
let processChildNode = () => {
|
|
if (childId >= this.childNodes.length) {
|
|
outputStream.write("\r\n--" + this.boundary + "--\r\n");
|
|
return callback();
|
|
}
|
|
let child = this.childNodes[childId++];
|
|
outputStream.write((childId > 1 ? "\r\n" : "") + "--" + this.boundary + "\r\n");
|
|
child.stream(outputStream, options, (err) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
setImmediate(processChildNode);
|
|
});
|
|
};
|
|
if (this.multipart) {
|
|
setImmediate(processChildNode);
|
|
} else {
|
|
return callback();
|
|
}
|
|
};
|
|
let sendContent = () => {
|
|
if (this.content) {
|
|
if (Object.prototype.toString.call(this.content) === "[object Error]") {
|
|
return callback(this.content);
|
|
}
|
|
if (typeof this.content.pipe === "function") {
|
|
this.content.removeListener("error", this._contentErrorHandler);
|
|
this._contentErrorHandler = (err) => callback(err);
|
|
this.content.once("error", this._contentErrorHandler);
|
|
}
|
|
let createStream = () => {
|
|
if (["quoted-printable", "base64"].includes(transferEncoding)) {
|
|
contentStream = new (transferEncoding === "base64" ? base64 : qp).Encoder(options);
|
|
contentStream.pipe(outputStream, {
|
|
end: false
|
|
});
|
|
contentStream.once("end", finalize);
|
|
contentStream.once("error", (err) => callback(err));
|
|
localStream = this._getStream(this.content);
|
|
localStream.pipe(contentStream);
|
|
} else {
|
|
localStream = this._getStream(this.content);
|
|
localStream.pipe(outputStream, {
|
|
end: false
|
|
});
|
|
localStream.once("end", finalize);
|
|
}
|
|
localStream.once("error", (err) => callback(err));
|
|
};
|
|
if (this.content._resolve) {
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
let returned2 = false;
|
|
let sourceStream = this._getStream(this.content);
|
|
sourceStream.on("error", (err) => {
|
|
if (returned2) {
|
|
return;
|
|
}
|
|
returned2 = true;
|
|
callback(err);
|
|
});
|
|
sourceStream.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = sourceStream.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
sourceStream.on("end", () => {
|
|
if (returned2) {
|
|
return;
|
|
}
|
|
returned2 = true;
|
|
this.content._resolve = false;
|
|
this.content._resolvedValue = Buffer.concat(chunks, chunklen);
|
|
setImmediate(createStream);
|
|
});
|
|
} else {
|
|
setImmediate(createStream);
|
|
}
|
|
return;
|
|
} else {
|
|
return setImmediate(finalize);
|
|
}
|
|
};
|
|
if (this._raw) {
|
|
setImmediate(() => {
|
|
if (Object.prototype.toString.call(this._raw) === "[object Error]") {
|
|
return callback(this._raw);
|
|
}
|
|
if (typeof this._raw.pipe === "function") {
|
|
this._raw.removeListener("error", this._contentErrorHandler);
|
|
}
|
|
let raw = this._getStream(this._raw);
|
|
raw.pipe(outputStream, {
|
|
end: false
|
|
});
|
|
raw.on("error", (err) => outputStream.emit("error", err));
|
|
raw.on("end", finalize);
|
|
});
|
|
} else {
|
|
outputStream.write(this.buildHeaders() + "\r\n\r\n");
|
|
setImmediate(sendContent);
|
|
}
|
|
}
|
|
setEnvelope(envelope) {
|
|
let list;
|
|
this._envelope = {
|
|
from: false,
|
|
to: []
|
|
};
|
|
if (envelope.from) {
|
|
list = [];
|
|
this._convertAddresses(this._parseAddresses(envelope.from), list);
|
|
list = list.filter((address) => address && address.address);
|
|
if (list.length && list[0]) {
|
|
this._envelope.from = list[0].address;
|
|
}
|
|
}
|
|
["to", "cc", "bcc"].forEach((key) => {
|
|
if (envelope[key]) {
|
|
this._convertAddresses(this._parseAddresses(envelope[key]), this._envelope.to);
|
|
}
|
|
});
|
|
this._envelope.to = this._envelope.to.map((to) => to.address).filter((address) => address);
|
|
let standardFields = ["to", "cc", "bcc", "from"];
|
|
Object.keys(envelope).forEach((key) => {
|
|
if (!standardFields.includes(key)) {
|
|
this._envelope[key] = envelope[key];
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
getAddresses() {
|
|
let addresses = {};
|
|
this._headers.forEach((header) => {
|
|
let key = header.key.toLowerCase();
|
|
if (["from", "sender", "reply-to", "to", "cc", "bcc"].includes(key)) {
|
|
if (!Array.isArray(addresses[key])) {
|
|
addresses[key] = [];
|
|
}
|
|
this._convertAddresses(this._parseAddresses(header.value), addresses[key]);
|
|
}
|
|
});
|
|
return addresses;
|
|
}
|
|
getEnvelope() {
|
|
if (this._envelope) {
|
|
return this._envelope;
|
|
}
|
|
let envelope = {
|
|
from: false,
|
|
to: []
|
|
};
|
|
this._headers.forEach((header) => {
|
|
let list = [];
|
|
if (header.key === "From" || !envelope.from && ["Reply-To", "Sender"].includes(header.key)) {
|
|
this._convertAddresses(this._parseAddresses(header.value), list);
|
|
if (list.length && list[0]) {
|
|
envelope.from = list[0].address;
|
|
}
|
|
} else if (["To", "Cc", "Bcc"].includes(header.key)) {
|
|
this._convertAddresses(this._parseAddresses(header.value), envelope.to);
|
|
}
|
|
});
|
|
envelope.to = envelope.to.map((to) => to.address);
|
|
return envelope;
|
|
}
|
|
messageId() {
|
|
let messageId = this.getHeader("Message-ID");
|
|
if (!messageId) {
|
|
messageId = this._generateMessageId();
|
|
this.setHeader("Message-ID", messageId);
|
|
}
|
|
return messageId;
|
|
}
|
|
setRaw(raw) {
|
|
this._raw = raw;
|
|
if (this._raw && typeof this._raw.pipe === "function") {
|
|
this._contentErrorHandler = (err) => {
|
|
this._raw.removeListener("error", this._contentErrorHandler);
|
|
this._raw = err;
|
|
};
|
|
this._raw.once("error", this._contentErrorHandler);
|
|
}
|
|
return this;
|
|
}
|
|
_getStream(content) {
|
|
let contentStream;
|
|
if (content._resolvedValue) {
|
|
contentStream = new PassThrough;
|
|
setImmediate(() => {
|
|
try {
|
|
contentStream.end(content._resolvedValue);
|
|
} catch (err) {
|
|
contentStream.emit("error", err);
|
|
}
|
|
});
|
|
return contentStream;
|
|
} else if (typeof content.pipe === "function") {
|
|
return content;
|
|
} else if (content && typeof content.path === "string" && !content.href) {
|
|
if (this.disableFileAccess) {
|
|
contentStream = new PassThrough;
|
|
setImmediate(() => contentStream.emit("error", new Error("File access rejected for " + content.path)));
|
|
return contentStream;
|
|
}
|
|
return fs15.createReadStream(content.path);
|
|
} else if (content && typeof content.href === "string") {
|
|
if (this.disableUrlAccess) {
|
|
contentStream = new PassThrough;
|
|
setImmediate(() => contentStream.emit("error", new Error("Url access rejected for " + content.href)));
|
|
return contentStream;
|
|
}
|
|
return nmfetch(content.href, { headers: content.httpHeaders });
|
|
} else {
|
|
contentStream = new PassThrough;
|
|
setImmediate(() => {
|
|
try {
|
|
contentStream.end(content || "");
|
|
} catch (err) {
|
|
contentStream.emit("error", err);
|
|
}
|
|
});
|
|
return contentStream;
|
|
}
|
|
}
|
|
_parseAddresses(addresses) {
|
|
return [].concat.apply([], [].concat(addresses).map((address) => {
|
|
if (address && address.address) {
|
|
address.address = this._normalizeAddress(address.address);
|
|
address.name = address.name || "";
|
|
return [address];
|
|
}
|
|
return addressparser(address);
|
|
}));
|
|
}
|
|
_normalizeHeaderKey(key) {
|
|
key = (key || "").toString().replace(/\r?\n|\r/g, " ").trim().toLowerCase().replace(/^X-SMTPAPI$|^(MIME|DKIM|ARC|BIMI)\b|^[a-z]|-(SPF|FBL|ID|MD5)$|-[a-z]/gi, (c) => c.toUpperCase()).replace(/^Content-Features$/i, "Content-features");
|
|
return key;
|
|
}
|
|
_handleContentType(structured) {
|
|
this.contentType = structured.value.trim().toLowerCase();
|
|
this.multipart = /^multipart\//i.test(this.contentType) ? this.contentType.substr(this.contentType.indexOf("/") + 1) : false;
|
|
if (this.multipart) {
|
|
this.boundary = structured.params.boundary = structured.params.boundary || this.boundary || this._generateBoundary();
|
|
} else {
|
|
this.boundary = false;
|
|
}
|
|
}
|
|
_generateBoundary() {
|
|
return this.rootNode.boundaryPrefix + "-" + this.rootNode.baseBoundary + "-Part_" + this._nodeId;
|
|
}
|
|
_encodeHeaderValue(key, value) {
|
|
key = this._normalizeHeaderKey(key);
|
|
switch (key) {
|
|
case "From":
|
|
case "Sender":
|
|
case "To":
|
|
case "Cc":
|
|
case "Bcc":
|
|
case "Reply-To":
|
|
return this._convertAddresses(this._parseAddresses(value));
|
|
case "Message-ID":
|
|
case "In-Reply-To":
|
|
case "Content-Id":
|
|
value = (value || "").toString().replace(/\r?\n|\r/g, " ");
|
|
if (value.charAt(0) !== "<") {
|
|
value = "<" + value;
|
|
}
|
|
if (value.charAt(value.length - 1) !== ">") {
|
|
value = value + ">";
|
|
}
|
|
return value;
|
|
case "References":
|
|
value = [].concat.apply([], [].concat(value || "").map((elm) => {
|
|
elm = (elm || "").toString().replace(/\r?\n|\r/g, " ").trim();
|
|
return elm.replace(/<[^>]*>/g, (str) => str.replace(/\s/g, "")).split(/\s+/);
|
|
})).map((elm) => {
|
|
if (elm.charAt(0) !== "<") {
|
|
elm = "<" + elm;
|
|
}
|
|
if (elm.charAt(elm.length - 1) !== ">") {
|
|
elm = elm + ">";
|
|
}
|
|
return elm;
|
|
});
|
|
return value.join(" ").trim();
|
|
case "Date":
|
|
if (Object.prototype.toString.call(value) === "[object Date]") {
|
|
return value.toUTCString().replace(/GMT/, "+0000");
|
|
}
|
|
value = (value || "").toString().replace(/\r?\n|\r/g, " ");
|
|
return this._encodeWords(value);
|
|
case "Content-Type":
|
|
case "Content-Disposition":
|
|
return (value || "").toString().replace(/\r?\n|\r/g, " ");
|
|
default:
|
|
value = (value || "").toString().replace(/\r?\n|\r/g, " ");
|
|
return this._encodeWords(value);
|
|
}
|
|
}
|
|
_convertAddresses(addresses, uniqueList) {
|
|
let values = [];
|
|
uniqueList = uniqueList || [];
|
|
[].concat(addresses || []).forEach((address) => {
|
|
if (address.address) {
|
|
address.address = this._normalizeAddress(address.address);
|
|
if (!address.name) {
|
|
values.push(address.address.indexOf(" ") >= 0 ? `<${address.address}>` : `${address.address}`);
|
|
} else if (address.name) {
|
|
values.push(`${this._encodeAddressName(address.name)} <${address.address}>`);
|
|
}
|
|
if (address.address) {
|
|
if (!uniqueList.filter((a) => a.address === address.address).length) {
|
|
uniqueList.push(address);
|
|
}
|
|
}
|
|
} else if (address.group) {
|
|
let groupListAddresses = (address.group.length ? this._convertAddresses(address.group, uniqueList) : "").trim();
|
|
values.push(`${this._encodeAddressName(address.name)}:${groupListAddresses};`);
|
|
}
|
|
});
|
|
return values.join(", ");
|
|
}
|
|
_normalizeAddress(address) {
|
|
address = (address || "").toString().replace(/[\x00-\x1F<>]+/g, " ").trim();
|
|
let lastAt = address.lastIndexOf("@");
|
|
if (lastAt < 0) {
|
|
return address;
|
|
}
|
|
let user = address.substr(0, lastAt);
|
|
let domain = address.substr(lastAt + 1);
|
|
let encodedDomain;
|
|
try {
|
|
encodedDomain = punycode.toASCII(domain.toLowerCase());
|
|
} catch (err) {
|
|
}
|
|
if (user.indexOf(" ") >= 0) {
|
|
if (user.charAt(0) !== '"') {
|
|
user = '"' + user;
|
|
}
|
|
if (user.substr(-1) !== '"') {
|
|
user = user + '"';
|
|
}
|
|
}
|
|
return `${user}@${encodedDomain}`;
|
|
}
|
|
_encodeAddressName(name) {
|
|
if (!/^[\w ]*$/.test(name)) {
|
|
if (/^[\x20-\x7e]*$/.test(name)) {
|
|
return '"' + name.replace(/([\\"])/g, "\\$1") + '"';
|
|
} else {
|
|
return mimeFuncs.encodeWord(name, this._getTextEncoding(name), 52);
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
_encodeWords(value) {
|
|
return mimeFuncs.encodeWords(value, this._getTextEncoding(value), 52, true);
|
|
}
|
|
_getTextEncoding(value) {
|
|
value = (value || "").toString();
|
|
let encoding = this.textEncoding;
|
|
let latinLen;
|
|
let nonLatinLen;
|
|
if (!encoding) {
|
|
nonLatinLen = (value.match(/[\x00-\x08\x0B\x0C\x0E-\x1F\u0080-\uFFFF]/g) || []).length;
|
|
latinLen = (value.match(/[a-z]/gi) || []).length;
|
|
encoding = nonLatinLen < latinLen ? "Q" : "B";
|
|
}
|
|
return encoding;
|
|
}
|
|
_generateMessageId() {
|
|
return "<" + [2, 2, 2, 6].reduce((prev, len) => prev + "-" + crypto2.randomBytes(len).toString("hex"), crypto2.randomBytes(4).toString("hex")) + "@" + (this.getEnvelope().from || this.hostname || "localhost").split("@").pop() + ">";
|
|
}
|
|
}
|
|
module.exports = MimeNode;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mail-composer/index.js
|
|
var require_mail_composer = __commonJS((exports, module) => {
|
|
var MimeNode = require_mime_node();
|
|
var mimeFuncs = require_mime_funcs();
|
|
var parseDataURI = require_shared().parseDataURI;
|
|
|
|
class MailComposer {
|
|
constructor(mail) {
|
|
this.mail = mail || {};
|
|
this.message = false;
|
|
}
|
|
compile() {
|
|
this._alternatives = this.getAlternatives();
|
|
this._htmlNode = this._alternatives.filter((alternative) => /^text\/html\b/i.test(alternative.contentType)).pop();
|
|
this._attachments = this.getAttachments(!!this._htmlNode);
|
|
this._useRelated = !!(this._htmlNode && this._attachments.related.length);
|
|
this._useAlternative = this._alternatives.length > 1;
|
|
this._useMixed = this._attachments.attached.length > 1 || this._alternatives.length && this._attachments.attached.length === 1;
|
|
if (this.mail.raw) {
|
|
this.message = new MimeNode("message/rfc822", { newline: this.mail.newline }).setRaw(this.mail.raw);
|
|
} else if (this._useMixed) {
|
|
this.message = this._createMixed();
|
|
} else if (this._useAlternative) {
|
|
this.message = this._createAlternative();
|
|
} else if (this._useRelated) {
|
|
this.message = this._createRelated();
|
|
} else {
|
|
this.message = this._createContentNode(false, [].concat(this._alternatives || []).concat(this._attachments.attached || []).shift() || {
|
|
contentType: "text/plain",
|
|
content: ""
|
|
});
|
|
}
|
|
if (this.mail.headers) {
|
|
this.message.addHeader(this.mail.headers);
|
|
}
|
|
["from", "sender", "to", "cc", "bcc", "reply-to", "in-reply-to", "references", "subject", "message-id", "date"].forEach((header) => {
|
|
let key = header.replace(/-(\w)/g, (o, c) => c.toUpperCase());
|
|
if (this.mail[key]) {
|
|
this.message.setHeader(header, this.mail[key]);
|
|
}
|
|
});
|
|
if (this.mail.envelope) {
|
|
this.message.setEnvelope(this.mail.envelope);
|
|
}
|
|
this.message.messageId();
|
|
return this.message;
|
|
}
|
|
getAttachments(findRelated) {
|
|
let icalEvent, eventObject;
|
|
let attachments = [].concat(this.mail.attachments || []).map((attachment, i) => {
|
|
let data;
|
|
let isMessageNode = /^message\//i.test(attachment.contentType);
|
|
if (/^data:/i.test(attachment.path || attachment.href)) {
|
|
attachment = this._processDataUrl(attachment);
|
|
}
|
|
let contentType = attachment.contentType || mimeFuncs.detectMimeType(attachment.filename || attachment.path || attachment.href || "bin");
|
|
let isImage = /^image\//i.test(contentType);
|
|
let contentDisposition = attachment.contentDisposition || (isMessageNode || isImage && attachment.cid ? "inline" : "attachment");
|
|
data = {
|
|
contentType,
|
|
contentDisposition,
|
|
contentTransferEncoding: "contentTransferEncoding" in attachment ? attachment.contentTransferEncoding : "base64"
|
|
};
|
|
if (attachment.filename) {
|
|
data.filename = attachment.filename;
|
|
} else if (!isMessageNode && attachment.filename !== false) {
|
|
data.filename = (attachment.path || attachment.href || "").split("/").pop().split("?").shift() || "attachment-" + (i + 1);
|
|
if (data.filename.indexOf(".") < 0) {
|
|
data.filename += "." + mimeFuncs.detectExtension(data.contentType);
|
|
}
|
|
}
|
|
if (/^https?:\/\//i.test(attachment.path)) {
|
|
attachment.href = attachment.path;
|
|
attachment.path = undefined;
|
|
}
|
|
if (attachment.cid) {
|
|
data.cid = attachment.cid;
|
|
}
|
|
if (attachment.raw) {
|
|
data.raw = attachment.raw;
|
|
} else if (attachment.path) {
|
|
data.content = {
|
|
path: attachment.path
|
|
};
|
|
} else if (attachment.href) {
|
|
data.content = {
|
|
href: attachment.href,
|
|
httpHeaders: attachment.httpHeaders
|
|
};
|
|
} else {
|
|
data.content = attachment.content || "";
|
|
}
|
|
if (attachment.encoding) {
|
|
data.encoding = attachment.encoding;
|
|
}
|
|
if (attachment.headers) {
|
|
data.headers = attachment.headers;
|
|
}
|
|
return data;
|
|
});
|
|
if (this.mail.icalEvent) {
|
|
if (typeof this.mail.icalEvent === "object" && (this.mail.icalEvent.content || this.mail.icalEvent.path || this.mail.icalEvent.href || this.mail.icalEvent.raw)) {
|
|
icalEvent = this.mail.icalEvent;
|
|
} else {
|
|
icalEvent = {
|
|
content: this.mail.icalEvent
|
|
};
|
|
}
|
|
eventObject = {};
|
|
Object.keys(icalEvent).forEach((key) => {
|
|
eventObject[key] = icalEvent[key];
|
|
});
|
|
eventObject.contentType = "application/ics";
|
|
if (!eventObject.headers) {
|
|
eventObject.headers = {};
|
|
}
|
|
eventObject.filename = eventObject.filename || "invite.ics";
|
|
eventObject.headers["Content-Disposition"] = "attachment";
|
|
eventObject.headers["Content-Transfer-Encoding"] = "base64";
|
|
}
|
|
if (!findRelated) {
|
|
return {
|
|
attached: attachments.concat(eventObject || []),
|
|
related: []
|
|
};
|
|
} else {
|
|
return {
|
|
attached: attachments.filter((attachment) => !attachment.cid).concat(eventObject || []),
|
|
related: attachments.filter((attachment) => !!attachment.cid)
|
|
};
|
|
}
|
|
}
|
|
getAlternatives() {
|
|
let alternatives = [], text, html, watchHtml, amp, icalEvent, eventObject;
|
|
if (this.mail.text) {
|
|
if (typeof this.mail.text === "object" && (this.mail.text.content || this.mail.text.path || this.mail.text.href || this.mail.text.raw)) {
|
|
text = this.mail.text;
|
|
} else {
|
|
text = {
|
|
content: this.mail.text
|
|
};
|
|
}
|
|
text.contentType = "text/plain; charset=utf-8";
|
|
}
|
|
if (this.mail.watchHtml) {
|
|
if (typeof this.mail.watchHtml === "object" && (this.mail.watchHtml.content || this.mail.watchHtml.path || this.mail.watchHtml.href || this.mail.watchHtml.raw)) {
|
|
watchHtml = this.mail.watchHtml;
|
|
} else {
|
|
watchHtml = {
|
|
content: this.mail.watchHtml
|
|
};
|
|
}
|
|
watchHtml.contentType = "text/watch-html; charset=utf-8";
|
|
}
|
|
if (this.mail.amp) {
|
|
if (typeof this.mail.amp === "object" && (this.mail.amp.content || this.mail.amp.path || this.mail.amp.href || this.mail.amp.raw)) {
|
|
amp = this.mail.amp;
|
|
} else {
|
|
amp = {
|
|
content: this.mail.amp
|
|
};
|
|
}
|
|
amp.contentType = "text/x-amp-html; charset=utf-8";
|
|
}
|
|
if (this.mail.icalEvent) {
|
|
if (typeof this.mail.icalEvent === "object" && (this.mail.icalEvent.content || this.mail.icalEvent.path || this.mail.icalEvent.href || this.mail.icalEvent.raw)) {
|
|
icalEvent = this.mail.icalEvent;
|
|
} else {
|
|
icalEvent = {
|
|
content: this.mail.icalEvent
|
|
};
|
|
}
|
|
eventObject = {};
|
|
Object.keys(icalEvent).forEach((key) => {
|
|
eventObject[key] = icalEvent[key];
|
|
});
|
|
if (eventObject.content && typeof eventObject.content === "object") {
|
|
eventObject.content._resolve = true;
|
|
}
|
|
eventObject.filename = false;
|
|
eventObject.contentType = "text/calendar; charset=utf-8; method=" + (eventObject.method || "PUBLISH").toString().trim().toUpperCase();
|
|
if (!eventObject.headers) {
|
|
eventObject.headers = {};
|
|
}
|
|
}
|
|
if (this.mail.html) {
|
|
if (typeof this.mail.html === "object" && (this.mail.html.content || this.mail.html.path || this.mail.html.href || this.mail.html.raw)) {
|
|
html = this.mail.html;
|
|
} else {
|
|
html = {
|
|
content: this.mail.html
|
|
};
|
|
}
|
|
html.contentType = "text/html; charset=utf-8";
|
|
}
|
|
[].concat(text || []).concat(watchHtml || []).concat(amp || []).concat(html || []).concat(eventObject || []).concat(this.mail.alternatives || []).forEach((alternative) => {
|
|
let data;
|
|
if (/^data:/i.test(alternative.path || alternative.href)) {
|
|
alternative = this._processDataUrl(alternative);
|
|
}
|
|
data = {
|
|
contentType: alternative.contentType || mimeFuncs.detectMimeType(alternative.filename || alternative.path || alternative.href || "txt"),
|
|
contentTransferEncoding: alternative.contentTransferEncoding
|
|
};
|
|
if (alternative.filename) {
|
|
data.filename = alternative.filename;
|
|
}
|
|
if (/^https?:\/\//i.test(alternative.path)) {
|
|
alternative.href = alternative.path;
|
|
alternative.path = undefined;
|
|
}
|
|
if (alternative.raw) {
|
|
data.raw = alternative.raw;
|
|
} else if (alternative.path) {
|
|
data.content = {
|
|
path: alternative.path
|
|
};
|
|
} else if (alternative.href) {
|
|
data.content = {
|
|
href: alternative.href
|
|
};
|
|
} else {
|
|
data.content = alternative.content || "";
|
|
}
|
|
if (alternative.encoding) {
|
|
data.encoding = alternative.encoding;
|
|
}
|
|
if (alternative.headers) {
|
|
data.headers = alternative.headers;
|
|
}
|
|
alternatives.push(data);
|
|
});
|
|
return alternatives;
|
|
}
|
|
_createMixed(parentNode) {
|
|
let node;
|
|
if (!parentNode) {
|
|
node = new MimeNode("multipart/mixed", {
|
|
baseBoundary: this.mail.baseBoundary,
|
|
textEncoding: this.mail.textEncoding,
|
|
boundaryPrefix: this.mail.boundaryPrefix,
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
} else {
|
|
node = parentNode.createChild("multipart/mixed", {
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
}
|
|
if (this._useAlternative) {
|
|
this._createAlternative(node);
|
|
} else if (this._useRelated) {
|
|
this._createRelated(node);
|
|
}
|
|
[].concat(!this._useAlternative && this._alternatives || []).concat(this._attachments.attached || []).forEach((element) => {
|
|
if (!this._useRelated || element !== this._htmlNode) {
|
|
this._createContentNode(node, element);
|
|
}
|
|
});
|
|
return node;
|
|
}
|
|
_createAlternative(parentNode) {
|
|
let node;
|
|
if (!parentNode) {
|
|
node = new MimeNode("multipart/alternative", {
|
|
baseBoundary: this.mail.baseBoundary,
|
|
textEncoding: this.mail.textEncoding,
|
|
boundaryPrefix: this.mail.boundaryPrefix,
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
} else {
|
|
node = parentNode.createChild("multipart/alternative", {
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
}
|
|
this._alternatives.forEach((alternative) => {
|
|
if (this._useRelated && this._htmlNode === alternative) {
|
|
this._createRelated(node);
|
|
} else {
|
|
this._createContentNode(node, alternative);
|
|
}
|
|
});
|
|
return node;
|
|
}
|
|
_createRelated(parentNode) {
|
|
let node;
|
|
if (!parentNode) {
|
|
node = new MimeNode('multipart/related; type="text/html"', {
|
|
baseBoundary: this.mail.baseBoundary,
|
|
textEncoding: this.mail.textEncoding,
|
|
boundaryPrefix: this.mail.boundaryPrefix,
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
} else {
|
|
node = parentNode.createChild('multipart/related; type="text/html"', {
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
}
|
|
this._createContentNode(node, this._htmlNode);
|
|
this._attachments.related.forEach((alternative) => this._createContentNode(node, alternative));
|
|
return node;
|
|
}
|
|
_createContentNode(parentNode, element) {
|
|
element = element || {};
|
|
element.content = element.content || "";
|
|
let node;
|
|
let encoding = (element.encoding || "utf8").toString().toLowerCase().replace(/[-_\s]/g, "");
|
|
if (!parentNode) {
|
|
node = new MimeNode(element.contentType, {
|
|
filename: element.filename,
|
|
baseBoundary: this.mail.baseBoundary,
|
|
textEncoding: this.mail.textEncoding,
|
|
boundaryPrefix: this.mail.boundaryPrefix,
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
} else {
|
|
node = parentNode.createChild(element.contentType, {
|
|
filename: element.filename,
|
|
textEncoding: this.mail.textEncoding,
|
|
disableUrlAccess: this.mail.disableUrlAccess,
|
|
disableFileAccess: this.mail.disableFileAccess,
|
|
normalizeHeaderKey: this.mail.normalizeHeaderKey,
|
|
newline: this.mail.newline
|
|
});
|
|
}
|
|
if (element.headers) {
|
|
node.addHeader(element.headers);
|
|
}
|
|
if (element.cid) {
|
|
node.setHeader("Content-Id", "<" + element.cid.replace(/[<>]/g, "") + ">");
|
|
}
|
|
if (element.contentTransferEncoding) {
|
|
node.setHeader("Content-Transfer-Encoding", element.contentTransferEncoding);
|
|
} else if (this.mail.encoding && /^text\//i.test(element.contentType)) {
|
|
node.setHeader("Content-Transfer-Encoding", this.mail.encoding);
|
|
}
|
|
if (!/^text\//i.test(element.contentType) || element.contentDisposition) {
|
|
node.setHeader("Content-Disposition", element.contentDisposition || (element.cid && /^image\//i.test(element.contentType) ? "inline" : "attachment"));
|
|
}
|
|
if (typeof element.content === "string" && !["utf8", "usascii", "ascii"].includes(encoding)) {
|
|
element.content = Buffer.from(element.content, encoding);
|
|
}
|
|
if (element.raw) {
|
|
node.setRaw(element.raw);
|
|
} else {
|
|
node.setContent(element.content);
|
|
}
|
|
return node;
|
|
}
|
|
_processDataUrl(element) {
|
|
let parsedDataUri;
|
|
if ((element.path || element.href).match(/^data:/)) {
|
|
parsedDataUri = parseDataURI(element.path || element.href);
|
|
}
|
|
if (!parsedDataUri) {
|
|
return element;
|
|
}
|
|
element.content = parsedDataUri.data;
|
|
element.contentType = element.contentType || parsedDataUri.contentType;
|
|
if ("path" in element) {
|
|
element.path = false;
|
|
}
|
|
if ("href" in element) {
|
|
element.href = false;
|
|
}
|
|
return element;
|
|
}
|
|
}
|
|
module.exports = MailComposer;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/dkim/message-parser.js
|
|
var require_message_parser = __commonJS((exports, module) => {
|
|
var Transform = __require("stream").Transform;
|
|
|
|
class MessageParser extends Transform {
|
|
constructor(options) {
|
|
super(options);
|
|
this.lastBytes = Buffer.alloc(4);
|
|
this.headersParsed = false;
|
|
this.headerBytes = 0;
|
|
this.headerChunks = [];
|
|
this.rawHeaders = false;
|
|
this.bodySize = 0;
|
|
}
|
|
updateLastBytes(data) {
|
|
let lblen = this.lastBytes.length;
|
|
let nblen = Math.min(data.length, lblen);
|
|
for (let i = 0, len = lblen - nblen;i < len; i++) {
|
|
this.lastBytes[i] = this.lastBytes[i + nblen];
|
|
}
|
|
for (let i = 1;i <= nblen; i++) {
|
|
this.lastBytes[lblen - i] = data[data.length - i];
|
|
}
|
|
}
|
|
checkHeaders(data) {
|
|
if (this.headersParsed) {
|
|
return true;
|
|
}
|
|
let lblen = this.lastBytes.length;
|
|
let headerPos = 0;
|
|
this.curLinePos = 0;
|
|
for (let i = 0, len = this.lastBytes.length + data.length;i < len; i++) {
|
|
let chr;
|
|
if (i < lblen) {
|
|
chr = this.lastBytes[i];
|
|
} else {
|
|
chr = data[i - lblen];
|
|
}
|
|
if (chr === 10 && i) {
|
|
let pr1 = i - 1 < lblen ? this.lastBytes[i - 1] : data[i - 1 - lblen];
|
|
let pr2 = i > 1 ? i - 2 < lblen ? this.lastBytes[i - 2] : data[i - 2 - lblen] : false;
|
|
if (pr1 === 10) {
|
|
this.headersParsed = true;
|
|
headerPos = i - lblen + 1;
|
|
this.headerBytes += headerPos;
|
|
break;
|
|
} else if (pr1 === 13 && pr2 === 10) {
|
|
this.headersParsed = true;
|
|
headerPos = i - lblen + 1;
|
|
this.headerBytes += headerPos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (this.headersParsed) {
|
|
this.headerChunks.push(data.slice(0, headerPos));
|
|
this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
|
|
this.headerChunks = null;
|
|
this.emit("headers", this.parseHeaders());
|
|
if (data.length - 1 > headerPos) {
|
|
let chunk = data.slice(headerPos);
|
|
this.bodySize += chunk.length;
|
|
setImmediate(() => this.push(chunk));
|
|
}
|
|
return false;
|
|
} else {
|
|
this.headerBytes += data.length;
|
|
this.headerChunks.push(data);
|
|
}
|
|
this.updateLastBytes(data);
|
|
return false;
|
|
}
|
|
_transform(chunk, encoding, callback) {
|
|
if (!chunk || !chunk.length) {
|
|
return callback();
|
|
}
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
}
|
|
let headersFound;
|
|
try {
|
|
headersFound = this.checkHeaders(chunk);
|
|
} catch (E) {
|
|
return callback(E);
|
|
}
|
|
if (headersFound) {
|
|
this.bodySize += chunk.length;
|
|
this.push(chunk);
|
|
}
|
|
setImmediate(callback);
|
|
}
|
|
_flush(callback) {
|
|
if (this.headerChunks) {
|
|
let chunk = Buffer.concat(this.headerChunks, this.headerBytes);
|
|
this.bodySize += chunk.length;
|
|
this.push(chunk);
|
|
this.headerChunks = null;
|
|
}
|
|
callback();
|
|
}
|
|
parseHeaders() {
|
|
let lines = (this.rawHeaders || "").toString().split(/\r?\n/);
|
|
for (let i = lines.length - 1;i > 0; i--) {
|
|
if (/^\s/.test(lines[i])) {
|
|
lines[i - 1] += "\n" + lines[i];
|
|
lines.splice(i, 1);
|
|
}
|
|
}
|
|
return lines.filter((line) => line.trim()).map((line) => ({
|
|
key: line.substr(0, line.indexOf(":")).trim().toLowerCase(),
|
|
line
|
|
}));
|
|
}
|
|
}
|
|
module.exports = MessageParser;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/dkim/relaxed-body.js
|
|
var require_relaxed_body = __commonJS((exports, module) => {
|
|
var Transform = __require("stream").Transform;
|
|
var crypto2 = __require("crypto");
|
|
|
|
class RelaxedBody extends Transform {
|
|
constructor(options) {
|
|
super();
|
|
options = options || {};
|
|
this.chunkBuffer = [];
|
|
this.chunkBufferLen = 0;
|
|
this.bodyHash = crypto2.createHash(options.hashAlgo || "sha1");
|
|
this.remainder = "";
|
|
this.byteLength = 0;
|
|
this.debug = options.debug;
|
|
this._debugBody = options.debug ? [] : false;
|
|
}
|
|
updateHash(chunk) {
|
|
let bodyStr;
|
|
let nextRemainder = "";
|
|
let state = "file";
|
|
for (let i = chunk.length - 1;i >= 0; i--) {
|
|
let c = chunk[i];
|
|
if (state === "file" && (c === 10 || c === 13)) {
|
|
} else if (state === "file" && (c === 9 || c === 32)) {
|
|
state = "line";
|
|
} else if (state === "line" && (c === 9 || c === 32)) {
|
|
} else if (state === "file" || state === "line") {
|
|
state = "body";
|
|
if (i === chunk.length - 1) {
|
|
break;
|
|
}
|
|
}
|
|
if (i === 0) {
|
|
if (state === "file" && (!this.remainder || /[\r\n]$/.test(this.remainder)) || state === "line" && (!this.remainder || /[ \t]$/.test(this.remainder))) {
|
|
this.remainder += chunk.toString("binary");
|
|
return;
|
|
} else if (state === "line" || state === "file") {
|
|
nextRemainder = chunk.toString("binary");
|
|
chunk = false;
|
|
break;
|
|
}
|
|
}
|
|
if (state !== "body") {
|
|
continue;
|
|
}
|
|
nextRemainder = chunk.slice(i + 1).toString("binary");
|
|
chunk = chunk.slice(0, i + 1);
|
|
break;
|
|
}
|
|
let needsFixing = !!this.remainder;
|
|
if (chunk && !needsFixing) {
|
|
for (let i = 0, len = chunk.length;i < len; i++) {
|
|
if (i && chunk[i] === 10 && chunk[i - 1] !== 13) {
|
|
needsFixing = true;
|
|
break;
|
|
} else if (i && chunk[i] === 13 && chunk[i - 1] === 32) {
|
|
needsFixing = true;
|
|
break;
|
|
} else if (i && chunk[i] === 32 && chunk[i - 1] === 32) {
|
|
needsFixing = true;
|
|
break;
|
|
} else if (chunk[i] === 9) {
|
|
needsFixing = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (needsFixing) {
|
|
bodyStr = this.remainder + (chunk ? chunk.toString("binary") : "");
|
|
this.remainder = nextRemainder;
|
|
bodyStr = bodyStr.replace(/\r?\n/g, "\n").replace(/[ \t]*$/gm, "").replace(/[ \t]+/gm, " ").replace(/\n/g, "\r\n");
|
|
chunk = Buffer.from(bodyStr, "binary");
|
|
} else if (nextRemainder) {
|
|
this.remainder = nextRemainder;
|
|
}
|
|
if (this.debug) {
|
|
this._debugBody.push(chunk);
|
|
}
|
|
this.bodyHash.update(chunk);
|
|
}
|
|
_transform(chunk, encoding, callback) {
|
|
if (!chunk || !chunk.length) {
|
|
return callback();
|
|
}
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
}
|
|
this.updateHash(chunk);
|
|
this.byteLength += chunk.length;
|
|
this.push(chunk);
|
|
callback();
|
|
}
|
|
_flush(callback) {
|
|
if (/[\r\n]$/.test(this.remainder) && this.byteLength > 2) {
|
|
this.bodyHash.update(Buffer.from("\r\n"));
|
|
}
|
|
if (!this.byteLength) {
|
|
this.push(Buffer.from("\r\n"));
|
|
}
|
|
this.emit("hash", this.bodyHash.digest("base64"), this.debug ? Buffer.concat(this._debugBody) : false);
|
|
callback();
|
|
}
|
|
}
|
|
module.exports = RelaxedBody;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/dkim/sign.js
|
|
var require_sign = __commonJS((exports, module) => {
|
|
var punycode = require_punycode();
|
|
var mimeFuncs = require_mime_funcs();
|
|
var crypto2 = __require("crypto");
|
|
module.exports = (headers, hashAlgo, bodyHash, options) => {
|
|
options = options || {};
|
|
let defaultFieldNames = "From:Sender:Reply-To:Subject:Date:Message-ID:To:" + "Cc:MIME-Version:Content-Type:Content-Transfer-Encoding:Content-ID:" + "Content-Description:Resent-Date:Resent-From:Resent-Sender:" + "Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:" + "List-Id:List-Help:List-Unsubscribe:List-Subscribe:List-Post:" + "List-Owner:List-Archive";
|
|
let fieldNames = options.headerFieldNames || defaultFieldNames;
|
|
let canonicalizedHeaderData = relaxedHeaders(headers, fieldNames, options.skipFields);
|
|
let dkimHeader = generateDKIMHeader(options.domainName, options.keySelector, canonicalizedHeaderData.fieldNames, hashAlgo, bodyHash);
|
|
let signer, signature;
|
|
canonicalizedHeaderData.headers += "dkim-signature:" + relaxedHeaderLine(dkimHeader);
|
|
signer = crypto2.createSign(("rsa-" + hashAlgo).toUpperCase());
|
|
signer.update(canonicalizedHeaderData.headers);
|
|
try {
|
|
signature = signer.sign(options.privateKey, "base64");
|
|
} catch (E) {
|
|
return false;
|
|
}
|
|
return dkimHeader + signature.replace(/(^.{73}|.{75}(?!\r?\n|\r))/g, "$&\r\n ").trim();
|
|
};
|
|
module.exports.relaxedHeaders = relaxedHeaders;
|
|
function generateDKIMHeader(domainName, keySelector, fieldNames, hashAlgo, bodyHash) {
|
|
let dkim = [
|
|
"v=1",
|
|
"a=rsa-" + hashAlgo,
|
|
"c=relaxed/relaxed",
|
|
"d=" + punycode.toASCII(domainName),
|
|
"q=dns/txt",
|
|
"s=" + keySelector,
|
|
"bh=" + bodyHash,
|
|
"h=" + fieldNames
|
|
].join("; ");
|
|
return mimeFuncs.foldLines("DKIM-Signature: " + dkim, 76) + ";\r\n b=";
|
|
}
|
|
function relaxedHeaders(headers, fieldNames, skipFields) {
|
|
let includedFields = new Set;
|
|
let skip = new Set;
|
|
let headerFields = new Map;
|
|
(skipFields || "").toLowerCase().split(":").forEach((field) => {
|
|
skip.add(field.trim());
|
|
});
|
|
(fieldNames || "").toLowerCase().split(":").filter((field) => !skip.has(field.trim())).forEach((field) => {
|
|
includedFields.add(field.trim());
|
|
});
|
|
for (let i = headers.length - 1;i >= 0; i--) {
|
|
let line = headers[i];
|
|
if (includedFields.has(line.key) && !headerFields.has(line.key)) {
|
|
headerFields.set(line.key, relaxedHeaderLine(line.line));
|
|
}
|
|
}
|
|
let headersList = [];
|
|
let fields = [];
|
|
includedFields.forEach((field) => {
|
|
if (headerFields.has(field)) {
|
|
fields.push(field);
|
|
headersList.push(field + ":" + headerFields.get(field));
|
|
}
|
|
});
|
|
return {
|
|
headers: headersList.join("\r\n") + "\r\n",
|
|
fieldNames: fields.join(":")
|
|
};
|
|
}
|
|
function relaxedHeaderLine(line) {
|
|
return line.substr(line.indexOf(":") + 1).replace(/\r?\n/g, "").replace(/\s+/g, " ").trim();
|
|
}
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/dkim/index.js
|
|
var require_dkim = __commonJS((exports, module) => {
|
|
var MessageParser = require_message_parser();
|
|
var RelaxedBody = require_relaxed_body();
|
|
var sign = require_sign();
|
|
var PassThrough = __require("stream").PassThrough;
|
|
var fs15 = __require("fs");
|
|
var path11 = __require("path");
|
|
var crypto2 = __require("crypto");
|
|
var DKIM_ALGO = "sha256";
|
|
var MAX_MESSAGE_SIZE = 128 * 1024;
|
|
|
|
class DKIMSigner {
|
|
constructor(options, keys, input, output) {
|
|
this.options = options || {};
|
|
this.keys = keys;
|
|
this.cacheTreshold = Number(this.options.cacheTreshold) || MAX_MESSAGE_SIZE;
|
|
this.hashAlgo = this.options.hashAlgo || DKIM_ALGO;
|
|
this.cacheDir = this.options.cacheDir || false;
|
|
this.chunks = [];
|
|
this.chunklen = 0;
|
|
this.readPos = 0;
|
|
this.cachePath = this.cacheDir ? path11.join(this.cacheDir, "message." + Date.now() + "-" + crypto2.randomBytes(14).toString("hex")) : false;
|
|
this.cache = false;
|
|
this.headers = false;
|
|
this.bodyHash = false;
|
|
this.parser = false;
|
|
this.relaxedBody = false;
|
|
this.input = input;
|
|
this.output = output;
|
|
this.output.usingCache = false;
|
|
this.hasErrored = false;
|
|
this.input.on("error", (err) => {
|
|
this.hasErrored = true;
|
|
this.cleanup();
|
|
output.emit("error", err);
|
|
});
|
|
}
|
|
cleanup() {
|
|
if (!this.cache || !this.cachePath) {
|
|
return;
|
|
}
|
|
fs15.unlink(this.cachePath, () => false);
|
|
}
|
|
createReadCache() {
|
|
this.cache = fs15.createReadStream(this.cachePath);
|
|
this.cache.once("error", (err) => {
|
|
this.cleanup();
|
|
this.output.emit("error", err);
|
|
});
|
|
this.cache.once("close", () => {
|
|
this.cleanup();
|
|
});
|
|
this.cache.pipe(this.output);
|
|
}
|
|
sendNextChunk() {
|
|
if (this.hasErrored) {
|
|
return;
|
|
}
|
|
if (this.readPos >= this.chunks.length) {
|
|
if (!this.cache) {
|
|
return this.output.end();
|
|
}
|
|
return this.createReadCache();
|
|
}
|
|
let chunk = this.chunks[this.readPos++];
|
|
if (this.output.write(chunk) === false) {
|
|
return this.output.once("drain", () => {
|
|
this.sendNextChunk();
|
|
});
|
|
}
|
|
setImmediate(() => this.sendNextChunk());
|
|
}
|
|
sendSignedOutput() {
|
|
let keyPos = 0;
|
|
let signNextKey = () => {
|
|
if (keyPos >= this.keys.length) {
|
|
this.output.write(this.parser.rawHeaders);
|
|
return setImmediate(() => this.sendNextChunk());
|
|
}
|
|
let key = this.keys[keyPos++];
|
|
let dkimField = sign(this.headers, this.hashAlgo, this.bodyHash, {
|
|
domainName: key.domainName,
|
|
keySelector: key.keySelector,
|
|
privateKey: key.privateKey,
|
|
headerFieldNames: this.options.headerFieldNames,
|
|
skipFields: this.options.skipFields
|
|
});
|
|
if (dkimField) {
|
|
this.output.write(Buffer.from(dkimField + "\r\n"));
|
|
}
|
|
return setImmediate(signNextKey);
|
|
};
|
|
if (this.bodyHash && this.headers) {
|
|
return signNextKey();
|
|
}
|
|
this.output.write(this.parser.rawHeaders);
|
|
this.sendNextChunk();
|
|
}
|
|
createWriteCache() {
|
|
this.output.usingCache = true;
|
|
this.cache = fs15.createWriteStream(this.cachePath);
|
|
this.cache.once("error", (err) => {
|
|
this.cleanup();
|
|
this.relaxedBody.unpipe(this.cache);
|
|
this.relaxedBody.on("readable", () => {
|
|
while (this.relaxedBody.read() !== null) {
|
|
}
|
|
});
|
|
this.hasErrored = true;
|
|
this.output.emit("error", err);
|
|
});
|
|
this.cache.once("close", () => {
|
|
this.sendSignedOutput();
|
|
});
|
|
this.relaxedBody.removeAllListeners("readable");
|
|
this.relaxedBody.pipe(this.cache);
|
|
}
|
|
signStream() {
|
|
this.parser = new MessageParser;
|
|
this.relaxedBody = new RelaxedBody({
|
|
hashAlgo: this.hashAlgo
|
|
});
|
|
this.parser.on("headers", (value) => {
|
|
this.headers = value;
|
|
});
|
|
this.relaxedBody.on("hash", (value) => {
|
|
this.bodyHash = value;
|
|
});
|
|
this.relaxedBody.on("readable", () => {
|
|
let chunk;
|
|
if (this.cache) {
|
|
return;
|
|
}
|
|
while ((chunk = this.relaxedBody.read()) !== null) {
|
|
this.chunks.push(chunk);
|
|
this.chunklen += chunk.length;
|
|
if (this.chunklen >= this.cacheTreshold && this.cachePath) {
|
|
return this.createWriteCache();
|
|
}
|
|
}
|
|
});
|
|
this.relaxedBody.on("end", () => {
|
|
if (this.cache) {
|
|
return;
|
|
}
|
|
this.sendSignedOutput();
|
|
});
|
|
this.parser.pipe(this.relaxedBody);
|
|
setImmediate(() => this.input.pipe(this.parser));
|
|
}
|
|
}
|
|
|
|
class DKIM {
|
|
constructor(options) {
|
|
this.options = options || {};
|
|
this.keys = [].concat(this.options.keys || {
|
|
domainName: options.domainName,
|
|
keySelector: options.keySelector,
|
|
privateKey: options.privateKey
|
|
});
|
|
}
|
|
sign(input, extraOptions) {
|
|
let output = new PassThrough;
|
|
let inputStream = input;
|
|
let writeValue = false;
|
|
if (Buffer.isBuffer(input)) {
|
|
writeValue = input;
|
|
inputStream = new PassThrough;
|
|
} else if (typeof input === "string") {
|
|
writeValue = Buffer.from(input);
|
|
inputStream = new PassThrough;
|
|
}
|
|
let options = this.options;
|
|
if (extraOptions && Object.keys(extraOptions).length) {
|
|
options = {};
|
|
Object.keys(this.options || {}).forEach((key) => {
|
|
options[key] = this.options[key];
|
|
});
|
|
Object.keys(extraOptions || {}).forEach((key) => {
|
|
if (!(key in options)) {
|
|
options[key] = extraOptions[key];
|
|
}
|
|
});
|
|
}
|
|
let signer = new DKIMSigner(options, this.keys, inputStream, output);
|
|
setImmediate(() => {
|
|
signer.signStream();
|
|
if (writeValue) {
|
|
setImmediate(() => {
|
|
inputStream.end(writeValue);
|
|
});
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
}
|
|
module.exports = DKIM;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-connection/http-proxy-client.js
|
|
var require_http_proxy_client = __commonJS((exports, module) => {
|
|
var net = __require("net");
|
|
var tls = __require("tls");
|
|
var urllib = __require("url");
|
|
function httpProxyClient(proxyUrl, destinationPort, destinationHost, callback) {
|
|
let proxy = urllib.parse(proxyUrl);
|
|
let options;
|
|
let connect;
|
|
let socket;
|
|
options = {
|
|
host: proxy.hostname,
|
|
port: Number(proxy.port) ? Number(proxy.port) : proxy.protocol === "https:" ? 443 : 80
|
|
};
|
|
if (proxy.protocol === "https:") {
|
|
options.rejectUnauthorized = false;
|
|
connect = tls.connect.bind(tls);
|
|
} else {
|
|
connect = net.connect.bind(net);
|
|
}
|
|
let finished = false;
|
|
let tempSocketErr = (err) => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
try {
|
|
socket.destroy();
|
|
} catch (E) {
|
|
}
|
|
callback(err);
|
|
};
|
|
let timeoutErr = () => {
|
|
let err = new Error("Proxy socket timed out");
|
|
err.code = "ETIMEDOUT";
|
|
tempSocketErr(err);
|
|
};
|
|
socket = connect(options, () => {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
let reqHeaders = {
|
|
Host: destinationHost + ":" + destinationPort,
|
|
Connection: "close"
|
|
};
|
|
if (proxy.auth) {
|
|
reqHeaders["Proxy-Authorization"] = "Basic " + Buffer.from(proxy.auth).toString("base64");
|
|
}
|
|
socket.write("CONNECT " + destinationHost + ":" + destinationPort + " HTTP/1.1\r\n" + Object.keys(reqHeaders).map((key) => key + ": " + reqHeaders[key]).join("\r\n") + "\r\n\r\n");
|
|
let headers = "";
|
|
let onSocketData = (chunk) => {
|
|
let match;
|
|
let remainder;
|
|
if (finished) {
|
|
return;
|
|
}
|
|
headers += chunk.toString("binary");
|
|
if (match = headers.match(/\r\n\r\n/)) {
|
|
socket.removeListener("data", onSocketData);
|
|
remainder = headers.substr(match.index + match[0].length);
|
|
headers = headers.substr(0, match.index);
|
|
if (remainder) {
|
|
socket.unshift(Buffer.from(remainder, "binary"));
|
|
}
|
|
finished = true;
|
|
match = headers.match(/^HTTP\/\d+\.\d+ (\d+)/i);
|
|
if (!match || (match[1] || "").charAt(0) !== "2") {
|
|
try {
|
|
socket.destroy();
|
|
} catch (E) {
|
|
}
|
|
return callback(new Error("Invalid response from proxy" + (match && ": " + match[1] || "")));
|
|
}
|
|
socket.removeListener("error", tempSocketErr);
|
|
socket.removeListener("timeout", timeoutErr);
|
|
socket.setTimeout(0);
|
|
return callback(null, socket);
|
|
}
|
|
};
|
|
socket.on("data", onSocketData);
|
|
});
|
|
socket.setTimeout(httpProxyClient.timeout || 30 * 1000);
|
|
socket.on("timeout", timeoutErr);
|
|
socket.once("error", tempSocketErr);
|
|
}
|
|
module.exports = httpProxyClient;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mailer/mail-message.js
|
|
var require_mail_message = __commonJS((exports, module) => {
|
|
var shared = require_shared();
|
|
var MimeNode = require_mime_node();
|
|
var mimeFuncs = require_mime_funcs();
|
|
|
|
class MailMessage {
|
|
constructor(mailer, data) {
|
|
this.mailer = mailer;
|
|
this.data = {};
|
|
this.message = null;
|
|
data = data || {};
|
|
let options = mailer.options || {};
|
|
let defaults = mailer._defaults || {};
|
|
Object.keys(data).forEach((key) => {
|
|
this.data[key] = data[key];
|
|
});
|
|
this.data.headers = this.data.headers || {};
|
|
Object.keys(defaults).forEach((key) => {
|
|
if (!(key in this.data)) {
|
|
this.data[key] = defaults[key];
|
|
} else if (key === "headers") {
|
|
Object.keys(defaults.headers).forEach((key2) => {
|
|
if (!(key2 in this.data.headers)) {
|
|
this.data.headers[key2] = defaults.headers[key2];
|
|
}
|
|
});
|
|
}
|
|
});
|
|
["disableFileAccess", "disableUrlAccess", "normalizeHeaderKey"].forEach((key) => {
|
|
if (key in options) {
|
|
this.data[key] = options[key];
|
|
}
|
|
});
|
|
}
|
|
resolveContent(...args) {
|
|
return shared.resolveContent(...args);
|
|
}
|
|
resolveAll(callback) {
|
|
let keys = [
|
|
[this.data, "html"],
|
|
[this.data, "text"],
|
|
[this.data, "watchHtml"],
|
|
[this.data, "amp"],
|
|
[this.data, "icalEvent"]
|
|
];
|
|
if (this.data.alternatives && this.data.alternatives.length) {
|
|
this.data.alternatives.forEach((alternative, i) => {
|
|
keys.push([this.data.alternatives, i]);
|
|
});
|
|
}
|
|
if (this.data.attachments && this.data.attachments.length) {
|
|
this.data.attachments.forEach((attachment, i) => {
|
|
if (!attachment.filename) {
|
|
attachment.filename = (attachment.path || attachment.href || "").split("/").pop().split("?").shift() || "attachment-" + (i + 1);
|
|
if (attachment.filename.indexOf(".") < 0) {
|
|
attachment.filename += "." + mimeFuncs.detectExtension(attachment.contentType);
|
|
}
|
|
}
|
|
if (!attachment.contentType) {
|
|
attachment.contentType = mimeFuncs.detectMimeType(attachment.filename || attachment.path || attachment.href || "bin");
|
|
}
|
|
keys.push([this.data.attachments, i]);
|
|
});
|
|
}
|
|
let mimeNode = new MimeNode;
|
|
let addressKeys = ["from", "to", "cc", "bcc", "sender", "replyTo"];
|
|
addressKeys.forEach((address) => {
|
|
let value;
|
|
if (this.message) {
|
|
value = [].concat(mimeNode._parseAddresses(this.message.getHeader(address === "replyTo" ? "reply-to" : address)) || []);
|
|
} else if (this.data[address]) {
|
|
value = [].concat(mimeNode._parseAddresses(this.data[address]) || []);
|
|
}
|
|
if (value && value.length) {
|
|
this.data[address] = value;
|
|
} else if (address in this.data) {
|
|
this.data[address] = null;
|
|
}
|
|
});
|
|
let singleKeys = ["from", "sender"];
|
|
singleKeys.forEach((address) => {
|
|
if (this.data[address]) {
|
|
this.data[address] = this.data[address].shift();
|
|
}
|
|
});
|
|
let pos = 0;
|
|
let resolveNext = () => {
|
|
if (pos >= keys.length) {
|
|
return callback(null, this.data);
|
|
}
|
|
let args = keys[pos++];
|
|
if (!args[0] || !args[0][args[1]]) {
|
|
return resolveNext();
|
|
}
|
|
shared.resolveContent(...args, (err, value) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let node = {
|
|
content: value
|
|
};
|
|
if (args[0][args[1]] && typeof args[0][args[1]] === "object" && !Buffer.isBuffer(args[0][args[1]])) {
|
|
Object.keys(args[0][args[1]]).forEach((key) => {
|
|
if (!(key in node) && !["content", "path", "href", "raw"].includes(key)) {
|
|
node[key] = args[0][args[1]][key];
|
|
}
|
|
});
|
|
}
|
|
args[0][args[1]] = node;
|
|
resolveNext();
|
|
});
|
|
};
|
|
setImmediate(() => resolveNext());
|
|
}
|
|
normalize(callback) {
|
|
let envelope = this.data.envelope || this.message.getEnvelope();
|
|
let messageId = this.message.messageId();
|
|
this.resolveAll((err, data) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
data.envelope = envelope;
|
|
data.messageId = messageId;
|
|
["html", "text", "watchHtml", "amp"].forEach((key) => {
|
|
if (data[key] && data[key].content) {
|
|
if (typeof data[key].content === "string") {
|
|
data[key] = data[key].content;
|
|
} else if (Buffer.isBuffer(data[key].content)) {
|
|
data[key] = data[key].content.toString();
|
|
}
|
|
}
|
|
});
|
|
if (data.icalEvent && Buffer.isBuffer(data.icalEvent.content)) {
|
|
data.icalEvent.content = data.icalEvent.content.toString("base64");
|
|
data.icalEvent.encoding = "base64";
|
|
}
|
|
if (data.alternatives && data.alternatives.length) {
|
|
data.alternatives.forEach((alternative) => {
|
|
if (alternative && alternative.content && Buffer.isBuffer(alternative.content)) {
|
|
alternative.content = alternative.content.toString("base64");
|
|
alternative.encoding = "base64";
|
|
}
|
|
});
|
|
}
|
|
if (data.attachments && data.attachments.length) {
|
|
data.attachments.forEach((attachment) => {
|
|
if (attachment && attachment.content && Buffer.isBuffer(attachment.content)) {
|
|
attachment.content = attachment.content.toString("base64");
|
|
attachment.encoding = "base64";
|
|
}
|
|
});
|
|
}
|
|
data.normalizedHeaders = {};
|
|
Object.keys(data.headers || {}).forEach((key) => {
|
|
let value = [].concat(data.headers[key] || []).shift();
|
|
value = value && value.value || value;
|
|
if (value) {
|
|
if (["references", "in-reply-to", "message-id", "content-id"].includes(key)) {
|
|
value = this.message._encodeHeaderValue(key, value);
|
|
}
|
|
data.normalizedHeaders[key] = value;
|
|
}
|
|
});
|
|
if (data.list && typeof data.list === "object") {
|
|
let listHeaders = this._getListHeaders(data.list);
|
|
listHeaders.forEach((entry) => {
|
|
data.normalizedHeaders[entry.key] = entry.value.map((val) => val && val.value || val).join(", ");
|
|
});
|
|
}
|
|
if (data.references) {
|
|
data.normalizedHeaders.references = this.message._encodeHeaderValue("references", data.references);
|
|
}
|
|
if (data.inReplyTo) {
|
|
data.normalizedHeaders["in-reply-to"] = this.message._encodeHeaderValue("in-reply-to", data.inReplyTo);
|
|
}
|
|
return callback(null, data);
|
|
});
|
|
}
|
|
setMailerHeader() {
|
|
if (!this.message || !this.data.xMailer) {
|
|
return;
|
|
}
|
|
this.message.setHeader("X-Mailer", this.data.xMailer);
|
|
}
|
|
setPriorityHeaders() {
|
|
if (!this.message || !this.data.priority) {
|
|
return;
|
|
}
|
|
switch ((this.data.priority || "").toString().toLowerCase()) {
|
|
case "high":
|
|
this.message.setHeader("X-Priority", "1 (Highest)");
|
|
this.message.setHeader("X-MSMail-Priority", "High");
|
|
this.message.setHeader("Importance", "High");
|
|
break;
|
|
case "low":
|
|
this.message.setHeader("X-Priority", "5 (Lowest)");
|
|
this.message.setHeader("X-MSMail-Priority", "Low");
|
|
this.message.setHeader("Importance", "Low");
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
setListHeaders() {
|
|
if (!this.message || !this.data.list || typeof this.data.list !== "object") {
|
|
return;
|
|
}
|
|
if (this.data.list && typeof this.data.list === "object") {
|
|
this._getListHeaders(this.data.list).forEach((listHeader) => {
|
|
listHeader.value.forEach((value) => {
|
|
this.message.addHeader(listHeader.key, value);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
_getListHeaders(listData) {
|
|
return Object.keys(listData).map((key) => ({
|
|
key: "list-" + key.toLowerCase().trim(),
|
|
value: [].concat(listData[key] || []).map((value) => ({
|
|
prepared: true,
|
|
foldLines: true,
|
|
value: [].concat(value || []).map((value2) => {
|
|
if (typeof value2 === "string") {
|
|
value2 = {
|
|
url: value2
|
|
};
|
|
}
|
|
if (value2 && value2.url) {
|
|
if (key.toLowerCase().trim() === "id") {
|
|
let comment2 = value2.comment || "";
|
|
if (mimeFuncs.isPlainText(comment2)) {
|
|
comment2 = '"' + comment2 + '"';
|
|
} else {
|
|
comment2 = mimeFuncs.encodeWord(comment2);
|
|
}
|
|
return (value2.comment ? comment2 + " " : "") + this._formatListUrl(value2.url).replace(/^<[^:]+\/{,2}/, "");
|
|
}
|
|
let comment = value2.comment || "";
|
|
if (!mimeFuncs.isPlainText(comment)) {
|
|
comment = mimeFuncs.encodeWord(comment);
|
|
}
|
|
return this._formatListUrl(value2.url) + (value2.comment ? " (" + comment + ")" : "");
|
|
}
|
|
return "";
|
|
}).filter((value2) => value2).join(", ")
|
|
}))
|
|
}));
|
|
}
|
|
_formatListUrl(url) {
|
|
url = url.replace(/[\s<]+|[\s>]+/g, "");
|
|
if (/^(https?|mailto|ftp):/.test(url)) {
|
|
return "<" + url + ">";
|
|
}
|
|
if (/^[^@]+@[^@]+$/.test(url)) {
|
|
return "<mailto:" + url + ">";
|
|
}
|
|
return "<http://" + url + ">";
|
|
}
|
|
}
|
|
module.exports = MailMessage;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/mailer/index.js
|
|
var require_mailer = __commonJS((exports, module) => {
|
|
var EventEmitter = __require("events");
|
|
var shared = require_shared();
|
|
var mimeTypes = require_mime_types();
|
|
var MailComposer = require_mail_composer();
|
|
var DKIM = require_dkim();
|
|
var httpProxyClient = require_http_proxy_client();
|
|
var util = __require("util");
|
|
var urllib = __require("url");
|
|
var packageData = require_package2();
|
|
var MailMessage = require_mail_message();
|
|
var net = __require("net");
|
|
var dns = __require("dns");
|
|
var crypto2 = __require("crypto");
|
|
|
|
class Mail extends EventEmitter {
|
|
constructor(transporter, options, defaults) {
|
|
super();
|
|
this.options = options || {};
|
|
this._defaults = defaults || {};
|
|
this._defaultPlugins = {
|
|
compile: [(...args) => this._convertDataImages(...args)],
|
|
stream: []
|
|
};
|
|
this._userPlugins = {
|
|
compile: [],
|
|
stream: []
|
|
};
|
|
this.meta = new Map;
|
|
this.dkim = this.options.dkim ? new DKIM(this.options.dkim) : false;
|
|
this.transporter = transporter;
|
|
this.transporter.mailer = this;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "mail"
|
|
});
|
|
this.logger.debug({
|
|
tnx: "create"
|
|
}, "Creating transport: %s", this.getVersionString());
|
|
if (typeof this.transporter.on === "function") {
|
|
this.transporter.on("log", (log) => {
|
|
this.logger.debug({
|
|
tnx: "transport"
|
|
}, "%s: %s", log.type, log.message);
|
|
});
|
|
this.transporter.on("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "transport"
|
|
}, "Transport Error: %s", err.message);
|
|
this.emit("error", err);
|
|
});
|
|
this.transporter.on("idle", (...args) => {
|
|
this.emit("idle", ...args);
|
|
});
|
|
}
|
|
["close", "isIdle", "verify"].forEach((method) => {
|
|
this[method] = (...args) => {
|
|
if (typeof this.transporter[method] === "function") {
|
|
if (method === "verify" && typeof this.getSocket === "function") {
|
|
this.transporter.getSocket = this.getSocket;
|
|
this.getSocket = false;
|
|
}
|
|
return this.transporter[method](...args);
|
|
} else {
|
|
this.logger.warn({
|
|
tnx: "transport",
|
|
methodName: method
|
|
}, "Non existing method %s called for transport", method);
|
|
return false;
|
|
}
|
|
};
|
|
});
|
|
if (this.options.proxy && typeof this.options.proxy === "string") {
|
|
this.setupProxy(this.options.proxy);
|
|
}
|
|
}
|
|
use(step, plugin) {
|
|
step = (step || "").toString();
|
|
if (!this._userPlugins.hasOwnProperty(step)) {
|
|
this._userPlugins[step] = [plugin];
|
|
} else {
|
|
this._userPlugins[step].push(plugin);
|
|
}
|
|
return this;
|
|
}
|
|
sendMail(data, callback = null) {
|
|
let promise;
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
if (typeof this.getSocket === "function") {
|
|
this.transporter.getSocket = this.getSocket;
|
|
this.getSocket = false;
|
|
}
|
|
let mail = new MailMessage(this, data);
|
|
this.logger.debug({
|
|
tnx: "transport",
|
|
name: this.transporter.name,
|
|
version: this.transporter.version,
|
|
action: "send"
|
|
}, "Sending mail using %s/%s", this.transporter.name, this.transporter.version);
|
|
this._processPlugins("compile", mail, (err) => {
|
|
if (err) {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "plugin",
|
|
action: "compile"
|
|
}, "PluginCompile Error: %s", err.message);
|
|
return callback(err);
|
|
}
|
|
mail.message = new MailComposer(mail.data).compile();
|
|
mail.setMailerHeader();
|
|
mail.setPriorityHeaders();
|
|
mail.setListHeaders();
|
|
this._processPlugins("stream", mail, (err2) => {
|
|
if (err2) {
|
|
this.logger.error({
|
|
err: err2,
|
|
tnx: "plugin",
|
|
action: "stream"
|
|
}, "PluginStream Error: %s", err2.message);
|
|
return callback(err2);
|
|
}
|
|
if (mail.data.dkim || this.dkim) {
|
|
mail.message.processFunc((input) => {
|
|
let dkim = mail.data.dkim ? new DKIM(mail.data.dkim) : this.dkim;
|
|
this.logger.debug({
|
|
tnx: "DKIM",
|
|
messageId: mail.message.messageId(),
|
|
dkimDomains: dkim.keys.map((key) => key.keySelector + "." + key.domainName).join(", ")
|
|
}, "Signing outgoing message with %s keys", dkim.keys.length);
|
|
return dkim.sign(input, mail.data._dkim);
|
|
});
|
|
}
|
|
this.transporter.send(mail, (...args) => {
|
|
if (args[0]) {
|
|
this.logger.error({
|
|
err: args[0],
|
|
tnx: "transport",
|
|
action: "send"
|
|
}, "Send Error: %s", args[0].message);
|
|
}
|
|
callback(...args);
|
|
});
|
|
});
|
|
});
|
|
return promise;
|
|
}
|
|
getVersionString() {
|
|
return util.format("%s (%s; +%s; %s/%s)", packageData.name, packageData.version, packageData.homepage, this.transporter.name, this.transporter.version);
|
|
}
|
|
_processPlugins(step, mail, callback) {
|
|
step = (step || "").toString();
|
|
if (!this._userPlugins.hasOwnProperty(step)) {
|
|
return callback();
|
|
}
|
|
let userPlugins = this._userPlugins[step] || [];
|
|
let defaultPlugins = this._defaultPlugins[step] || [];
|
|
if (userPlugins.length) {
|
|
this.logger.debug({
|
|
tnx: "transaction",
|
|
pluginCount: userPlugins.length,
|
|
step
|
|
}, "Using %s plugins for %s", userPlugins.length, step);
|
|
}
|
|
if (userPlugins.length + defaultPlugins.length === 0) {
|
|
return callback();
|
|
}
|
|
let pos = 0;
|
|
let block = "default";
|
|
let processPlugins = () => {
|
|
let curplugins = block === "default" ? defaultPlugins : userPlugins;
|
|
if (pos >= curplugins.length) {
|
|
if (block === "default" && userPlugins.length) {
|
|
block = "user";
|
|
pos = 0;
|
|
curplugins = userPlugins;
|
|
} else {
|
|
return callback();
|
|
}
|
|
}
|
|
let plugin = curplugins[pos++];
|
|
plugin(mail, (err) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
processPlugins();
|
|
});
|
|
};
|
|
processPlugins();
|
|
}
|
|
setupProxy(proxyUrl) {
|
|
let proxy = urllib.parse(proxyUrl);
|
|
this.getSocket = (options, callback) => {
|
|
let protocol = proxy.protocol.replace(/:$/, "").toLowerCase();
|
|
if (this.meta.has("proxy_handler_" + protocol)) {
|
|
return this.meta.get("proxy_handler_" + protocol)(proxy, options, callback);
|
|
}
|
|
switch (protocol) {
|
|
case "http":
|
|
case "https":
|
|
httpProxyClient(proxy.href, options.port, options.host, (err, socket) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
return callback(null, {
|
|
connection: socket
|
|
});
|
|
});
|
|
return;
|
|
case "socks":
|
|
case "socks5":
|
|
case "socks4":
|
|
case "socks4a": {
|
|
if (!this.meta.has("proxy_socks_module")) {
|
|
return callback(new Error("Socks module not loaded"));
|
|
}
|
|
let connect = (ipaddress) => {
|
|
let proxyV2 = !!this.meta.get("proxy_socks_module").SocksClient;
|
|
let socksClient = proxyV2 ? this.meta.get("proxy_socks_module").SocksClient : this.meta.get("proxy_socks_module");
|
|
let proxyType = Number(proxy.protocol.replace(/\D/g, "")) || 5;
|
|
let connectionOpts = {
|
|
proxy: {
|
|
ipaddress,
|
|
port: Number(proxy.port),
|
|
type: proxyType
|
|
},
|
|
[proxyV2 ? "destination" : "target"]: {
|
|
host: options.host,
|
|
port: options.port
|
|
},
|
|
command: "connect"
|
|
};
|
|
if (proxy.auth) {
|
|
let username = decodeURIComponent(proxy.auth.split(":").shift());
|
|
let password = decodeURIComponent(proxy.auth.split(":").pop());
|
|
if (proxyV2) {
|
|
connectionOpts.proxy.userId = username;
|
|
connectionOpts.proxy.password = password;
|
|
} else if (proxyType === 4) {
|
|
connectionOpts.userid = username;
|
|
} else {
|
|
connectionOpts.authentication = {
|
|
username,
|
|
password
|
|
};
|
|
}
|
|
}
|
|
socksClient.createConnection(connectionOpts, (err, info) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
return callback(null, {
|
|
connection: info.socket || info
|
|
});
|
|
});
|
|
};
|
|
if (net.isIP(proxy.hostname)) {
|
|
return connect(proxy.hostname);
|
|
}
|
|
return dns.resolve(proxy.hostname, (err, address) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
connect(Array.isArray(address) ? address[0] : address);
|
|
});
|
|
}
|
|
}
|
|
callback(new Error("Unknown proxy configuration"));
|
|
};
|
|
}
|
|
_convertDataImages(mail, callback) {
|
|
if (!this.options.attachDataUrls && !mail.data.attachDataUrls || !mail.data.html) {
|
|
return callback();
|
|
}
|
|
mail.resolveContent(mail.data, "html", (err, html) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let cidCounter = 0;
|
|
html = (html || "").toString().replace(/(<img\b[^<>]{0,1024} src\s{0,20}=[\s"']{0,20})(data:([^;]+);[^"'>\s]+)/gi, (match, prefix, dataUri, mimeType) => {
|
|
let cid = crypto2.randomBytes(10).toString("hex") + "@localhost";
|
|
if (!mail.data.attachments) {
|
|
mail.data.attachments = [];
|
|
}
|
|
if (!Array.isArray(mail.data.attachments)) {
|
|
mail.data.attachments = [].concat(mail.data.attachments || []);
|
|
}
|
|
mail.data.attachments.push({
|
|
path: dataUri,
|
|
cid,
|
|
filename: "image-" + ++cidCounter + "." + mimeTypes.detectExtension(mimeType)
|
|
});
|
|
return prefix + "cid:" + cid;
|
|
});
|
|
mail.data.html = html;
|
|
callback();
|
|
});
|
|
}
|
|
set(key, value) {
|
|
return this.meta.set(key, value);
|
|
}
|
|
get(key) {
|
|
return this.meta.get(key);
|
|
}
|
|
}
|
|
module.exports = Mail;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-connection/data-stream.js
|
|
var require_data_stream = __commonJS((exports, module) => {
|
|
var stream = __require("stream");
|
|
var Transform = stream.Transform;
|
|
|
|
class DataStream extends Transform {
|
|
constructor(options) {
|
|
super(options);
|
|
this.options = options || {};
|
|
this._curLine = "";
|
|
this.inByteCount = 0;
|
|
this.outByteCount = 0;
|
|
this.lastByte = false;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
let i, len, lastPos = 0;
|
|
let buf;
|
|
if (!chunk || !chunk.length) {
|
|
return done();
|
|
}
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk);
|
|
}
|
|
this.inByteCount += chunk.length;
|
|
for (i = 0, len = chunk.length;i < len; i++) {
|
|
if (chunk[i] === 46) {
|
|
if (i && chunk[i - 1] === 10 || !i && (!this.lastByte || this.lastByte === 10)) {
|
|
buf = chunk.slice(lastPos, i + 1);
|
|
chunks.push(buf);
|
|
chunks.push(Buffer.from("."));
|
|
chunklen += buf.length + 1;
|
|
lastPos = i + 1;
|
|
}
|
|
} else if (chunk[i] === 10) {
|
|
if (i && chunk[i - 1] !== 13 || !i && this.lastByte !== 13) {
|
|
if (i > lastPos) {
|
|
buf = chunk.slice(lastPos, i);
|
|
chunks.push(buf);
|
|
chunklen += buf.length + 2;
|
|
} else {
|
|
chunklen += 2;
|
|
}
|
|
chunks.push(Buffer.from("\r\n"));
|
|
lastPos = i + 1;
|
|
}
|
|
}
|
|
}
|
|
if (chunklen) {
|
|
if (lastPos < chunk.length) {
|
|
buf = chunk.slice(lastPos);
|
|
chunks.push(buf);
|
|
chunklen += buf.length;
|
|
}
|
|
this.outByteCount += chunklen;
|
|
this.push(Buffer.concat(chunks, chunklen));
|
|
} else {
|
|
this.outByteCount += chunk.length;
|
|
this.push(chunk);
|
|
}
|
|
this.lastByte = chunk[chunk.length - 1];
|
|
done();
|
|
}
|
|
_flush(done) {
|
|
let buf;
|
|
if (this.lastByte === 10) {
|
|
buf = Buffer.from(".\r\n");
|
|
} else if (this.lastByte === 13) {
|
|
buf = Buffer.from("\n.\r\n");
|
|
} else {
|
|
buf = Buffer.from("\r\n.\r\n");
|
|
}
|
|
this.outByteCount += buf.length;
|
|
this.push(buf);
|
|
done();
|
|
}
|
|
}
|
|
module.exports = DataStream;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-connection/index.js
|
|
var require_smtp_connection = __commonJS((exports, module) => {
|
|
var packageInfo = require_package2();
|
|
var EventEmitter = __require("events").EventEmitter;
|
|
var net = __require("net");
|
|
var tls = __require("tls");
|
|
var os = __require("os");
|
|
var crypto2 = __require("crypto");
|
|
var DataStream = require_data_stream();
|
|
var PassThrough = __require("stream").PassThrough;
|
|
var shared = require_shared();
|
|
var CONNECTION_TIMEOUT = 2 * 60 * 1000;
|
|
var SOCKET_TIMEOUT = 10 * 60 * 1000;
|
|
var GREETING_TIMEOUT = 30 * 1000;
|
|
var DNS_TIMEOUT = 30 * 1000;
|
|
|
|
class SMTPConnection extends EventEmitter {
|
|
constructor(options) {
|
|
super(options);
|
|
this.id = crypto2.randomBytes(8).toString("base64").replace(/\W/g, "");
|
|
this.stage = "init";
|
|
this.options = options || {};
|
|
this.secureConnection = !!this.options.secure;
|
|
this.alreadySecured = !!this.options.secured;
|
|
this.port = Number(this.options.port) || (this.secureConnection ? 465 : 587);
|
|
this.host = this.options.host || "localhost";
|
|
this.servername = this.options.servername ? this.options.servername : !net.isIP(this.host) ? this.host : false;
|
|
this.allowInternalNetworkInterfaces = this.options.allowInternalNetworkInterfaces || false;
|
|
if (typeof this.options.secure === "undefined" && this.port === 465) {
|
|
this.secureConnection = true;
|
|
}
|
|
this.name = this.options.name || this._getHostname();
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "smtp-connection",
|
|
sid: this.id
|
|
});
|
|
this.customAuth = new Map;
|
|
Object.keys(this.options.customAuth || {}).forEach((key) => {
|
|
let mapKey = (key || "").toString().trim().toUpperCase();
|
|
if (!mapKey) {
|
|
return;
|
|
}
|
|
this.customAuth.set(mapKey, this.options.customAuth[key]);
|
|
});
|
|
this.version = packageInfo.version;
|
|
this.authenticated = false;
|
|
this.destroyed = false;
|
|
this.secure = !!this.secureConnection;
|
|
this._remainder = "";
|
|
this._responseQueue = [];
|
|
this.lastServerResponse = false;
|
|
this._socket = false;
|
|
this._supportedAuth = [];
|
|
this.allowsAuth = false;
|
|
this._envelope = false;
|
|
this._supportedExtensions = [];
|
|
this._maxAllowedSize = 0;
|
|
this._responseActions = [];
|
|
this._recipientQueue = [];
|
|
this._greetingTimeout = false;
|
|
this._connectionTimeout = false;
|
|
this._destroyed = false;
|
|
this._closing = false;
|
|
this._onSocketData = (chunk) => this._onData(chunk);
|
|
this._onSocketError = (error) => this._onError(error, "ESOCKET", false, "CONN");
|
|
this._onSocketClose = () => this._onClose();
|
|
this._onSocketEnd = () => this._onEnd();
|
|
this._onSocketTimeout = () => this._onTimeout();
|
|
}
|
|
connect(connectCallback) {
|
|
if (typeof connectCallback === "function") {
|
|
this.once("connect", () => {
|
|
this.logger.debug({
|
|
tnx: "smtp"
|
|
}, "SMTP handshake finished");
|
|
connectCallback();
|
|
});
|
|
const isDestroyedMessage = this._isDestroyedMessage("connect");
|
|
if (isDestroyedMessage) {
|
|
return connectCallback(this._formatError(isDestroyedMessage, "ECONNECTION", false, "CONN"));
|
|
}
|
|
}
|
|
let opts = {
|
|
port: this.port,
|
|
host: this.host,
|
|
allowInternalNetworkInterfaces: this.allowInternalNetworkInterfaces,
|
|
timeout: this.options.dnsTimeout || DNS_TIMEOUT
|
|
};
|
|
if (this.options.localAddress) {
|
|
opts.localAddress = this.options.localAddress;
|
|
}
|
|
let setupConnectionHandlers = () => {
|
|
this._connectionTimeout = setTimeout(() => {
|
|
this._onError("Connection timeout", "ETIMEDOUT", false, "CONN");
|
|
}, this.options.connectionTimeout || CONNECTION_TIMEOUT);
|
|
this._socket.on("error", this._onSocketError);
|
|
};
|
|
if (this.options.connection) {
|
|
this._socket = this.options.connection;
|
|
if (this.secureConnection && !this.alreadySecured) {
|
|
setImmediate(() => this._upgradeConnection((err) => {
|
|
if (err) {
|
|
this._onError(new Error("Error initiating TLS - " + (err.message || err)), "ETLS", false, "CONN");
|
|
return;
|
|
}
|
|
this._onConnect();
|
|
}));
|
|
} else {
|
|
setImmediate(() => this._onConnect());
|
|
}
|
|
return;
|
|
} else if (this.options.socket) {
|
|
this._socket = this.options.socket;
|
|
return shared.resolveHostname(opts, (err, resolved) => {
|
|
if (err) {
|
|
return setImmediate(() => this._onError(err, "EDNS", false, "CONN"));
|
|
}
|
|
this.logger.debug({
|
|
tnx: "dns",
|
|
source: opts.host,
|
|
resolved: resolved.host,
|
|
cached: !!resolved.cached
|
|
}, "Resolved %s as %s [cache %s]", opts.host, resolved.host, resolved.cached ? "hit" : "miss");
|
|
Object.keys(resolved).forEach((key) => {
|
|
if (key.charAt(0) !== "_" && resolved[key]) {
|
|
opts[key] = resolved[key];
|
|
}
|
|
});
|
|
try {
|
|
this._socket.connect(this.port, this.host, () => {
|
|
this._socket.setKeepAlive(true);
|
|
this._onConnect();
|
|
});
|
|
setupConnectionHandlers();
|
|
} catch (E) {
|
|
return setImmediate(() => this._onError(E, "ECONNECTION", false, "CONN"));
|
|
}
|
|
});
|
|
} else if (this.secureConnection) {
|
|
if (this.options.tls) {
|
|
Object.keys(this.options.tls).forEach((key) => {
|
|
opts[key] = this.options.tls[key];
|
|
});
|
|
}
|
|
if (this.servername && !opts.servername) {
|
|
opts.servername = this.servername;
|
|
}
|
|
return shared.resolveHostname(opts, (err, resolved) => {
|
|
if (err) {
|
|
return setImmediate(() => this._onError(err, "EDNS", false, "CONN"));
|
|
}
|
|
this.logger.debug({
|
|
tnx: "dns",
|
|
source: opts.host,
|
|
resolved: resolved.host,
|
|
cached: !!resolved.cached
|
|
}, "Resolved %s as %s [cache %s]", opts.host, resolved.host, resolved.cached ? "hit" : "miss");
|
|
Object.keys(resolved).forEach((key) => {
|
|
if (key.charAt(0) !== "_" && resolved[key]) {
|
|
opts[key] = resolved[key];
|
|
}
|
|
});
|
|
try {
|
|
this._socket = tls.connect(opts, () => {
|
|
this._socket.setKeepAlive(true);
|
|
this._onConnect();
|
|
});
|
|
setupConnectionHandlers();
|
|
} catch (E) {
|
|
return setImmediate(() => this._onError(E, "ECONNECTION", false, "CONN"));
|
|
}
|
|
});
|
|
} else {
|
|
return shared.resolveHostname(opts, (err, resolved) => {
|
|
if (err) {
|
|
return setImmediate(() => this._onError(err, "EDNS", false, "CONN"));
|
|
}
|
|
this.logger.debug({
|
|
tnx: "dns",
|
|
source: opts.host,
|
|
resolved: resolved.host,
|
|
cached: !!resolved.cached
|
|
}, "Resolved %s as %s [cache %s]", opts.host, resolved.host, resolved.cached ? "hit" : "miss");
|
|
Object.keys(resolved).forEach((key) => {
|
|
if (key.charAt(0) !== "_" && resolved[key]) {
|
|
opts[key] = resolved[key];
|
|
}
|
|
});
|
|
try {
|
|
this._socket = net.connect(opts, () => {
|
|
this._socket.setKeepAlive(true);
|
|
this._onConnect();
|
|
});
|
|
setupConnectionHandlers();
|
|
} catch (E) {
|
|
return setImmediate(() => this._onError(E, "ECONNECTION", false, "CONN"));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
quit() {
|
|
this._sendCommand("QUIT");
|
|
this._responseActions.push(this.close);
|
|
}
|
|
close() {
|
|
clearTimeout(this._connectionTimeout);
|
|
clearTimeout(this._greetingTimeout);
|
|
this._responseActions = [];
|
|
if (this._closing) {
|
|
return;
|
|
}
|
|
this._closing = true;
|
|
let closeMethod = "end";
|
|
if (this.stage === "init") {
|
|
closeMethod = "destroy";
|
|
}
|
|
this.logger.debug({
|
|
tnx: "smtp"
|
|
}, 'Closing connection to the server using "%s"', closeMethod);
|
|
let socket = this._socket && this._socket.socket || this._socket;
|
|
if (socket && !socket.destroyed) {
|
|
try {
|
|
this._socket[closeMethod]();
|
|
} catch (E) {
|
|
}
|
|
}
|
|
this._destroy();
|
|
}
|
|
login(authData, callback) {
|
|
const isDestroyedMessage = this._isDestroyedMessage("login");
|
|
if (isDestroyedMessage) {
|
|
return callback(this._formatError(isDestroyedMessage, "ECONNECTION", false, "API"));
|
|
}
|
|
this._auth = authData || {};
|
|
this._authMethod = (this._auth.method || "").toString().trim().toUpperCase() || false;
|
|
if (!this._authMethod && this._auth.oauth2 && !this._auth.credentials) {
|
|
this._authMethod = "XOAUTH2";
|
|
} else if (!this._authMethod || this._authMethod === "XOAUTH2" && !this._auth.oauth2) {
|
|
this._authMethod = (this._supportedAuth[0] || "PLAIN").toUpperCase().trim();
|
|
}
|
|
if (this._authMethod !== "XOAUTH2" && (!this._auth.credentials || !this._auth.credentials.user || !this._auth.credentials.pass)) {
|
|
if (this._auth.user && this._auth.pass || this.customAuth.has(this._authMethod)) {
|
|
this._auth.credentials = {
|
|
user: this._auth.user,
|
|
pass: this._auth.pass,
|
|
options: this._auth.options
|
|
};
|
|
} else {
|
|
return callback(this._formatError('Missing credentials for "' + this._authMethod + '"', "EAUTH", false, "API"));
|
|
}
|
|
}
|
|
if (this.customAuth.has(this._authMethod)) {
|
|
let handler = this.customAuth.get(this._authMethod);
|
|
let lastResponse;
|
|
let returned = false;
|
|
let resolve = () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
this.logger.info({
|
|
tnx: "smtp",
|
|
username: this._auth.user,
|
|
action: "authenticated",
|
|
method: this._authMethod
|
|
}, "User %s authenticated", JSON.stringify(this._auth.user));
|
|
this.authenticated = true;
|
|
callback(null, true);
|
|
};
|
|
let reject = (err) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
callback(this._formatError(err, "EAUTH", lastResponse, "AUTH " + this._authMethod));
|
|
};
|
|
let handlerResponse = handler({
|
|
auth: this._auth,
|
|
method: this._authMethod,
|
|
extensions: [].concat(this._supportedExtensions),
|
|
authMethods: [].concat(this._supportedAuth),
|
|
maxAllowedSize: this._maxAllowedSize || false,
|
|
sendCommand: (cmd, done) => {
|
|
let promise;
|
|
if (!done) {
|
|
promise = new Promise((resolve2, reject2) => {
|
|
done = shared.callbackPromise(resolve2, reject2);
|
|
});
|
|
}
|
|
this._responseActions.push((str) => {
|
|
lastResponse = str;
|
|
let codes = str.match(/^(\d+)(?:\s(\d+\.\d+\.\d+))?\s/);
|
|
let data = {
|
|
command: cmd,
|
|
response: str
|
|
};
|
|
if (codes) {
|
|
data.status = Number(codes[1]) || 0;
|
|
if (codes[2]) {
|
|
data.code = codes[2];
|
|
}
|
|
data.text = str.substr(codes[0].length);
|
|
} else {
|
|
data.text = str;
|
|
data.status = 0;
|
|
}
|
|
done(null, data);
|
|
});
|
|
setImmediate(() => this._sendCommand(cmd));
|
|
return promise;
|
|
},
|
|
resolve,
|
|
reject
|
|
});
|
|
if (handlerResponse && typeof handlerResponse.catch === "function") {
|
|
handlerResponse.then(resolve).catch(reject);
|
|
}
|
|
return;
|
|
}
|
|
switch (this._authMethod) {
|
|
case "XOAUTH2":
|
|
this._handleXOauth2Token(false, callback);
|
|
return;
|
|
case "LOGIN":
|
|
this._responseActions.push((str) => {
|
|
this._actionAUTH_LOGIN_USER(str, callback);
|
|
});
|
|
this._sendCommand("AUTH LOGIN");
|
|
return;
|
|
case "PLAIN":
|
|
this._responseActions.push((str) => {
|
|
this._actionAUTHComplete(str, callback);
|
|
});
|
|
this._sendCommand("AUTH PLAIN " + Buffer.from("\0" + this._auth.credentials.user + "\0" + this._auth.credentials.pass, "utf-8").toString("base64"), "AUTH PLAIN " + Buffer.from("\0" + this._auth.credentials.user + "\0" + "/* secret */", "utf-8").toString("base64"));
|
|
return;
|
|
case "CRAM-MD5":
|
|
this._responseActions.push((str) => {
|
|
this._actionAUTH_CRAM_MD5(str, callback);
|
|
});
|
|
this._sendCommand("AUTH CRAM-MD5");
|
|
return;
|
|
}
|
|
return callback(this._formatError('Unknown authentication method "' + this._authMethod + '"', "EAUTH", false, "API"));
|
|
}
|
|
send(envelope, message, done) {
|
|
if (!message) {
|
|
return done(this._formatError("Empty message", "EMESSAGE", false, "API"));
|
|
}
|
|
const isDestroyedMessage = this._isDestroyedMessage("send message");
|
|
if (isDestroyedMessage) {
|
|
return done(this._formatError(isDestroyedMessage, "ECONNECTION", false, "API"));
|
|
}
|
|
if (this._maxAllowedSize && envelope.size > this._maxAllowedSize) {
|
|
return setImmediate(() => {
|
|
done(this._formatError("Message size larger than allowed " + this._maxAllowedSize, "EMESSAGE", false, "MAIL FROM"));
|
|
});
|
|
}
|
|
let returned = false;
|
|
let callback = function() {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
done(...arguments);
|
|
};
|
|
if (typeof message.on === "function") {
|
|
message.on("error", (err) => callback(this._formatError(err, "ESTREAM", false, "API")));
|
|
}
|
|
let startTime = Date.now();
|
|
this._setEnvelope(envelope, (err, info) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let envelopeTime = Date.now();
|
|
let stream = this._createSendStream((err2, str) => {
|
|
if (err2) {
|
|
return callback(err2);
|
|
}
|
|
info.envelopeTime = envelopeTime - startTime;
|
|
info.messageTime = Date.now() - envelopeTime;
|
|
info.messageSize = stream.outByteCount;
|
|
info.response = str;
|
|
return callback(null, info);
|
|
});
|
|
if (typeof message.pipe === "function") {
|
|
message.pipe(stream);
|
|
} else {
|
|
stream.write(message);
|
|
stream.end();
|
|
}
|
|
});
|
|
}
|
|
reset(callback) {
|
|
this._sendCommand("RSET");
|
|
this._responseActions.push((str) => {
|
|
if (str.charAt(0) !== "2") {
|
|
return callback(this._formatError("Could not reset session state. response=" + str, "EPROTOCOL", str, "RSET"));
|
|
}
|
|
this._envelope = false;
|
|
return callback(null, true);
|
|
});
|
|
}
|
|
_onConnect() {
|
|
clearTimeout(this._connectionTimeout);
|
|
this.logger.info({
|
|
tnx: "network",
|
|
localAddress: this._socket.localAddress,
|
|
localPort: this._socket.localPort,
|
|
remoteAddress: this._socket.remoteAddress,
|
|
remotePort: this._socket.remotePort
|
|
}, "%s established to %s:%s", this.secure ? "Secure connection" : "Connection", this._socket.remoteAddress, this._socket.remotePort);
|
|
if (this._destroyed) {
|
|
this.close();
|
|
return;
|
|
}
|
|
this.stage = "connected";
|
|
this._socket.removeListener("data", this._onSocketData);
|
|
this._socket.removeListener("timeout", this._onSocketTimeout);
|
|
this._socket.removeListener("close", this._onSocketClose);
|
|
this._socket.removeListener("end", this._onSocketEnd);
|
|
this._socket.on("data", this._onSocketData);
|
|
this._socket.once("close", this._onSocketClose);
|
|
this._socket.once("end", this._onSocketEnd);
|
|
this._socket.setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT);
|
|
this._socket.on("timeout", this._onSocketTimeout);
|
|
this._greetingTimeout = setTimeout(() => {
|
|
if (this._socket && !this._destroyed && this._responseActions[0] === this._actionGreeting) {
|
|
this._onError("Greeting never received", "ETIMEDOUT", false, "CONN");
|
|
}
|
|
}, this.options.greetingTimeout || GREETING_TIMEOUT);
|
|
this._responseActions.push(this._actionGreeting);
|
|
this._socket.resume();
|
|
}
|
|
_onData(chunk) {
|
|
if (this._destroyed || !chunk || !chunk.length) {
|
|
return;
|
|
}
|
|
let data = (chunk || "").toString("binary");
|
|
let lines = (this._remainder + data).split(/\r?\n/);
|
|
let lastline;
|
|
this._remainder = lines.pop();
|
|
for (let i = 0, len = lines.length;i < len; i++) {
|
|
if (this._responseQueue.length) {
|
|
lastline = this._responseQueue[this._responseQueue.length - 1];
|
|
if (/^\d+-/.test(lastline.split("\n").pop())) {
|
|
this._responseQueue[this._responseQueue.length - 1] += "\n" + lines[i];
|
|
continue;
|
|
}
|
|
}
|
|
this._responseQueue.push(lines[i]);
|
|
}
|
|
if (this._responseQueue.length) {
|
|
lastline = this._responseQueue[this._responseQueue.length - 1];
|
|
if (/^\d+-/.test(lastline.split("\n").pop())) {
|
|
return;
|
|
}
|
|
}
|
|
this._processResponse();
|
|
}
|
|
_onError(err, type, data, command) {
|
|
clearTimeout(this._connectionTimeout);
|
|
clearTimeout(this._greetingTimeout);
|
|
if (this._destroyed) {
|
|
return;
|
|
}
|
|
err = this._formatError(err, type, data, command);
|
|
this.logger.error(data, err.message);
|
|
this.emit("error", err);
|
|
this.close();
|
|
}
|
|
_formatError(message, type, response, command) {
|
|
let err;
|
|
if (/Error\]$/i.test(Object.prototype.toString.call(message))) {
|
|
err = message;
|
|
} else {
|
|
err = new Error(message);
|
|
}
|
|
if (type && type !== "Error") {
|
|
err.code = type;
|
|
}
|
|
if (response) {
|
|
err.response = response;
|
|
err.message += ": " + response;
|
|
}
|
|
let responseCode = typeof response === "string" && Number((response.match(/^\d+/) || [])[0]) || false;
|
|
if (responseCode) {
|
|
err.responseCode = responseCode;
|
|
}
|
|
if (command) {
|
|
err.command = command;
|
|
}
|
|
return err;
|
|
}
|
|
_onClose() {
|
|
let serverResponse = false;
|
|
if (this._remainder && this._remainder.trim()) {
|
|
if (this.options.debug || this.options.transactionLog) {
|
|
this.logger.debug({
|
|
tnx: "server"
|
|
}, this._remainder.replace(/\r?\n$/, ""));
|
|
}
|
|
this.lastServerResponse = serverResponse = this._remainder.trim();
|
|
}
|
|
this.logger.info({
|
|
tnx: "network"
|
|
}, "Connection closed");
|
|
if (this.upgrading && !this._destroyed) {
|
|
return this._onError(new Error("Connection closed unexpectedly"), "ETLS", serverResponse, "CONN");
|
|
} else if (![this._actionGreeting, this.close].includes(this._responseActions[0]) && !this._destroyed) {
|
|
return this._onError(new Error("Connection closed unexpectedly"), "ECONNECTION", serverResponse, "CONN");
|
|
} else if (/^[45]\d{2}\b/.test(serverResponse)) {
|
|
return this._onError(new Error("Connection closed unexpectedly"), "ECONNECTION", serverResponse, "CONN");
|
|
}
|
|
this._destroy();
|
|
}
|
|
_onEnd() {
|
|
if (this._socket && !this._socket.destroyed) {
|
|
this._socket.destroy();
|
|
}
|
|
}
|
|
_onTimeout() {
|
|
return this._onError(new Error("Timeout"), "ETIMEDOUT", false, "CONN");
|
|
}
|
|
_destroy() {
|
|
if (this._destroyed) {
|
|
return;
|
|
}
|
|
this._destroyed = true;
|
|
this.emit("end");
|
|
}
|
|
_upgradeConnection(callback) {
|
|
this._socket.removeListener("data", this._onSocketData);
|
|
this._socket.removeListener("timeout", this._onSocketTimeout);
|
|
let socketPlain = this._socket;
|
|
let opts = {
|
|
socket: this._socket,
|
|
host: this.host
|
|
};
|
|
Object.keys(this.options.tls || {}).forEach((key) => {
|
|
opts[key] = this.options.tls[key];
|
|
});
|
|
if (this.servername && !opts.servername) {
|
|
opts.servername = this.servername;
|
|
}
|
|
this.upgrading = true;
|
|
try {
|
|
this._socket = tls.connect(opts, () => {
|
|
this.secure = true;
|
|
this.upgrading = false;
|
|
this._socket.on("data", this._onSocketData);
|
|
socketPlain.removeListener("close", this._onSocketClose);
|
|
socketPlain.removeListener("end", this._onSocketEnd);
|
|
return callback(null, true);
|
|
});
|
|
} catch (err) {
|
|
return callback(err);
|
|
}
|
|
this._socket.on("error", this._onSocketError);
|
|
this._socket.once("close", this._onSocketClose);
|
|
this._socket.once("end", this._onSocketEnd);
|
|
this._socket.setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT);
|
|
this._socket.on("timeout", this._onSocketTimeout);
|
|
socketPlain.resume();
|
|
}
|
|
_processResponse() {
|
|
if (!this._responseQueue.length) {
|
|
return false;
|
|
}
|
|
let str = this.lastServerResponse = (this._responseQueue.shift() || "").toString();
|
|
if (/^\d+-/.test(str.split("\n").pop())) {
|
|
return;
|
|
}
|
|
if (this.options.debug || this.options.transactionLog) {
|
|
this.logger.debug({
|
|
tnx: "server"
|
|
}, str.replace(/\r?\n$/, ""));
|
|
}
|
|
if (!str.trim()) {
|
|
setImmediate(() => this._processResponse());
|
|
}
|
|
let action = this._responseActions.shift();
|
|
if (typeof action === "function") {
|
|
action.call(this, str);
|
|
setImmediate(() => this._processResponse());
|
|
} else {
|
|
return this._onError(new Error("Unexpected Response"), "EPROTOCOL", str, "CONN");
|
|
}
|
|
}
|
|
_sendCommand(str, logStr) {
|
|
if (this._destroyed) {
|
|
return;
|
|
}
|
|
if (this._socket.destroyed) {
|
|
return this.close();
|
|
}
|
|
if (this.options.debug || this.options.transactionLog) {
|
|
this.logger.debug({
|
|
tnx: "client"
|
|
}, (logStr || str || "").toString().replace(/\r?\n$/, ""));
|
|
}
|
|
this._socket.write(Buffer.from(str + "\r\n", "utf-8"));
|
|
}
|
|
_setEnvelope(envelope, callback) {
|
|
let args = [];
|
|
let useSmtpUtf8 = false;
|
|
this._envelope = envelope || {};
|
|
this._envelope.from = (this._envelope.from && this._envelope.from.address || this._envelope.from || "").toString().trim();
|
|
this._envelope.to = [].concat(this._envelope.to || []).map((to) => (to && to.address || to || "").toString().trim());
|
|
if (!this._envelope.to.length) {
|
|
return callback(this._formatError("No recipients defined", "EENVELOPE", false, "API"));
|
|
}
|
|
if (this._envelope.from && /[\r\n<>]/.test(this._envelope.from)) {
|
|
return callback(this._formatError("Invalid sender " + JSON.stringify(this._envelope.from), "EENVELOPE", false, "API"));
|
|
}
|
|
if (/[\x80-\uFFFF]/.test(this._envelope.from)) {
|
|
useSmtpUtf8 = true;
|
|
}
|
|
for (let i = 0, len = this._envelope.to.length;i < len; i++) {
|
|
if (!this._envelope.to[i] || /[\r\n<>]/.test(this._envelope.to[i])) {
|
|
return callback(this._formatError("Invalid recipient " + JSON.stringify(this._envelope.to[i]), "EENVELOPE", false, "API"));
|
|
}
|
|
if (/[\x80-\uFFFF]/.test(this._envelope.to[i])) {
|
|
useSmtpUtf8 = true;
|
|
}
|
|
}
|
|
this._envelope.rcptQueue = JSON.parse(JSON.stringify(this._envelope.to || []));
|
|
this._envelope.rejected = [];
|
|
this._envelope.rejectedErrors = [];
|
|
this._envelope.accepted = [];
|
|
if (this._envelope.dsn) {
|
|
try {
|
|
this._envelope.dsn = this._setDsnEnvelope(this._envelope.dsn);
|
|
} catch (err) {
|
|
return callback(this._formatError("Invalid DSN " + err.message, "EENVELOPE", false, "API"));
|
|
}
|
|
}
|
|
this._responseActions.push((str) => {
|
|
this._actionMAIL(str, callback);
|
|
});
|
|
if (useSmtpUtf8 && this._supportedExtensions.includes("SMTPUTF8")) {
|
|
args.push("SMTPUTF8");
|
|
this._usingSmtpUtf8 = true;
|
|
}
|
|
if (this._envelope.use8BitMime && this._supportedExtensions.includes("8BITMIME")) {
|
|
args.push("BODY=8BITMIME");
|
|
this._using8BitMime = true;
|
|
}
|
|
if (this._envelope.size && this._supportedExtensions.includes("SIZE")) {
|
|
args.push("SIZE=" + this._envelope.size);
|
|
}
|
|
if (this._envelope.dsn && this._supportedExtensions.includes("DSN")) {
|
|
if (this._envelope.dsn.ret) {
|
|
args.push("RET=" + shared.encodeXText(this._envelope.dsn.ret));
|
|
}
|
|
if (this._envelope.dsn.envid) {
|
|
args.push("ENVID=" + shared.encodeXText(this._envelope.dsn.envid));
|
|
}
|
|
}
|
|
this._sendCommand("MAIL FROM:<" + this._envelope.from + ">" + (args.length ? " " + args.join(" ") : ""));
|
|
}
|
|
_setDsnEnvelope(params) {
|
|
let ret = (params.ret || params.return || "").toString().toUpperCase() || null;
|
|
if (ret) {
|
|
switch (ret) {
|
|
case "HDRS":
|
|
case "HEADERS":
|
|
ret = "HDRS";
|
|
break;
|
|
case "FULL":
|
|
case "BODY":
|
|
ret = "FULL";
|
|
break;
|
|
}
|
|
}
|
|
if (ret && !["FULL", "HDRS"].includes(ret)) {
|
|
throw new Error("ret: " + JSON.stringify(ret));
|
|
}
|
|
let envid = (params.envid || params.id || "").toString() || null;
|
|
let notify = params.notify || null;
|
|
if (notify) {
|
|
if (typeof notify === "string") {
|
|
notify = notify.split(",");
|
|
}
|
|
notify = notify.map((n) => n.trim().toUpperCase());
|
|
let validNotify = ["NEVER", "SUCCESS", "FAILURE", "DELAY"];
|
|
let invaliNotify = notify.filter((n) => !validNotify.includes(n));
|
|
if (invaliNotify.length || notify.length > 1 && notify.includes("NEVER")) {
|
|
throw new Error("notify: " + JSON.stringify(notify.join(",")));
|
|
}
|
|
notify = notify.join(",");
|
|
}
|
|
let orcpt = (params.recipient || params.orcpt || "").toString() || null;
|
|
if (orcpt && orcpt.indexOf(";") < 0) {
|
|
orcpt = "rfc822;" + orcpt;
|
|
}
|
|
return {
|
|
ret,
|
|
envid,
|
|
notify,
|
|
orcpt
|
|
};
|
|
}
|
|
_getDsnRcptToArgs() {
|
|
let args = [];
|
|
if (this._envelope.dsn && this._supportedExtensions.includes("DSN")) {
|
|
if (this._envelope.dsn.notify) {
|
|
args.push("NOTIFY=" + shared.encodeXText(this._envelope.dsn.notify));
|
|
}
|
|
if (this._envelope.dsn.orcpt) {
|
|
args.push("ORCPT=" + shared.encodeXText(this._envelope.dsn.orcpt));
|
|
}
|
|
}
|
|
return args.length ? " " + args.join(" ") : "";
|
|
}
|
|
_createSendStream(callback) {
|
|
let dataStream = new DataStream;
|
|
let logStream;
|
|
if (this.options.lmtp) {
|
|
this._envelope.accepted.forEach((recipient, i) => {
|
|
let final = i === this._envelope.accepted.length - 1;
|
|
this._responseActions.push((str) => {
|
|
this._actionLMTPStream(recipient, final, str, callback);
|
|
});
|
|
});
|
|
} else {
|
|
this._responseActions.push((str) => {
|
|
this._actionSMTPStream(str, callback);
|
|
});
|
|
}
|
|
dataStream.pipe(this._socket, {
|
|
end: false
|
|
});
|
|
if (this.options.debug) {
|
|
logStream = new PassThrough;
|
|
logStream.on("readable", () => {
|
|
let chunk;
|
|
while (chunk = logStream.read()) {
|
|
this.logger.debug({
|
|
tnx: "message"
|
|
}, chunk.toString("binary").replace(/\r?\n$/, ""));
|
|
}
|
|
});
|
|
dataStream.pipe(logStream);
|
|
}
|
|
dataStream.once("end", () => {
|
|
this.logger.info({
|
|
tnx: "message",
|
|
inByteCount: dataStream.inByteCount,
|
|
outByteCount: dataStream.outByteCount
|
|
}, "<%s bytes encoded mime message (source size %s bytes)>", dataStream.outByteCount, dataStream.inByteCount);
|
|
});
|
|
return dataStream;
|
|
}
|
|
_actionGreeting(str) {
|
|
clearTimeout(this._greetingTimeout);
|
|
if (str.substr(0, 3) !== "220") {
|
|
this._onError(new Error("Invalid greeting. response=" + str), "EPROTOCOL", str, "CONN");
|
|
return;
|
|
}
|
|
if (this.options.lmtp) {
|
|
this._responseActions.push(this._actionLHLO);
|
|
this._sendCommand("LHLO " + this.name);
|
|
} else {
|
|
this._responseActions.push(this._actionEHLO);
|
|
this._sendCommand("EHLO " + this.name);
|
|
}
|
|
}
|
|
_actionLHLO(str) {
|
|
if (str.charAt(0) !== "2") {
|
|
this._onError(new Error("Invalid LHLO. response=" + str), "EPROTOCOL", str, "LHLO");
|
|
return;
|
|
}
|
|
this._actionEHLO(str);
|
|
}
|
|
_actionEHLO(str) {
|
|
let match;
|
|
if (str.substr(0, 3) === "421") {
|
|
this._onError(new Error("Server terminates connection. response=" + str), "ECONNECTION", str, "EHLO");
|
|
return;
|
|
}
|
|
if (str.charAt(0) !== "2") {
|
|
if (this.options.requireTLS) {
|
|
this._onError(new Error("EHLO failed but HELO does not support required STARTTLS. response=" + str), "ECONNECTION", str, "EHLO");
|
|
return;
|
|
}
|
|
this._responseActions.push(this._actionHELO);
|
|
this._sendCommand("HELO " + this.name);
|
|
return;
|
|
}
|
|
this._ehloLines = str.split(/\r?\n/).map((line) => line.replace(/^\d+[ -]/, "").trim()).filter((line) => line).slice(1);
|
|
if (!this.secure && !this.options.ignoreTLS && (/[ -]STARTTLS\b/im.test(str) || this.options.requireTLS)) {
|
|
this._sendCommand("STARTTLS");
|
|
this._responseActions.push(this._actionSTARTTLS);
|
|
return;
|
|
}
|
|
if (/[ -]SMTPUTF8\b/im.test(str)) {
|
|
this._supportedExtensions.push("SMTPUTF8");
|
|
}
|
|
if (/[ -]DSN\b/im.test(str)) {
|
|
this._supportedExtensions.push("DSN");
|
|
}
|
|
if (/[ -]8BITMIME\b/im.test(str)) {
|
|
this._supportedExtensions.push("8BITMIME");
|
|
}
|
|
if (/[ -]PIPELINING\b/im.test(str)) {
|
|
this._supportedExtensions.push("PIPELINING");
|
|
}
|
|
if (/[ -]AUTH\b/i.test(str)) {
|
|
this.allowsAuth = true;
|
|
}
|
|
if (/[ -]AUTH(?:(\s+|=)[^\n]*\s+|\s+|=)PLAIN/i.test(str)) {
|
|
this._supportedAuth.push("PLAIN");
|
|
}
|
|
if (/[ -]AUTH(?:(\s+|=)[^\n]*\s+|\s+|=)LOGIN/i.test(str)) {
|
|
this._supportedAuth.push("LOGIN");
|
|
}
|
|
if (/[ -]AUTH(?:(\s+|=)[^\n]*\s+|\s+|=)CRAM-MD5/i.test(str)) {
|
|
this._supportedAuth.push("CRAM-MD5");
|
|
}
|
|
if (/[ -]AUTH(?:(\s+|=)[^\n]*\s+|\s+|=)XOAUTH2/i.test(str)) {
|
|
this._supportedAuth.push("XOAUTH2");
|
|
}
|
|
if (match = str.match(/[ -]SIZE(?:[ \t]+(\d+))?/im)) {
|
|
this._supportedExtensions.push("SIZE");
|
|
this._maxAllowedSize = Number(match[1]) || 0;
|
|
}
|
|
this.emit("connect");
|
|
}
|
|
_actionHELO(str) {
|
|
if (str.charAt(0) !== "2") {
|
|
this._onError(new Error("Invalid HELO. response=" + str), "EPROTOCOL", str, "HELO");
|
|
return;
|
|
}
|
|
this.allowsAuth = true;
|
|
this.emit("connect");
|
|
}
|
|
_actionSTARTTLS(str) {
|
|
if (str.charAt(0) !== "2") {
|
|
if (this.options.opportunisticTLS) {
|
|
this.logger.info({
|
|
tnx: "smtp"
|
|
}, "Failed STARTTLS upgrade, continuing unencrypted");
|
|
return this.emit("connect");
|
|
}
|
|
this._onError(new Error("Error upgrading connection with STARTTLS"), "ETLS", str, "STARTTLS");
|
|
return;
|
|
}
|
|
this._upgradeConnection((err, secured) => {
|
|
if (err) {
|
|
this._onError(new Error("Error initiating TLS - " + (err.message || err)), "ETLS", false, "STARTTLS");
|
|
return;
|
|
}
|
|
this.logger.info({
|
|
tnx: "smtp"
|
|
}, "Connection upgraded with STARTTLS");
|
|
if (secured) {
|
|
if (this.options.lmtp) {
|
|
this._responseActions.push(this._actionLHLO);
|
|
this._sendCommand("LHLO " + this.name);
|
|
} else {
|
|
this._responseActions.push(this._actionEHLO);
|
|
this._sendCommand("EHLO " + this.name);
|
|
}
|
|
} else {
|
|
this.emit("connect");
|
|
}
|
|
});
|
|
}
|
|
_actionAUTH_LOGIN_USER(str, callback) {
|
|
if (!/^334[ -]/.test(str)) {
|
|
callback(this._formatError('Invalid login sequence while waiting for "334 VXNlcm5hbWU6"', "EAUTH", str, "AUTH LOGIN"));
|
|
return;
|
|
}
|
|
this._responseActions.push((str2) => {
|
|
this._actionAUTH_LOGIN_PASS(str2, callback);
|
|
});
|
|
this._sendCommand(Buffer.from(this._auth.credentials.user + "", "utf-8").toString("base64"));
|
|
}
|
|
_actionAUTH_CRAM_MD5(str, callback) {
|
|
let challengeMatch = str.match(/^334\s+(.+)$/);
|
|
let challengeString = "";
|
|
if (!challengeMatch) {
|
|
return callback(this._formatError("Invalid login sequence while waiting for server challenge string", "EAUTH", str, "AUTH CRAM-MD5"));
|
|
} else {
|
|
challengeString = challengeMatch[1];
|
|
}
|
|
let base64decoded = Buffer.from(challengeString, "base64").toString("ascii"), hmacMD5 = crypto2.createHmac("md5", this._auth.credentials.pass);
|
|
hmacMD5.update(base64decoded);
|
|
let prepended = this._auth.credentials.user + " " + hmacMD5.digest("hex");
|
|
this._responseActions.push((str2) => {
|
|
this._actionAUTH_CRAM_MD5_PASS(str2, callback);
|
|
});
|
|
this._sendCommand(Buffer.from(prepended).toString("base64"), Buffer.from(this._auth.credentials.user + " /* secret */").toString("base64"));
|
|
}
|
|
_actionAUTH_CRAM_MD5_PASS(str, callback) {
|
|
if (!str.match(/^235\s+/)) {
|
|
return callback(this._formatError('Invalid login sequence while waiting for "235"', "EAUTH", str, "AUTH CRAM-MD5"));
|
|
}
|
|
this.logger.info({
|
|
tnx: "smtp",
|
|
username: this._auth.user,
|
|
action: "authenticated",
|
|
method: this._authMethod
|
|
}, "User %s authenticated", JSON.stringify(this._auth.user));
|
|
this.authenticated = true;
|
|
callback(null, true);
|
|
}
|
|
_actionAUTH_LOGIN_PASS(str, callback) {
|
|
if (!/^334[ -]/.test(str)) {
|
|
return callback(this._formatError('Invalid login sequence while waiting for "334 UGFzc3dvcmQ6"', "EAUTH", str, "AUTH LOGIN"));
|
|
}
|
|
this._responseActions.push((str2) => {
|
|
this._actionAUTHComplete(str2, callback);
|
|
});
|
|
this._sendCommand(Buffer.from((this._auth.credentials.pass || "").toString(), "utf-8").toString("base64"), Buffer.from("/* secret */", "utf-8").toString("base64"));
|
|
}
|
|
_actionAUTHComplete(str, isRetry, callback) {
|
|
if (!callback && typeof isRetry === "function") {
|
|
callback = isRetry;
|
|
isRetry = false;
|
|
}
|
|
if (str.substr(0, 3) === "334") {
|
|
this._responseActions.push((str2) => {
|
|
if (isRetry || this._authMethod !== "XOAUTH2") {
|
|
this._actionAUTHComplete(str2, true, callback);
|
|
} else {
|
|
setImmediate(() => this._handleXOauth2Token(true, callback));
|
|
}
|
|
});
|
|
this._sendCommand("");
|
|
return;
|
|
}
|
|
if (str.charAt(0) !== "2") {
|
|
this.logger.info({
|
|
tnx: "smtp",
|
|
username: this._auth.user,
|
|
action: "authfail",
|
|
method: this._authMethod
|
|
}, "User %s failed to authenticate", JSON.stringify(this._auth.user));
|
|
return callback(this._formatError("Invalid login", "EAUTH", str, "AUTH " + this._authMethod));
|
|
}
|
|
this.logger.info({
|
|
tnx: "smtp",
|
|
username: this._auth.user,
|
|
action: "authenticated",
|
|
method: this._authMethod
|
|
}, "User %s authenticated", JSON.stringify(this._auth.user));
|
|
this.authenticated = true;
|
|
callback(null, true);
|
|
}
|
|
_actionMAIL(str, callback) {
|
|
let message, curRecipient;
|
|
if (Number(str.charAt(0)) !== 2) {
|
|
if (this._usingSmtpUtf8 && /^550 /.test(str) && /[\x80-\uFFFF]/.test(this._envelope.from)) {
|
|
message = "Internationalized mailbox name not allowed";
|
|
} else {
|
|
message = "Mail command failed";
|
|
}
|
|
return callback(this._formatError(message, "EENVELOPE", str, "MAIL FROM"));
|
|
}
|
|
if (!this._envelope.rcptQueue.length) {
|
|
return callback(this._formatError("Can't send mail - no recipients defined", "EENVELOPE", false, "API"));
|
|
} else {
|
|
this._recipientQueue = [];
|
|
if (this._supportedExtensions.includes("PIPELINING")) {
|
|
while (this._envelope.rcptQueue.length) {
|
|
curRecipient = this._envelope.rcptQueue.shift();
|
|
this._recipientQueue.push(curRecipient);
|
|
this._responseActions.push((str2) => {
|
|
this._actionRCPT(str2, callback);
|
|
});
|
|
this._sendCommand("RCPT TO:<" + curRecipient + ">" + this._getDsnRcptToArgs());
|
|
}
|
|
} else {
|
|
curRecipient = this._envelope.rcptQueue.shift();
|
|
this._recipientQueue.push(curRecipient);
|
|
this._responseActions.push((str2) => {
|
|
this._actionRCPT(str2, callback);
|
|
});
|
|
this._sendCommand("RCPT TO:<" + curRecipient + ">" + this._getDsnRcptToArgs());
|
|
}
|
|
}
|
|
}
|
|
_actionRCPT(str, callback) {
|
|
let message, err, curRecipient = this._recipientQueue.shift();
|
|
if (Number(str.charAt(0)) !== 2) {
|
|
if (this._usingSmtpUtf8 && /^553 /.test(str) && /[\x80-\uFFFF]/.test(curRecipient)) {
|
|
message = "Internationalized mailbox name not allowed";
|
|
} else {
|
|
message = "Recipient command failed";
|
|
}
|
|
this._envelope.rejected.push(curRecipient);
|
|
err = this._formatError(message, "EENVELOPE", str, "RCPT TO");
|
|
err.recipient = curRecipient;
|
|
this._envelope.rejectedErrors.push(err);
|
|
} else {
|
|
this._envelope.accepted.push(curRecipient);
|
|
}
|
|
if (!this._envelope.rcptQueue.length && !this._recipientQueue.length) {
|
|
if (this._envelope.rejected.length < this._envelope.to.length) {
|
|
this._responseActions.push((str2) => {
|
|
this._actionDATA(str2, callback);
|
|
});
|
|
this._sendCommand("DATA");
|
|
} else {
|
|
err = this._formatError("Can't send mail - all recipients were rejected", "EENVELOPE", str, "RCPT TO");
|
|
err.rejected = this._envelope.rejected;
|
|
err.rejectedErrors = this._envelope.rejectedErrors;
|
|
return callback(err);
|
|
}
|
|
} else if (this._envelope.rcptQueue.length) {
|
|
curRecipient = this._envelope.rcptQueue.shift();
|
|
this._recipientQueue.push(curRecipient);
|
|
this._responseActions.push((str2) => {
|
|
this._actionRCPT(str2, callback);
|
|
});
|
|
this._sendCommand("RCPT TO:<" + curRecipient + ">" + this._getDsnRcptToArgs());
|
|
}
|
|
}
|
|
_actionDATA(str, callback) {
|
|
if (!/^[23]/.test(str)) {
|
|
return callback(this._formatError("Data command failed", "EENVELOPE", str, "DATA"));
|
|
}
|
|
let response = {
|
|
accepted: this._envelope.accepted,
|
|
rejected: this._envelope.rejected
|
|
};
|
|
if (this._ehloLines && this._ehloLines.length) {
|
|
response.ehlo = this._ehloLines;
|
|
}
|
|
if (this._envelope.rejectedErrors.length) {
|
|
response.rejectedErrors = this._envelope.rejectedErrors;
|
|
}
|
|
callback(null, response);
|
|
}
|
|
_actionSMTPStream(str, callback) {
|
|
if (Number(str.charAt(0)) !== 2) {
|
|
return callback(this._formatError("Message failed", "EMESSAGE", str, "DATA"));
|
|
} else {
|
|
return callback(null, str);
|
|
}
|
|
}
|
|
_actionLMTPStream(recipient, final, str, callback) {
|
|
let err;
|
|
if (Number(str.charAt(0)) !== 2) {
|
|
err = this._formatError("Message failed for recipient " + recipient, "EMESSAGE", str, "DATA");
|
|
err.recipient = recipient;
|
|
this._envelope.rejected.push(recipient);
|
|
this._envelope.rejectedErrors.push(err);
|
|
for (let i = 0, len = this._envelope.accepted.length;i < len; i++) {
|
|
if (this._envelope.accepted[i] === recipient) {
|
|
this._envelope.accepted.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
if (final) {
|
|
return callback(null, str);
|
|
}
|
|
}
|
|
_handleXOauth2Token(isRetry, callback) {
|
|
this._auth.oauth2.getToken(isRetry, (err, accessToken) => {
|
|
if (err) {
|
|
this.logger.info({
|
|
tnx: "smtp",
|
|
username: this._auth.user,
|
|
action: "authfail",
|
|
method: this._authMethod
|
|
}, "User %s failed to authenticate", JSON.stringify(this._auth.user));
|
|
return callback(this._formatError(err, "EAUTH", false, "AUTH XOAUTH2"));
|
|
}
|
|
this._responseActions.push((str) => {
|
|
this._actionAUTHComplete(str, isRetry, callback);
|
|
});
|
|
this._sendCommand("AUTH XOAUTH2 " + this._auth.oauth2.buildXOAuth2Token(accessToken), "AUTH XOAUTH2 " + this._auth.oauth2.buildXOAuth2Token("/* secret */"));
|
|
});
|
|
}
|
|
_isDestroyedMessage(command) {
|
|
if (this._destroyed) {
|
|
return "Cannot " + command + " - smtp connection is already destroyed.";
|
|
}
|
|
if (this._socket) {
|
|
if (this._socket.destroyed) {
|
|
return "Cannot " + command + " - smtp connection socket is already destroyed.";
|
|
}
|
|
if (!this._socket.writable) {
|
|
return "Cannot " + command + " - smtp connection socket is already half-closed.";
|
|
}
|
|
}
|
|
}
|
|
_getHostname() {
|
|
let defaultHostname;
|
|
try {
|
|
defaultHostname = os.hostname() || "";
|
|
} catch (err) {
|
|
defaultHostname = "localhost";
|
|
}
|
|
if (!defaultHostname || defaultHostname.indexOf(".") < 0) {
|
|
defaultHostname = "[127.0.0.1]";
|
|
}
|
|
if (defaultHostname.match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)) {
|
|
defaultHostname = "[" + defaultHostname + "]";
|
|
}
|
|
return defaultHostname;
|
|
}
|
|
}
|
|
module.exports = SMTPConnection;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/xoauth2/index.js
|
|
var require_xoauth2 = __commonJS((exports, module) => {
|
|
var Stream = __require("stream").Stream;
|
|
var nmfetch = require_fetch();
|
|
var crypto2 = __require("crypto");
|
|
var shared = require_shared();
|
|
|
|
class XOAuth2 extends Stream {
|
|
constructor(options, logger) {
|
|
super();
|
|
this.options = options || {};
|
|
if (options && options.serviceClient) {
|
|
if (!options.privateKey || !options.user) {
|
|
setImmediate(() => this.emit("error", new Error('Options "privateKey" and "user" are required for service account!')));
|
|
return;
|
|
}
|
|
let serviceRequestTimeout = Math.min(Math.max(Number(this.options.serviceRequestTimeout) || 0, 0), 3600);
|
|
this.options.serviceRequestTimeout = serviceRequestTimeout || 5 * 60;
|
|
}
|
|
this.logger = shared.getLogger({
|
|
logger
|
|
}, {
|
|
component: this.options.component || "OAuth2"
|
|
});
|
|
this.provisionCallback = typeof this.options.provisionCallback === "function" ? this.options.provisionCallback : false;
|
|
this.options.accessUrl = this.options.accessUrl || "https://accounts.google.com/o/oauth2/token";
|
|
this.options.customHeaders = this.options.customHeaders || {};
|
|
this.options.customParams = this.options.customParams || {};
|
|
this.accessToken = this.options.accessToken || false;
|
|
if (this.options.expires && Number(this.options.expires)) {
|
|
this.expires = this.options.expires;
|
|
} else {
|
|
let timeout = Math.max(Number(this.options.timeout) || 0, 0);
|
|
this.expires = timeout && Date.now() + timeout * 1000 || 0;
|
|
}
|
|
}
|
|
getToken(renew, callback) {
|
|
if (!renew && this.accessToken && (!this.expires || this.expires > Date.now())) {
|
|
return callback(null, this.accessToken);
|
|
}
|
|
let generateCallback = (...args) => {
|
|
if (args[0]) {
|
|
this.logger.error({
|
|
err: args[0],
|
|
tnx: "OAUTH2",
|
|
user: this.options.user,
|
|
action: "renew"
|
|
}, "Failed generating new Access Token for %s", this.options.user);
|
|
} else {
|
|
this.logger.info({
|
|
tnx: "OAUTH2",
|
|
user: this.options.user,
|
|
action: "renew"
|
|
}, "Generated new Access Token for %s", this.options.user);
|
|
}
|
|
callback(...args);
|
|
};
|
|
if (this.provisionCallback) {
|
|
this.provisionCallback(this.options.user, !!renew, (err, accessToken, expires) => {
|
|
if (!err && accessToken) {
|
|
this.accessToken = accessToken;
|
|
this.expires = expires || 0;
|
|
}
|
|
generateCallback(err, accessToken);
|
|
});
|
|
} else {
|
|
this.generateToken(generateCallback);
|
|
}
|
|
}
|
|
updateToken(accessToken, timeout) {
|
|
this.accessToken = accessToken;
|
|
timeout = Math.max(Number(timeout) || 0, 0);
|
|
this.expires = timeout && Date.now() + timeout * 1000 || 0;
|
|
this.emit("token", {
|
|
user: this.options.user,
|
|
accessToken: accessToken || "",
|
|
expires: this.expires
|
|
});
|
|
}
|
|
generateToken(callback) {
|
|
let urlOptions;
|
|
let loggedUrlOptions;
|
|
if (this.options.serviceClient) {
|
|
let iat = Math.floor(Date.now() / 1000);
|
|
let tokenData = {
|
|
iss: this.options.serviceClient,
|
|
scope: this.options.scope || "https://mail.google.com/",
|
|
sub: this.options.user,
|
|
aud: this.options.accessUrl,
|
|
iat,
|
|
exp: iat + this.options.serviceRequestTimeout
|
|
};
|
|
let token;
|
|
try {
|
|
token = this.jwtSignRS256(tokenData);
|
|
} catch (err) {
|
|
return callback(new Error("Can't generate token. Check your auth options"));
|
|
}
|
|
urlOptions = {
|
|
grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
|
|
assertion: token
|
|
};
|
|
loggedUrlOptions = {
|
|
grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
|
|
assertion: tokenData
|
|
};
|
|
} else {
|
|
if (!this.options.refreshToken) {
|
|
return callback(new Error("Can't create new access token for user"));
|
|
}
|
|
urlOptions = {
|
|
client_id: this.options.clientId || "",
|
|
client_secret: this.options.clientSecret || "",
|
|
refresh_token: this.options.refreshToken,
|
|
grant_type: "refresh_token"
|
|
};
|
|
loggedUrlOptions = {
|
|
client_id: this.options.clientId || "",
|
|
client_secret: (this.options.clientSecret || "").substr(0, 6) + "...",
|
|
refresh_token: (this.options.refreshToken || "").substr(0, 6) + "...",
|
|
grant_type: "refresh_token"
|
|
};
|
|
}
|
|
Object.keys(this.options.customParams).forEach((key) => {
|
|
urlOptions[key] = this.options.customParams[key];
|
|
loggedUrlOptions[key] = this.options.customParams[key];
|
|
});
|
|
this.logger.debug({
|
|
tnx: "OAUTH2",
|
|
user: this.options.user,
|
|
action: "generate"
|
|
}, "Requesting token using: %s", JSON.stringify(loggedUrlOptions));
|
|
this.postRequest(this.options.accessUrl, urlOptions, this.options, (error, body) => {
|
|
let data;
|
|
if (error) {
|
|
return callback(error);
|
|
}
|
|
try {
|
|
data = JSON.parse(body.toString());
|
|
} catch (E) {
|
|
return callback(E);
|
|
}
|
|
if (!data || typeof data !== "object") {
|
|
this.logger.debug({
|
|
tnx: "OAUTH2",
|
|
user: this.options.user,
|
|
action: "post"
|
|
}, "Response: %s", (body || "").toString());
|
|
return callback(new Error("Invalid authentication response"));
|
|
}
|
|
let logData = {};
|
|
Object.keys(data).forEach((key) => {
|
|
if (key !== "access_token") {
|
|
logData[key] = data[key];
|
|
} else {
|
|
logData[key] = (data[key] || "").toString().substr(0, 6) + "...";
|
|
}
|
|
});
|
|
this.logger.debug({
|
|
tnx: "OAUTH2",
|
|
user: this.options.user,
|
|
action: "post"
|
|
}, "Response: %s", JSON.stringify(logData));
|
|
if (data.error) {
|
|
let errorMessage = data.error;
|
|
if (data.error_description) {
|
|
errorMessage += ": " + data.error_description;
|
|
}
|
|
if (data.error_uri) {
|
|
errorMessage += " (" + data.error_uri + ")";
|
|
}
|
|
return callback(new Error(errorMessage));
|
|
}
|
|
if (data.access_token) {
|
|
this.updateToken(data.access_token, data.expires_in);
|
|
return callback(null, this.accessToken);
|
|
}
|
|
return callback(new Error("No access token"));
|
|
});
|
|
}
|
|
buildXOAuth2Token(accessToken) {
|
|
let authData = ["user=" + (this.options.user || ""), "auth=Bearer " + (accessToken || this.accessToken), "", ""];
|
|
return Buffer.from(authData.join("\x01"), "utf-8").toString("base64");
|
|
}
|
|
postRequest(url, payload, params, callback) {
|
|
let returned = false;
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
let req = nmfetch(url, {
|
|
method: "post",
|
|
headers: params.customHeaders,
|
|
body: payload,
|
|
allowErrorResponse: true
|
|
});
|
|
req.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = req.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
req.once("error", (err) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(err);
|
|
});
|
|
req.once("end", () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(null, Buffer.concat(chunks, chunklen));
|
|
});
|
|
}
|
|
toBase64URL(data) {
|
|
if (typeof data === "string") {
|
|
data = Buffer.from(data);
|
|
}
|
|
return data.toString("base64").replace(/[=]+/g, "").replace(/\+/g, "-").replace(/\//g, "_");
|
|
}
|
|
jwtSignRS256(payload) {
|
|
payload = ['{"alg":"RS256","typ":"JWT"}', JSON.stringify(payload)].map((val) => this.toBase64URL(val)).join(".");
|
|
let signature = crypto2.createSign("RSA-SHA256").update(payload).sign(this.options.privateKey);
|
|
return payload + "." + this.toBase64URL(signature);
|
|
}
|
|
}
|
|
module.exports = XOAuth2;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-pool/pool-resource.js
|
|
var require_pool_resource = __commonJS((exports, module) => {
|
|
var SMTPConnection = require_smtp_connection();
|
|
var assign = require_shared().assign;
|
|
var XOAuth2 = require_xoauth2();
|
|
var EventEmitter = __require("events");
|
|
|
|
class PoolResource extends EventEmitter {
|
|
constructor(pool) {
|
|
super();
|
|
this.pool = pool;
|
|
this.options = pool.options;
|
|
this.logger = this.pool.logger;
|
|
if (this.options.auth) {
|
|
switch ((this.options.auth.type || "").toString().toUpperCase()) {
|
|
case "OAUTH2": {
|
|
let oauth2 = new XOAuth2(this.options.auth, this.logger);
|
|
oauth2.provisionCallback = this.pool.mailer && this.pool.mailer.get("oauth2_provision_cb") || oauth2.provisionCallback;
|
|
this.auth = {
|
|
type: "OAUTH2",
|
|
user: this.options.auth.user,
|
|
oauth2,
|
|
method: "XOAUTH2"
|
|
};
|
|
oauth2.on("token", (token) => this.pool.mailer.emit("token", token));
|
|
oauth2.on("error", (err) => this.emit("error", err));
|
|
break;
|
|
}
|
|
default:
|
|
if (!this.options.auth.user && !this.options.auth.pass) {
|
|
break;
|
|
}
|
|
this.auth = {
|
|
type: (this.options.auth.type || "").toString().toUpperCase() || "LOGIN",
|
|
user: this.options.auth.user,
|
|
credentials: {
|
|
user: this.options.auth.user || "",
|
|
pass: this.options.auth.pass,
|
|
options: this.options.auth.options
|
|
},
|
|
method: (this.options.auth.method || "").trim().toUpperCase() || this.options.authMethod || false
|
|
};
|
|
}
|
|
}
|
|
this._connection = false;
|
|
this._connected = false;
|
|
this.messages = 0;
|
|
this.available = true;
|
|
}
|
|
connect(callback) {
|
|
this.pool.getSocket(this.options, (err, socketOptions) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let returned = false;
|
|
let options = this.options;
|
|
if (socketOptions && socketOptions.connection) {
|
|
this.logger.info({
|
|
tnx: "proxy",
|
|
remoteAddress: socketOptions.connection.remoteAddress,
|
|
remotePort: socketOptions.connection.remotePort,
|
|
destHost: options.host || "",
|
|
destPort: options.port || "",
|
|
action: "connected"
|
|
}, "Using proxied socket from %s:%s to %s:%s", socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || "", options.port || "");
|
|
options = assign(false, options);
|
|
Object.keys(socketOptions).forEach((key) => {
|
|
options[key] = socketOptions[key];
|
|
});
|
|
}
|
|
this.connection = new SMTPConnection(options);
|
|
this.connection.once("error", (err2) => {
|
|
this.emit("error", err2);
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(err2);
|
|
});
|
|
this.connection.once("end", () => {
|
|
this.close();
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
let timer = setTimeout(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
let err2 = new Error("Unexpected socket close");
|
|
if (this.connection && this.connection._socket && this.connection._socket.upgrading) {
|
|
err2.code = "ETLS";
|
|
}
|
|
callback(err2);
|
|
}, 1000);
|
|
try {
|
|
timer.unref();
|
|
} catch (E) {
|
|
}
|
|
});
|
|
this.connection.connect(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
if (this.auth && (this.connection.allowsAuth || options.forceAuth)) {
|
|
this.connection.login(this.auth, (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
if (err2) {
|
|
this.connection.close();
|
|
this.emit("error", err2);
|
|
return callback(err2);
|
|
}
|
|
this._connected = true;
|
|
callback(null, true);
|
|
});
|
|
} else {
|
|
returned = true;
|
|
this._connected = true;
|
|
return callback(null, true);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
send(mail, callback) {
|
|
if (!this._connected) {
|
|
return this.connect((err) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
return this.send(mail, callback);
|
|
});
|
|
}
|
|
let envelope = mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId,
|
|
cid: this.id
|
|
}, "Sending message %s using #%s to <%s>", messageId, this.id, recipients.join(", "));
|
|
if (mail.data.dsn) {
|
|
envelope.dsn = mail.data.dsn;
|
|
}
|
|
this.connection.send(envelope, mail.message.createReadStream(), (err, info) => {
|
|
this.messages++;
|
|
if (err) {
|
|
this.connection.close();
|
|
this.emit("error", err);
|
|
return callback(err);
|
|
}
|
|
info.envelope = {
|
|
from: envelope.from,
|
|
to: envelope.to
|
|
};
|
|
info.messageId = messageId;
|
|
setImmediate(() => {
|
|
let err2;
|
|
if (this.messages >= this.options.maxMessages) {
|
|
err2 = new Error("Resource exhausted");
|
|
err2.code = "EMAXLIMIT";
|
|
this.connection.close();
|
|
this.emit("error", err2);
|
|
} else {
|
|
this.pool._checkRateLimit(() => {
|
|
this.available = true;
|
|
this.emit("available");
|
|
});
|
|
}
|
|
});
|
|
callback(null, info);
|
|
});
|
|
}
|
|
close() {
|
|
this._connected = false;
|
|
if (this.auth && this.auth.oauth2) {
|
|
this.auth.oauth2.removeAllListeners();
|
|
}
|
|
if (this.connection) {
|
|
this.connection.close();
|
|
}
|
|
this.emit("close");
|
|
}
|
|
}
|
|
module.exports = PoolResource;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/well-known/services.json
|
|
var require_services = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
"1und1": {
|
|
host: "smtp.1und1.de",
|
|
port: 465,
|
|
secure: true,
|
|
authMethod: "LOGIN"
|
|
},
|
|
Aliyun: {
|
|
domains: ["aliyun.com"],
|
|
host: "smtp.aliyun.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
AOL: {
|
|
domains: ["aol.com"],
|
|
host: "smtp.aol.com",
|
|
port: 587
|
|
},
|
|
Bluewin: {
|
|
host: "smtpauths.bluewin.ch",
|
|
domains: ["bluewin.ch"],
|
|
port: 465
|
|
},
|
|
DebugMail: {
|
|
host: "debugmail.io",
|
|
port: 25
|
|
},
|
|
DynectEmail: {
|
|
aliases: ["Dynect"],
|
|
host: "smtp.dynect.net",
|
|
port: 25
|
|
},
|
|
Ethereal: {
|
|
aliases: ["ethereal.email"],
|
|
host: "smtp.ethereal.email",
|
|
port: 587
|
|
},
|
|
FastMail: {
|
|
domains: ["fastmail.fm"],
|
|
host: "smtp.fastmail.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"Forward Email": {
|
|
aliases: ["FE", "ForwardEmail"],
|
|
domains: ["forwardemail.net"],
|
|
host: "smtp.forwardemail.net",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"Feishu Mail": {
|
|
aliases: ["Feishu", "FeishuMail"],
|
|
domains: ["www.feishu.cn"],
|
|
host: "smtp.feishu.cn",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
GandiMail: {
|
|
aliases: ["Gandi", "Gandi Mail"],
|
|
host: "mail.gandi.net",
|
|
port: 587
|
|
},
|
|
Gmail: {
|
|
aliases: ["Google Mail"],
|
|
domains: ["gmail.com", "googlemail.com"],
|
|
host: "smtp.gmail.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Godaddy: {
|
|
host: "smtpout.secureserver.net",
|
|
port: 25
|
|
},
|
|
GodaddyAsia: {
|
|
host: "smtp.asia.secureserver.net",
|
|
port: 25
|
|
},
|
|
GodaddyEurope: {
|
|
host: "smtp.europe.secureserver.net",
|
|
port: 25
|
|
},
|
|
"hot.ee": {
|
|
host: "mail.hot.ee"
|
|
},
|
|
Hotmail: {
|
|
aliases: ["Outlook", "Outlook.com", "Hotmail.com"],
|
|
domains: ["hotmail.com", "outlook.com"],
|
|
host: "smtp-mail.outlook.com",
|
|
port: 587
|
|
},
|
|
iCloud: {
|
|
aliases: ["Me", "Mac"],
|
|
domains: ["me.com", "mac.com"],
|
|
host: "smtp.mail.me.com",
|
|
port: 587
|
|
},
|
|
Infomaniak: {
|
|
host: "mail.infomaniak.com",
|
|
domains: ["ik.me", "ikmail.com", "etik.com"],
|
|
port: 587
|
|
},
|
|
Loopia: {
|
|
host: "mailcluster.loopia.se",
|
|
port: 465
|
|
},
|
|
"mail.ee": {
|
|
host: "smtp.mail.ee"
|
|
},
|
|
"Mail.ru": {
|
|
host: "smtp.mail.ru",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"Mailcatch.app": {
|
|
host: "sandbox-smtp.mailcatch.app",
|
|
port: 2525
|
|
},
|
|
Maildev: {
|
|
port: 1025,
|
|
ignoreTLS: true
|
|
},
|
|
Mailgun: {
|
|
host: "smtp.mailgun.org",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Mailjet: {
|
|
host: "in.mailjet.com",
|
|
port: 587
|
|
},
|
|
Mailosaur: {
|
|
host: "mailosaur.io",
|
|
port: 25
|
|
},
|
|
Mailtrap: {
|
|
host: "live.smtp.mailtrap.io",
|
|
port: 587
|
|
},
|
|
Mandrill: {
|
|
host: "smtp.mandrillapp.com",
|
|
port: 587
|
|
},
|
|
Naver: {
|
|
host: "smtp.naver.com",
|
|
port: 587
|
|
},
|
|
One: {
|
|
host: "send.one.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
OpenMailBox: {
|
|
aliases: ["OMB", "openmailbox.org"],
|
|
host: "smtp.openmailbox.org",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Outlook365: {
|
|
host: "smtp.office365.com",
|
|
port: 587,
|
|
secure: false
|
|
},
|
|
OhMySMTP: {
|
|
host: "smtp.ohmysmtp.com",
|
|
port: 587,
|
|
secure: false
|
|
},
|
|
Postmark: {
|
|
aliases: ["PostmarkApp"],
|
|
host: "smtp.postmarkapp.com",
|
|
port: 2525
|
|
},
|
|
"qiye.aliyun": {
|
|
host: "smtp.mxhichina.com",
|
|
port: "465",
|
|
secure: true
|
|
},
|
|
QQ: {
|
|
domains: ["qq.com"],
|
|
host: "smtp.qq.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
QQex: {
|
|
aliases: ["QQ Enterprise"],
|
|
domains: ["exmail.qq.com"],
|
|
host: "smtp.exmail.qq.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
SendCloud: {
|
|
host: "smtp.sendcloud.net",
|
|
port: 2525
|
|
},
|
|
SendGrid: {
|
|
host: "smtp.sendgrid.net",
|
|
port: 587
|
|
},
|
|
SendinBlue: {
|
|
aliases: ["Brevo"],
|
|
host: "smtp-relay.brevo.com",
|
|
port: 587
|
|
},
|
|
SendPulse: {
|
|
host: "smtp-pulse.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
SES: {
|
|
host: "email-smtp.us-east-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-US-EAST-1": {
|
|
host: "email-smtp.us-east-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-US-WEST-2": {
|
|
host: "email-smtp.us-west-2.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-EU-WEST-1": {
|
|
host: "email-smtp.eu-west-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-SOUTH-1": {
|
|
host: "email-smtp.ap-south-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-NORTHEAST-1": {
|
|
host: "email-smtp.ap-northeast-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-NORTHEAST-2": {
|
|
host: "email-smtp.ap-northeast-2.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-NORTHEAST-3": {
|
|
host: "email-smtp.ap-northeast-3.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-SOUTHEAST-1": {
|
|
host: "email-smtp.ap-southeast-1.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"SES-AP-SOUTHEAST-2": {
|
|
host: "email-smtp.ap-southeast-2.amazonaws.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Sparkpost: {
|
|
aliases: ["SparkPost", "SparkPost Mail"],
|
|
domains: ["sparkpost.com"],
|
|
host: "smtp.sparkpostmail.com",
|
|
port: 587,
|
|
secure: false
|
|
},
|
|
Tipimail: {
|
|
host: "smtp.tipimail.com",
|
|
port: 587
|
|
},
|
|
Yahoo: {
|
|
domains: ["yahoo.com"],
|
|
host: "smtp.mail.yahoo.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Yandex: {
|
|
domains: ["yandex.ru"],
|
|
host: "smtp.yandex.ru",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
Zoho: {
|
|
host: "smtp.zoho.com",
|
|
port: 465,
|
|
secure: true,
|
|
authMethod: "LOGIN"
|
|
},
|
|
"126": {
|
|
host: "smtp.126.com",
|
|
port: 465,
|
|
secure: true
|
|
},
|
|
"163": {
|
|
host: "smtp.163.com",
|
|
port: 465,
|
|
secure: true
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/well-known/index.js
|
|
var require_well_known = __commonJS((exports, module) => {
|
|
var services = require_services();
|
|
var normalized = {};
|
|
Object.keys(services).forEach((key) => {
|
|
let service = services[key];
|
|
normalized[normalizeKey(key)] = normalizeService(service);
|
|
[].concat(service.aliases || []).forEach((alias) => {
|
|
normalized[normalizeKey(alias)] = normalizeService(service);
|
|
});
|
|
[].concat(service.domains || []).forEach((domain) => {
|
|
normalized[normalizeKey(domain)] = normalizeService(service);
|
|
});
|
|
});
|
|
function normalizeKey(key) {
|
|
return key.replace(/[^a-zA-Z0-9.-]/g, "").toLowerCase();
|
|
}
|
|
function normalizeService(service) {
|
|
let filter = ["domains", "aliases"];
|
|
let response = {};
|
|
Object.keys(service).forEach((key) => {
|
|
if (filter.indexOf(key) < 0) {
|
|
response[key] = service[key];
|
|
}
|
|
});
|
|
return response;
|
|
}
|
|
module.exports = function(key) {
|
|
key = normalizeKey(key.split("@").pop());
|
|
return normalized[key] || false;
|
|
};
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-pool/index.js
|
|
var require_smtp_pool = __commonJS((exports, module) => {
|
|
var EventEmitter = __require("events");
|
|
var PoolResource = require_pool_resource();
|
|
var SMTPConnection = require_smtp_connection();
|
|
var wellKnown = require_well_known();
|
|
var shared = require_shared();
|
|
var packageData = require_package2();
|
|
|
|
class SMTPPool extends EventEmitter {
|
|
constructor(options) {
|
|
super();
|
|
options = options || {};
|
|
if (typeof options === "string") {
|
|
options = {
|
|
url: options
|
|
};
|
|
}
|
|
let urlData;
|
|
let service = options.service;
|
|
if (typeof options.getSocket === "function") {
|
|
this.getSocket = options.getSocket;
|
|
}
|
|
if (options.url) {
|
|
urlData = shared.parseConnectionUrl(options.url);
|
|
service = service || urlData.service;
|
|
}
|
|
this.options = shared.assign(false, options, urlData, service && wellKnown(service));
|
|
this.options.maxConnections = this.options.maxConnections || 5;
|
|
this.options.maxMessages = this.options.maxMessages || 100;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "smtp-pool"
|
|
});
|
|
let connection2 = new SMTPConnection(this.options);
|
|
this.name = "SMTP (pool)";
|
|
this.version = packageData.version + "[client:" + connection2.version + "]";
|
|
this._rateLimit = {
|
|
counter: 0,
|
|
timeout: null,
|
|
waiting: [],
|
|
checkpoint: false,
|
|
delta: Number(this.options.rateDelta) || 1000,
|
|
limit: Number(this.options.rateLimit) || 0
|
|
};
|
|
this._closed = false;
|
|
this._queue = [];
|
|
this._connections = [];
|
|
this._connectionCounter = 0;
|
|
this.idling = true;
|
|
setImmediate(() => {
|
|
if (this.idling) {
|
|
this.emit("idle");
|
|
}
|
|
});
|
|
}
|
|
getSocket(options, callback) {
|
|
return setImmediate(() => callback(null, false));
|
|
}
|
|
send(mail, callback) {
|
|
if (this._closed) {
|
|
return false;
|
|
}
|
|
this._queue.push({
|
|
mail,
|
|
requeueAttempts: 0,
|
|
callback
|
|
});
|
|
if (this.idling && this._queue.length >= this.options.maxConnections) {
|
|
this.idling = false;
|
|
}
|
|
setImmediate(() => this._processMessages());
|
|
return true;
|
|
}
|
|
close() {
|
|
let connection2;
|
|
let len = this._connections.length;
|
|
this._closed = true;
|
|
clearTimeout(this._rateLimit.timeout);
|
|
if (!len && !this._queue.length) {
|
|
return;
|
|
}
|
|
for (let i = len - 1;i >= 0; i--) {
|
|
if (this._connections[i] && this._connections[i].available) {
|
|
connection2 = this._connections[i];
|
|
connection2.close();
|
|
this.logger.info({
|
|
tnx: "connection",
|
|
cid: connection2.id,
|
|
action: "removed"
|
|
}, "Connection #%s removed", connection2.id);
|
|
}
|
|
}
|
|
if (len && !this._connections.length) {
|
|
this.logger.debug({
|
|
tnx: "connection"
|
|
}, "All connections removed");
|
|
}
|
|
if (!this._queue.length) {
|
|
return;
|
|
}
|
|
let invokeCallbacks = () => {
|
|
if (!this._queue.length) {
|
|
this.logger.debug({
|
|
tnx: "connection"
|
|
}, "Pending queue entries cleared");
|
|
return;
|
|
}
|
|
let entry = this._queue.shift();
|
|
if (entry && typeof entry.callback === "function") {
|
|
try {
|
|
entry.callback(new Error("Connection pool was closed"));
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "callback",
|
|
cid: connection2.id
|
|
}, "Callback error for #%s: %s", connection2.id, E.message);
|
|
}
|
|
}
|
|
setImmediate(invokeCallbacks);
|
|
};
|
|
setImmediate(invokeCallbacks);
|
|
}
|
|
_processMessages() {
|
|
let connection2;
|
|
let i, len;
|
|
if (this._closed) {
|
|
return;
|
|
}
|
|
if (!this._queue.length) {
|
|
if (!this.idling) {
|
|
this.idling = true;
|
|
this.emit("idle");
|
|
}
|
|
return;
|
|
}
|
|
for (i = 0, len = this._connections.length;i < len; i++) {
|
|
if (this._connections[i].available) {
|
|
connection2 = this._connections[i];
|
|
break;
|
|
}
|
|
}
|
|
if (!connection2 && this._connections.length < this.options.maxConnections) {
|
|
connection2 = this._createConnection();
|
|
}
|
|
if (!connection2) {
|
|
this.idling = false;
|
|
return;
|
|
}
|
|
if (!this.idling && this._queue.length < this.options.maxConnections) {
|
|
this.idling = true;
|
|
this.emit("idle");
|
|
}
|
|
let entry = connection2.queueEntry = this._queue.shift();
|
|
entry.messageId = (connection2.queueEntry.mail.message.getHeader("message-id") || "").replace(/[<>\s]/g, "");
|
|
connection2.available = false;
|
|
this.logger.debug({
|
|
tnx: "pool",
|
|
cid: connection2.id,
|
|
messageId: entry.messageId,
|
|
action: "assign"
|
|
}, "Assigned message <%s> to #%s (%s)", entry.messageId, connection2.id, connection2.messages + 1);
|
|
if (this._rateLimit.limit) {
|
|
this._rateLimit.counter++;
|
|
if (!this._rateLimit.checkpoint) {
|
|
this._rateLimit.checkpoint = Date.now();
|
|
}
|
|
}
|
|
connection2.send(entry.mail, (err, info) => {
|
|
if (entry === connection2.queueEntry) {
|
|
try {
|
|
entry.callback(err, info);
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "callback",
|
|
cid: connection2.id
|
|
}, "Callback error for #%s: %s", connection2.id, E.message);
|
|
}
|
|
connection2.queueEntry = false;
|
|
}
|
|
});
|
|
}
|
|
_createConnection() {
|
|
let connection2 = new PoolResource(this);
|
|
connection2.id = ++this._connectionCounter;
|
|
this.logger.info({
|
|
tnx: "pool",
|
|
cid: connection2.id,
|
|
action: "conection"
|
|
}, "Created new pool resource #%s", connection2.id);
|
|
connection2.on("available", () => {
|
|
this.logger.debug({
|
|
tnx: "connection",
|
|
cid: connection2.id,
|
|
action: "available"
|
|
}, "Connection #%s became available", connection2.id);
|
|
if (this._closed) {
|
|
this.close();
|
|
} else {
|
|
this._processMessages();
|
|
}
|
|
});
|
|
connection2.once("error", (err) => {
|
|
if (err.code !== "EMAXLIMIT") {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "pool",
|
|
cid: connection2.id
|
|
}, "Pool Error for #%s: %s", connection2.id, err.message);
|
|
} else {
|
|
this.logger.debug({
|
|
tnx: "pool",
|
|
cid: connection2.id,
|
|
action: "maxlimit"
|
|
}, "Max messages limit exchausted for #%s", connection2.id);
|
|
}
|
|
if (connection2.queueEntry) {
|
|
try {
|
|
connection2.queueEntry.callback(err);
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "callback",
|
|
cid: connection2.id
|
|
}, "Callback error for #%s: %s", connection2.id, E.message);
|
|
}
|
|
connection2.queueEntry = false;
|
|
}
|
|
this._removeConnection(connection2);
|
|
this._continueProcessing();
|
|
});
|
|
connection2.once("close", () => {
|
|
this.logger.info({
|
|
tnx: "connection",
|
|
cid: connection2.id,
|
|
action: "closed"
|
|
}, "Connection #%s was closed", connection2.id);
|
|
this._removeConnection(connection2);
|
|
if (connection2.queueEntry) {
|
|
setTimeout(() => {
|
|
if (connection2.queueEntry) {
|
|
if (this._shouldRequeuOnConnectionClose(connection2.queueEntry)) {
|
|
this._requeueEntryOnConnectionClose(connection2);
|
|
} else {
|
|
this._failDeliveryOnConnectionClose(connection2);
|
|
}
|
|
}
|
|
this._continueProcessing();
|
|
}, 50);
|
|
} else {
|
|
this._continueProcessing();
|
|
}
|
|
});
|
|
this._connections.push(connection2);
|
|
return connection2;
|
|
}
|
|
_shouldRequeuOnConnectionClose(queueEntry) {
|
|
if (this.options.maxRequeues === undefined || this.options.maxRequeues < 0) {
|
|
return true;
|
|
}
|
|
return queueEntry.requeueAttempts < this.options.maxRequeues;
|
|
}
|
|
_failDeliveryOnConnectionClose(connection2) {
|
|
if (connection2.queueEntry && connection2.queueEntry.callback) {
|
|
try {
|
|
connection2.queueEntry.callback(new Error("Reached maximum number of retries after connection was closed"));
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "callback",
|
|
messageId: connection2.queueEntry.messageId,
|
|
cid: connection2.id
|
|
}, "Callback error for #%s: %s", connection2.id, E.message);
|
|
}
|
|
connection2.queueEntry = false;
|
|
}
|
|
}
|
|
_requeueEntryOnConnectionClose(connection2) {
|
|
connection2.queueEntry.requeueAttempts = connection2.queueEntry.requeueAttempts + 1;
|
|
this.logger.debug({
|
|
tnx: "pool",
|
|
cid: connection2.id,
|
|
messageId: connection2.queueEntry.messageId,
|
|
action: "requeue"
|
|
}, "Re-queued message <%s> for #%s. Attempt: #%s", connection2.queueEntry.messageId, connection2.id, connection2.queueEntry.requeueAttempts);
|
|
this._queue.unshift(connection2.queueEntry);
|
|
connection2.queueEntry = false;
|
|
}
|
|
_continueProcessing() {
|
|
if (this._closed) {
|
|
this.close();
|
|
} else {
|
|
setTimeout(() => this._processMessages(), 100);
|
|
}
|
|
}
|
|
_removeConnection(connection2) {
|
|
let index = this._connections.indexOf(connection2);
|
|
if (index !== -1) {
|
|
this._connections.splice(index, 1);
|
|
}
|
|
}
|
|
_checkRateLimit(callback) {
|
|
if (!this._rateLimit.limit) {
|
|
return callback();
|
|
}
|
|
let now = Date.now();
|
|
if (this._rateLimit.counter < this._rateLimit.limit) {
|
|
return callback();
|
|
}
|
|
this._rateLimit.waiting.push(callback);
|
|
if (this._rateLimit.checkpoint <= now - this._rateLimit.delta) {
|
|
return this._clearRateLimit();
|
|
} else if (!this._rateLimit.timeout) {
|
|
this._rateLimit.timeout = setTimeout(() => this._clearRateLimit(), this._rateLimit.delta - (now - this._rateLimit.checkpoint));
|
|
this._rateLimit.checkpoint = now;
|
|
}
|
|
}
|
|
_clearRateLimit() {
|
|
clearTimeout(this._rateLimit.timeout);
|
|
this._rateLimit.timeout = null;
|
|
this._rateLimit.counter = 0;
|
|
this._rateLimit.checkpoint = false;
|
|
while (this._rateLimit.waiting.length) {
|
|
let cb = this._rateLimit.waiting.shift();
|
|
setImmediate(cb);
|
|
}
|
|
}
|
|
isIdle() {
|
|
return this.idling;
|
|
}
|
|
verify(callback) {
|
|
let promise;
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
let auth = new PoolResource(this).auth;
|
|
this.getSocket(this.options, (err, socketOptions) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let options = this.options;
|
|
if (socketOptions && socketOptions.connection) {
|
|
this.logger.info({
|
|
tnx: "proxy",
|
|
remoteAddress: socketOptions.connection.remoteAddress,
|
|
remotePort: socketOptions.connection.remotePort,
|
|
destHost: options.host || "",
|
|
destPort: options.port || "",
|
|
action: "connected"
|
|
}, "Using proxied socket from %s:%s to %s:%s", socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || "", options.port || "");
|
|
options = shared.assign(false, options);
|
|
Object.keys(socketOptions).forEach((key) => {
|
|
options[key] = socketOptions[key];
|
|
});
|
|
}
|
|
let connection2 = new SMTPConnection(options);
|
|
let returned = false;
|
|
connection2.once("error", (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
});
|
|
connection2.once("end", () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(new Error("Connection closed"));
|
|
});
|
|
let finalize = () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
connection2.quit();
|
|
return callback(null, true);
|
|
};
|
|
connection2.connect(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
if (auth && (connection2.allowsAuth || options.forceAuth)) {
|
|
connection2.login(auth, (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
if (err2) {
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
}
|
|
finalize();
|
|
});
|
|
} else if (!auth && connection2.allowsAuth && options.forceAuth) {
|
|
let err2 = new Error("Authentication info was not provided");
|
|
err2.code = "NoAuth";
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
} else {
|
|
finalize();
|
|
}
|
|
});
|
|
});
|
|
return promise;
|
|
}
|
|
}
|
|
module.exports = SMTPPool;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/smtp-transport/index.js
|
|
var require_smtp_transport = __commonJS((exports, module) => {
|
|
var EventEmitter = __require("events");
|
|
var SMTPConnection = require_smtp_connection();
|
|
var wellKnown = require_well_known();
|
|
var shared = require_shared();
|
|
var XOAuth2 = require_xoauth2();
|
|
var packageData = require_package2();
|
|
|
|
class SMTPTransport extends EventEmitter {
|
|
constructor(options) {
|
|
super();
|
|
options = options || {};
|
|
if (typeof options === "string") {
|
|
options = {
|
|
url: options
|
|
};
|
|
}
|
|
let urlData;
|
|
let service = options.service;
|
|
if (typeof options.getSocket === "function") {
|
|
this.getSocket = options.getSocket;
|
|
}
|
|
if (options.url) {
|
|
urlData = shared.parseConnectionUrl(options.url);
|
|
service = service || urlData.service;
|
|
}
|
|
this.options = shared.assign(false, options, urlData, service && wellKnown(service));
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "smtp-transport"
|
|
});
|
|
let connection2 = new SMTPConnection(this.options);
|
|
this.name = "SMTP";
|
|
this.version = packageData.version + "[client:" + connection2.version + "]";
|
|
if (this.options.auth) {
|
|
this.auth = this.getAuth({});
|
|
}
|
|
}
|
|
getSocket(options, callback) {
|
|
return setImmediate(() => callback(null, false));
|
|
}
|
|
getAuth(authOpts) {
|
|
if (!authOpts) {
|
|
return this.auth;
|
|
}
|
|
let hasAuth = false;
|
|
let authData = {};
|
|
if (this.options.auth && typeof this.options.auth === "object") {
|
|
Object.keys(this.options.auth).forEach((key) => {
|
|
hasAuth = true;
|
|
authData[key] = this.options.auth[key];
|
|
});
|
|
}
|
|
if (authOpts && typeof authOpts === "object") {
|
|
Object.keys(authOpts).forEach((key) => {
|
|
hasAuth = true;
|
|
authData[key] = authOpts[key];
|
|
});
|
|
}
|
|
if (!hasAuth) {
|
|
return false;
|
|
}
|
|
switch ((authData.type || "").toString().toUpperCase()) {
|
|
case "OAUTH2": {
|
|
if (!authData.service && !authData.user) {
|
|
return false;
|
|
}
|
|
let oauth2 = new XOAuth2(authData, this.logger);
|
|
oauth2.provisionCallback = this.mailer && this.mailer.get("oauth2_provision_cb") || oauth2.provisionCallback;
|
|
oauth2.on("token", (token) => this.mailer.emit("token", token));
|
|
oauth2.on("error", (err) => this.emit("error", err));
|
|
return {
|
|
type: "OAUTH2",
|
|
user: authData.user,
|
|
oauth2,
|
|
method: "XOAUTH2"
|
|
};
|
|
}
|
|
default:
|
|
return {
|
|
type: (authData.type || "").toString().toUpperCase() || "LOGIN",
|
|
user: authData.user,
|
|
credentials: {
|
|
user: authData.user || "",
|
|
pass: authData.pass,
|
|
options: authData.options
|
|
},
|
|
method: (authData.method || "").trim().toUpperCase() || this.options.authMethod || false
|
|
};
|
|
}
|
|
}
|
|
send(mail, callback) {
|
|
this.getSocket(this.options, (err, socketOptions) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let returned = false;
|
|
let options = this.options;
|
|
if (socketOptions && socketOptions.connection) {
|
|
this.logger.info({
|
|
tnx: "proxy",
|
|
remoteAddress: socketOptions.connection.remoteAddress,
|
|
remotePort: socketOptions.connection.remotePort,
|
|
destHost: options.host || "",
|
|
destPort: options.port || "",
|
|
action: "connected"
|
|
}, "Using proxied socket from %s:%s to %s:%s", socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || "", options.port || "");
|
|
options = shared.assign(false, options);
|
|
Object.keys(socketOptions).forEach((key) => {
|
|
options[key] = socketOptions[key];
|
|
});
|
|
}
|
|
let connection2 = new SMTPConnection(options);
|
|
connection2.once("error", (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
});
|
|
connection2.once("end", () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
let timer = setTimeout(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
let err2 = new Error("Unexpected socket close");
|
|
if (connection2 && connection2._socket && connection2._socket.upgrading) {
|
|
err2.code = "ETLS";
|
|
}
|
|
callback(err2);
|
|
}, 1000);
|
|
try {
|
|
timer.unref();
|
|
} catch (E) {
|
|
}
|
|
});
|
|
let sendMessage = () => {
|
|
let envelope = mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
if (mail.data.dsn) {
|
|
envelope.dsn = mail.data.dsn;
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId
|
|
}, "Sending message %s to <%s>", messageId, recipients.join(", "));
|
|
connection2.send(envelope, mail.message.createReadStream(), (err2, info) => {
|
|
returned = true;
|
|
connection2.close();
|
|
if (err2) {
|
|
this.logger.error({
|
|
err: err2,
|
|
tnx: "send"
|
|
}, "Send error for %s: %s", messageId, err2.message);
|
|
return callback(err2);
|
|
}
|
|
info.envelope = {
|
|
from: envelope.from,
|
|
to: envelope.to
|
|
};
|
|
info.messageId = messageId;
|
|
try {
|
|
return callback(null, info);
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "callback"
|
|
}, "Callback error for %s: %s", messageId, E.message);
|
|
}
|
|
});
|
|
};
|
|
connection2.connect(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
let auth = this.getAuth(mail.data.auth);
|
|
if (auth && (connection2.allowsAuth || options.forceAuth)) {
|
|
connection2.login(auth, (err2) => {
|
|
if (auth && auth !== this.auth && auth.oauth2) {
|
|
auth.oauth2.removeAllListeners();
|
|
}
|
|
if (returned) {
|
|
return;
|
|
}
|
|
if (err2) {
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
}
|
|
sendMessage();
|
|
});
|
|
} else {
|
|
sendMessage();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
verify(callback) {
|
|
let promise;
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
this.getSocket(this.options, (err, socketOptions) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let options = this.options;
|
|
if (socketOptions && socketOptions.connection) {
|
|
this.logger.info({
|
|
tnx: "proxy",
|
|
remoteAddress: socketOptions.connection.remoteAddress,
|
|
remotePort: socketOptions.connection.remotePort,
|
|
destHost: options.host || "",
|
|
destPort: options.port || "",
|
|
action: "connected"
|
|
}, "Using proxied socket from %s:%s to %s:%s", socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || "", options.port || "");
|
|
options = shared.assign(false, options);
|
|
Object.keys(socketOptions).forEach((key) => {
|
|
options[key] = socketOptions[key];
|
|
});
|
|
}
|
|
let connection2 = new SMTPConnection(options);
|
|
let returned = false;
|
|
connection2.once("error", (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
});
|
|
connection2.once("end", () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
return callback(new Error("Connection closed"));
|
|
});
|
|
let finalize = () => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
connection2.quit();
|
|
return callback(null, true);
|
|
};
|
|
connection2.connect(() => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
let authData = this.getAuth({});
|
|
if (authData && (connection2.allowsAuth || options.forceAuth)) {
|
|
connection2.login(authData, (err2) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
if (err2) {
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
}
|
|
finalize();
|
|
});
|
|
} else if (!authData && connection2.allowsAuth && options.forceAuth) {
|
|
let err2 = new Error("Authentication info was not provided");
|
|
err2.code = "NoAuth";
|
|
returned = true;
|
|
connection2.close();
|
|
return callback(err2);
|
|
} else {
|
|
finalize();
|
|
}
|
|
});
|
|
});
|
|
return promise;
|
|
}
|
|
close() {
|
|
if (this.auth && this.auth.oauth2) {
|
|
this.auth.oauth2.removeAllListeners();
|
|
}
|
|
this.emit("close");
|
|
}
|
|
}
|
|
module.exports = SMTPTransport;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/sendmail-transport/index.js
|
|
var require_sendmail_transport = __commonJS((exports, module) => {
|
|
var spawn = __require("child_process").spawn;
|
|
var packageData = require_package2();
|
|
var shared = require_shared();
|
|
|
|
class SendmailTransport {
|
|
constructor(options) {
|
|
options = options || {};
|
|
this._spawn = spawn;
|
|
this.options = options || {};
|
|
this.name = "Sendmail";
|
|
this.version = packageData.version;
|
|
this.path = "sendmail";
|
|
this.args = false;
|
|
this.winbreak = false;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "sendmail"
|
|
});
|
|
if (options) {
|
|
if (typeof options === "string") {
|
|
this.path = options;
|
|
} else if (typeof options === "object") {
|
|
if (options.path) {
|
|
this.path = options.path;
|
|
}
|
|
if (Array.isArray(options.args)) {
|
|
this.args = options.args;
|
|
}
|
|
this.winbreak = ["win", "windows", "dos", "\r\n"].includes((options.newline || "").toString().toLowerCase());
|
|
}
|
|
}
|
|
}
|
|
send(mail, done) {
|
|
mail.message.keepBcc = true;
|
|
let envelope = mail.data.envelope || mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let args;
|
|
let sendmail;
|
|
let returned;
|
|
const hasInvalidAddresses = [].concat(envelope.from || []).concat(envelope.to || []).some((addr) => /^-/.test(addr));
|
|
if (hasInvalidAddresses) {
|
|
return done(new Error("Can not send mail. Invalid envelope addresses."));
|
|
}
|
|
if (this.args) {
|
|
args = ["-i"].concat(this.args).concat(envelope.to);
|
|
} else {
|
|
args = ["-i"].concat(envelope.from ? ["-f", envelope.from] : []).concat(envelope.to);
|
|
}
|
|
let callback = (err) => {
|
|
if (returned) {
|
|
return;
|
|
}
|
|
returned = true;
|
|
if (typeof done === "function") {
|
|
if (err) {
|
|
return done(err);
|
|
} else {
|
|
return done(null, {
|
|
envelope: mail.data.envelope || mail.message.getEnvelope(),
|
|
messageId,
|
|
response: "Messages queued for delivery"
|
|
});
|
|
}
|
|
}
|
|
};
|
|
try {
|
|
sendmail = this._spawn(this.path, args);
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "spawn",
|
|
messageId
|
|
}, "Error occurred while spawning sendmail. %s", E.message);
|
|
return callback(E);
|
|
}
|
|
if (sendmail) {
|
|
sendmail.on("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "spawn",
|
|
messageId
|
|
}, "Error occurred when sending message %s. %s", messageId, err.message);
|
|
callback(err);
|
|
});
|
|
sendmail.once("exit", (code) => {
|
|
if (!code) {
|
|
return callback();
|
|
}
|
|
let err;
|
|
if (code === 127) {
|
|
err = new Error("Sendmail command not found, process exited with code " + code);
|
|
} else {
|
|
err = new Error("Sendmail exited with code " + code);
|
|
}
|
|
this.logger.error({
|
|
err,
|
|
tnx: "stdin",
|
|
messageId
|
|
}, "Error sending message %s to sendmail. %s", messageId, err.message);
|
|
callback(err);
|
|
});
|
|
sendmail.once("close", callback);
|
|
sendmail.stdin.on("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "stdin",
|
|
messageId
|
|
}, "Error occurred when piping message %s to sendmail. %s", messageId, err.message);
|
|
callback(err);
|
|
});
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId
|
|
}, "Sending message %s to <%s>", messageId, recipients.join(", "));
|
|
let sourceStream = mail.message.createReadStream();
|
|
sourceStream.once("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "stdin",
|
|
messageId
|
|
}, "Error occurred when generating message %s. %s", messageId, err.message);
|
|
sendmail.kill("SIGINT");
|
|
callback(err);
|
|
});
|
|
sourceStream.pipe(sendmail.stdin);
|
|
} else {
|
|
return callback(new Error("sendmail was not found"));
|
|
}
|
|
}
|
|
}
|
|
module.exports = SendmailTransport;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/stream-transport/index.js
|
|
var require_stream_transport = __commonJS((exports, module) => {
|
|
var packageData = require_package2();
|
|
var shared = require_shared();
|
|
|
|
class StreamTransport {
|
|
constructor(options) {
|
|
options = options || {};
|
|
this.options = options || {};
|
|
this.name = "StreamTransport";
|
|
this.version = packageData.version;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "stream-transport"
|
|
});
|
|
this.winbreak = ["win", "windows", "dos", "\r\n"].includes((options.newline || "").toString().toLowerCase());
|
|
}
|
|
send(mail, done) {
|
|
mail.message.keepBcc = true;
|
|
let envelope = mail.data.envelope || mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId
|
|
}, "Sending message %s to <%s> using %s line breaks", messageId, recipients.join(", "), this.winbreak ? "<CR><LF>" : "<LF>");
|
|
setImmediate(() => {
|
|
let stream;
|
|
try {
|
|
stream = mail.message.createReadStream();
|
|
} catch (E) {
|
|
this.logger.error({
|
|
err: E,
|
|
tnx: "send",
|
|
messageId
|
|
}, "Creating send stream failed for %s. %s", messageId, E.message);
|
|
return done(E);
|
|
}
|
|
if (!this.options.buffer) {
|
|
stream.once("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "send",
|
|
messageId
|
|
}, "Failed creating message for %s. %s", messageId, err.message);
|
|
});
|
|
return done(null, {
|
|
envelope: mail.data.envelope || mail.message.getEnvelope(),
|
|
messageId,
|
|
message: stream
|
|
});
|
|
}
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
stream.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = stream.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
stream.once("error", (err) => {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "send",
|
|
messageId
|
|
}, "Failed creating message for %s. %s", messageId, err.message);
|
|
return done(err);
|
|
});
|
|
stream.on("end", () => done(null, {
|
|
envelope: mail.data.envelope || mail.message.getEnvelope(),
|
|
messageId,
|
|
message: Buffer.concat(chunks, chunklen)
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
module.exports = StreamTransport;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/json-transport/index.js
|
|
var require_json_transport = __commonJS((exports, module) => {
|
|
var packageData = require_package2();
|
|
var shared = require_shared();
|
|
|
|
class JSONTransport {
|
|
constructor(options) {
|
|
options = options || {};
|
|
this.options = options || {};
|
|
this.name = "JSONTransport";
|
|
this.version = packageData.version;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "json-transport"
|
|
});
|
|
}
|
|
send(mail, done) {
|
|
mail.message.keepBcc = true;
|
|
let envelope = mail.data.envelope || mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId
|
|
}, "Composing JSON structure of %s to <%s>", messageId, recipients.join(", "));
|
|
setImmediate(() => {
|
|
mail.normalize((err, data) => {
|
|
if (err) {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "send",
|
|
messageId
|
|
}, "Failed building JSON structure for %s. %s", messageId, err.message);
|
|
return done(err);
|
|
}
|
|
delete data.envelope;
|
|
delete data.normalizedHeaders;
|
|
return done(null, {
|
|
envelope,
|
|
messageId,
|
|
message: this.options.skipEncoding ? data : JSON.stringify(data)
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}
|
|
module.exports = JSONTransport;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/ses-transport/index.js
|
|
var require_ses_transport = __commonJS((exports, module) => {
|
|
var EventEmitter = __require("events");
|
|
var packageData = require_package2();
|
|
var shared = require_shared();
|
|
var LeWindows = require_le_windows();
|
|
|
|
class SESTransport extends EventEmitter {
|
|
constructor(options) {
|
|
super();
|
|
options = options || {};
|
|
this.options = options || {};
|
|
this.ses = this.options.SES;
|
|
this.name = "SESTransport";
|
|
this.version = packageData.version;
|
|
this.logger = shared.getLogger(this.options, {
|
|
component: this.options.component || "ses-transport"
|
|
});
|
|
this.maxConnections = Number(this.options.maxConnections) || Infinity;
|
|
this.connections = 0;
|
|
this.sendingRate = Number(this.options.sendingRate) || Infinity;
|
|
this.sendingRateTTL = null;
|
|
this.rateInterval = 1000;
|
|
this.rateMessages = [];
|
|
this.pending = [];
|
|
this.idling = true;
|
|
setImmediate(() => {
|
|
if (this.idling) {
|
|
this.emit("idle");
|
|
}
|
|
});
|
|
}
|
|
send(mail, callback) {
|
|
if (this.connections >= this.maxConnections) {
|
|
this.idling = false;
|
|
return this.pending.push({
|
|
mail,
|
|
callback
|
|
});
|
|
}
|
|
if (!this._checkSendingRate()) {
|
|
this.idling = false;
|
|
return this.pending.push({
|
|
mail,
|
|
callback
|
|
});
|
|
}
|
|
this._send(mail, (...args) => {
|
|
setImmediate(() => callback(...args));
|
|
this._sent();
|
|
});
|
|
}
|
|
_checkRatedQueue() {
|
|
if (this.connections >= this.maxConnections || !this._checkSendingRate()) {
|
|
return;
|
|
}
|
|
if (!this.pending.length) {
|
|
if (!this.idling) {
|
|
this.idling = true;
|
|
this.emit("idle");
|
|
}
|
|
return;
|
|
}
|
|
let next = this.pending.shift();
|
|
this._send(next.mail, (...args) => {
|
|
setImmediate(() => next.callback(...args));
|
|
this._sent();
|
|
});
|
|
}
|
|
_checkSendingRate() {
|
|
clearTimeout(this.sendingRateTTL);
|
|
let now = Date.now();
|
|
let oldest = false;
|
|
for (let i = this.rateMessages.length - 1;i >= 0; i--) {
|
|
if (this.rateMessages[i].ts >= now - this.rateInterval && (!oldest || this.rateMessages[i].ts < oldest)) {
|
|
oldest = this.rateMessages[i].ts;
|
|
}
|
|
if (this.rateMessages[i].ts < now - this.rateInterval && !this.rateMessages[i].pending) {
|
|
this.rateMessages.splice(i, 1);
|
|
}
|
|
}
|
|
if (this.rateMessages.length < this.sendingRate) {
|
|
return true;
|
|
}
|
|
let delay = Math.max(oldest + 1001, now + 20);
|
|
this.sendingRateTTL = setTimeout(() => this._checkRatedQueue(), now - delay);
|
|
try {
|
|
this.sendingRateTTL.unref();
|
|
} catch (E) {
|
|
}
|
|
return false;
|
|
}
|
|
_sent() {
|
|
this.connections--;
|
|
this._checkRatedQueue();
|
|
}
|
|
isIdle() {
|
|
return this.idling;
|
|
}
|
|
_send(mail, callback) {
|
|
let statObject = {
|
|
ts: Date.now(),
|
|
pending: true
|
|
};
|
|
this.connections++;
|
|
this.rateMessages.push(statObject);
|
|
let envelope = mail.data.envelope || mail.message.getEnvelope();
|
|
let messageId = mail.message.messageId();
|
|
let recipients = [].concat(envelope.to || []);
|
|
if (recipients.length > 3) {
|
|
recipients.push("...and " + recipients.splice(2).length + " more");
|
|
}
|
|
this.logger.info({
|
|
tnx: "send",
|
|
messageId
|
|
}, "Sending message %s to <%s>", messageId, recipients.join(", "));
|
|
let getRawMessage = (next) => {
|
|
if (!mail.data._dkim) {
|
|
mail.data._dkim = {};
|
|
}
|
|
if (mail.data._dkim.skipFields && typeof mail.data._dkim.skipFields === "string") {
|
|
mail.data._dkim.skipFields += ":date:message-id";
|
|
} else {
|
|
mail.data._dkim.skipFields = "date:message-id";
|
|
}
|
|
let sourceStream = mail.message.createReadStream();
|
|
let stream = sourceStream.pipe(new LeWindows);
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
stream.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = stream.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
sourceStream.once("error", (err) => stream.emit("error", err));
|
|
stream.once("error", (err) => {
|
|
next(err);
|
|
});
|
|
stream.once("end", () => next(null, Buffer.concat(chunks, chunklen)));
|
|
};
|
|
setImmediate(() => getRawMessage((err, raw) => {
|
|
if (err) {
|
|
this.logger.error({
|
|
err,
|
|
tnx: "send",
|
|
messageId
|
|
}, "Failed creating message for %s. %s", messageId, err.message);
|
|
statObject.pending = false;
|
|
return callback(err);
|
|
}
|
|
let sesMessage = {
|
|
RawMessage: {
|
|
Data: raw
|
|
},
|
|
Source: envelope.from,
|
|
Destinations: envelope.to
|
|
};
|
|
Object.keys(mail.data.ses || {}).forEach((key) => {
|
|
sesMessage[key] = mail.data.ses[key];
|
|
});
|
|
let ses = (this.ses.aws ? this.ses.ses : this.ses) || {};
|
|
let aws = this.ses.aws || {};
|
|
let getRegion = (cb) => {
|
|
if (ses.config && typeof ses.config.region === "function") {
|
|
return ses.config.region().then((region) => cb(null, region)).catch((err2) => cb(err2));
|
|
}
|
|
return cb(null, ses.config && ses.config.region || "us-east-1");
|
|
};
|
|
getRegion((err2, region) => {
|
|
if (err2 || !region) {
|
|
region = "us-east-1";
|
|
}
|
|
let sendPromise;
|
|
if (typeof ses.send === "function" && aws.SendRawEmailCommand) {
|
|
sendPromise = ses.send(new aws.SendRawEmailCommand(sesMessage));
|
|
} else {
|
|
sendPromise = ses.sendRawEmail(sesMessage).promise();
|
|
}
|
|
sendPromise.then((data) => {
|
|
if (region === "us-east-1") {
|
|
region = "email";
|
|
}
|
|
statObject.pending = false;
|
|
callback(null, {
|
|
envelope: {
|
|
from: envelope.from,
|
|
to: envelope.to
|
|
},
|
|
messageId: "<" + data.MessageId + (!/@/.test(data.MessageId) ? "@" + region + ".amazonses.com" : "") + ">",
|
|
response: data.MessageId,
|
|
raw
|
|
});
|
|
}).catch((err3) => {
|
|
this.logger.error({
|
|
err: err3,
|
|
tnx: "send"
|
|
}, "Send error for %s: %s", messageId, err3.message);
|
|
statObject.pending = false;
|
|
callback(err3);
|
|
});
|
|
});
|
|
}));
|
|
}
|
|
verify(callback) {
|
|
let promise;
|
|
let ses = (this.ses.aws ? this.ses.ses : this.ses) || {};
|
|
let aws = this.ses.aws || {};
|
|
const sesMessage = {
|
|
RawMessage: {
|
|
Data: "From: invalid@invalid\r\nTo: invalid@invalid\r\n Subject: Invalid\r\n\r\nInvalid"
|
|
},
|
|
Source: "invalid@invalid",
|
|
Destinations: ["invalid@invalid"]
|
|
};
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
const cb = (err) => {
|
|
if (err && (err.code || err.Code) !== "InvalidParameterValue") {
|
|
return callback(err);
|
|
}
|
|
return callback(null, true);
|
|
};
|
|
if (typeof ses.send === "function" && aws.SendRawEmailCommand) {
|
|
sesMessage.RawMessage.Data = Buffer.from(sesMessage.RawMessage.Data);
|
|
ses.send(new aws.SendRawEmailCommand(sesMessage), cb);
|
|
} else {
|
|
ses.sendRawEmail(sesMessage, cb);
|
|
}
|
|
return promise;
|
|
}
|
|
}
|
|
module.exports = SESTransport;
|
|
});
|
|
|
|
// node_modules/nodemailer/lib/nodemailer.js
|
|
var require_nodemailer = __commonJS((exports, module) => {
|
|
var Mailer = require_mailer();
|
|
var shared = require_shared();
|
|
var SMTPPool = require_smtp_pool();
|
|
var SMTPTransport = require_smtp_transport();
|
|
var SendmailTransport = require_sendmail_transport();
|
|
var StreamTransport = require_stream_transport();
|
|
var JSONTransport = require_json_transport();
|
|
var SESTransport = require_ses_transport();
|
|
var nmfetch = require_fetch();
|
|
var packageData = require_package2();
|
|
var ETHEREAL_API = (process.env.ETHEREAL_API || "https://api.nodemailer.com").replace(/\/+$/, "");
|
|
var ETHEREAL_WEB = (process.env.ETHEREAL_WEB || "https://ethereal.email").replace(/\/+$/, "");
|
|
var ETHEREAL_API_KEY = (process.env.ETHEREAL_API_KEY || "").replace(/\s*/g, "") || null;
|
|
var ETHEREAL_CACHE = ["true", "yes", "y", "1"].includes((process.env.ETHEREAL_CACHE || "yes").toString().trim().toLowerCase());
|
|
var testAccount = false;
|
|
exports.createTransport = function(transporter, defaults) {
|
|
let urlConfig;
|
|
let options;
|
|
let mailer;
|
|
if (typeof transporter === "object" && typeof transporter.send !== "function" || typeof transporter === "string" && /^(smtps?|direct):/i.test(transporter)) {
|
|
if (urlConfig = typeof transporter === "string" ? transporter : transporter.url) {
|
|
options = shared.parseConnectionUrl(urlConfig);
|
|
} else {
|
|
options = transporter;
|
|
}
|
|
if (options.pool) {
|
|
transporter = new SMTPPool(options);
|
|
} else if (options.sendmail) {
|
|
transporter = new SendmailTransport(options);
|
|
} else if (options.streamTransport) {
|
|
transporter = new StreamTransport(options);
|
|
} else if (options.jsonTransport) {
|
|
transporter = new JSONTransport(options);
|
|
} else if (options.SES) {
|
|
transporter = new SESTransport(options);
|
|
} else {
|
|
transporter = new SMTPTransport(options);
|
|
}
|
|
}
|
|
mailer = new Mailer(transporter, options, defaults);
|
|
return mailer;
|
|
};
|
|
exports.createTestAccount = function(apiUrl, callback) {
|
|
let promise;
|
|
if (!callback && typeof apiUrl === "function") {
|
|
callback = apiUrl;
|
|
apiUrl = false;
|
|
}
|
|
if (!callback) {
|
|
promise = new Promise((resolve, reject) => {
|
|
callback = shared.callbackPromise(resolve, reject);
|
|
});
|
|
}
|
|
if (ETHEREAL_CACHE && testAccount) {
|
|
setImmediate(() => callback(null, testAccount));
|
|
return promise;
|
|
}
|
|
apiUrl = apiUrl || ETHEREAL_API;
|
|
let chunks = [];
|
|
let chunklen = 0;
|
|
let requestHeaders = {};
|
|
let requestBody = {
|
|
requestor: packageData.name,
|
|
version: packageData.version
|
|
};
|
|
if (ETHEREAL_API_KEY) {
|
|
requestHeaders.Authorization = "Bearer " + ETHEREAL_API_KEY;
|
|
}
|
|
let req = nmfetch(apiUrl + "/user", {
|
|
contentType: "application/json",
|
|
method: "POST",
|
|
headers: requestHeaders,
|
|
body: Buffer.from(JSON.stringify(requestBody))
|
|
});
|
|
req.on("readable", () => {
|
|
let chunk;
|
|
while ((chunk = req.read()) !== null) {
|
|
chunks.push(chunk);
|
|
chunklen += chunk.length;
|
|
}
|
|
});
|
|
req.once("error", (err) => callback(err));
|
|
req.once("end", () => {
|
|
let res = Buffer.concat(chunks, chunklen);
|
|
let data;
|
|
let err;
|
|
try {
|
|
data = JSON.parse(res.toString());
|
|
} catch (E) {
|
|
err = E;
|
|
}
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
if (data.status !== "success" || data.error) {
|
|
return callback(new Error(data.error || "Request failed"));
|
|
}
|
|
delete data.status;
|
|
testAccount = data;
|
|
callback(null, testAccount);
|
|
});
|
|
return promise;
|
|
};
|
|
exports.getTestMessageUrl = function(info) {
|
|
if (!info || !info.response) {
|
|
return false;
|
|
}
|
|
let infoProps = new Map;
|
|
info.response.replace(/\[([^\]]+)\]$/, (m, props) => {
|
|
props.replace(/\b([A-Z0-9]+)=([^\s]+)/g, (m2, key, value) => {
|
|
infoProps.set(key, value);
|
|
});
|
|
});
|
|
if (infoProps.has("STATUS") && infoProps.has("MSGID")) {
|
|
return (testAccount.web || ETHEREAL_WEB) + "/message/" + infoProps.get("MSGID");
|
|
}
|
|
return false;
|
|
};
|
|
});
|
|
|
|
// package-shared/utils/backend/parseCookies.ts
|
|
function parseCookies({
|
|
request,
|
|
cookieString
|
|
}) {
|
|
try {
|
|
const cookieStr = request ? request.headers.cookie : cookieString ? cookieString : undefined;
|
|
if (!cookieStr)
|
|
return {};
|
|
if (!cookieStr || typeof cookieStr !== "string") {
|
|
return {};
|
|
}
|
|
const cookieSplitArray = cookieStr.split(";");
|
|
let cookieObject = {};
|
|
cookieSplitArray.forEach((keyValueString) => {
|
|
const [key, value] = keyValueString.split("=");
|
|
if (key && typeof key == "string") {
|
|
const parsedKey = key.replace(/^ +| +$/, "");
|
|
cookieObject[parsedKey] = value && typeof value == "string" ? value.replace(/^ +| +$/, "") : "";
|
|
}
|
|
});
|
|
return cookieObject;
|
|
} catch (error) {
|
|
console.log(`ERROR parsing cookies: ${error.message}`);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// node_modules/generate-password/src/generate.js
|
|
var require_generate = __commonJS((exports, module) => {
|
|
var crypto2 = __require("crypto");
|
|
var RANDOM_BATCH_SIZE = 256;
|
|
var randomIndex;
|
|
var randomBytes;
|
|
var getNextRandomValue = function() {
|
|
if (randomIndex === undefined || randomIndex >= randomBytes.length) {
|
|
randomIndex = 0;
|
|
randomBytes = crypto2.randomBytes(RANDOM_BATCH_SIZE);
|
|
}
|
|
var result = randomBytes[randomIndex];
|
|
randomIndex += 1;
|
|
return result;
|
|
};
|
|
var randomNumber = function(max) {
|
|
var rand = getNextRandomValue();
|
|
while (rand >= 256 - 256 % max) {
|
|
rand = getNextRandomValue();
|
|
}
|
|
return rand % max;
|
|
};
|
|
var lowercase = "abcdefghijklmnopqrstuvwxyz";
|
|
var uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
var numbers = "0123456789";
|
|
var symbols = '!@#$%^&*()+_-=}{[]|:;"/?.><,`~';
|
|
var similarCharacters = /[ilLI|`oO0]/g;
|
|
var strictRules = [
|
|
{ name: "lowercase", rule: /[a-z]/ },
|
|
{ name: "uppercase", rule: /[A-Z]/ },
|
|
{ name: "numbers", rule: /[0-9]/ },
|
|
{ name: "symbols", rule: /[!@#$%^&*()+_\-=}{[\]|:;"/?.><,`~]/ }
|
|
];
|
|
var generate = function(options, pool) {
|
|
var password = "", optionsLength = options.length, poolLength = pool.length;
|
|
for (var i = 0;i < optionsLength; i++) {
|
|
password += pool[randomNumber(poolLength)];
|
|
}
|
|
if (options.strict) {
|
|
var fitsRules = strictRules.every(function(rule) {
|
|
if (options[rule.name] == false)
|
|
return true;
|
|
if (rule.name === "symbols" && typeof options[rule.name] === "string") {
|
|
var re = new RegExp("[" + options[rule.name] + "]");
|
|
return re.test(password);
|
|
}
|
|
return rule.rule.test(password);
|
|
});
|
|
if (!fitsRules)
|
|
return generate(options, pool);
|
|
}
|
|
return password;
|
|
};
|
|
exports.generate = function(options) {
|
|
options = options || {};
|
|
if (!Object.prototype.hasOwnProperty.call(options, "length"))
|
|
options.length = 10;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "numbers"))
|
|
options.numbers = false;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "symbols"))
|
|
options.symbols = false;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "exclude"))
|
|
options.exclude = "";
|
|
if (!Object.prototype.hasOwnProperty.call(options, "uppercase"))
|
|
options.uppercase = true;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "lowercase"))
|
|
options.lowercase = true;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "excludeSimilarCharacters"))
|
|
options.excludeSimilarCharacters = false;
|
|
if (!Object.prototype.hasOwnProperty.call(options, "strict"))
|
|
options.strict = false;
|
|
if (options.strict) {
|
|
var minStrictLength = 1 + (options.numbers ? 1 : 0) + (options.symbols ? 1 : 0) + (options.uppercase ? 1 : 0);
|
|
if (minStrictLength > options.length) {
|
|
throw new TypeError("Length must correlate with strict guidelines");
|
|
}
|
|
}
|
|
var pool = "";
|
|
if (options.lowercase) {
|
|
pool += lowercase;
|
|
}
|
|
if (options.uppercase) {
|
|
pool += uppercase;
|
|
}
|
|
if (options.numbers) {
|
|
pool += numbers;
|
|
}
|
|
if (options.symbols) {
|
|
if (typeof options.symbols === "string") {
|
|
pool += options.symbols;
|
|
} else {
|
|
pool += symbols;
|
|
}
|
|
}
|
|
if (!pool) {
|
|
throw new TypeError("At least one rule for pools must be true");
|
|
}
|
|
if (options.excludeSimilarCharacters) {
|
|
pool = pool.replace(similarCharacters, "");
|
|
}
|
|
var i = options.exclude.length;
|
|
while (i--) {
|
|
pool = pool.replace(options.exclude[i], "");
|
|
}
|
|
var password = generate(options, pool);
|
|
return password;
|
|
};
|
|
exports.generateMultiple = function(amount, options) {
|
|
var passwords = [];
|
|
for (var i = 0;i < amount; i++) {
|
|
passwords[i] = exports.generate(options);
|
|
}
|
|
return passwords;
|
|
};
|
|
});
|
|
|
|
// package-shared/functions/api/users/api-delete-user.ts
|
|
async function apiDeleteUser({
|
|
dbFullName,
|
|
deletedUserId,
|
|
useLocal
|
|
}) {
|
|
const existingUserQuery = `SELECT * FROM users WHERE id = ?`;
|
|
const existingUserValues = [deletedUserId];
|
|
const existingUser = await varDatabaseDbHandler2({
|
|
queryString: existingUserQuery,
|
|
queryValuesArray: existingUserValues,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
if (!existingUser?.[0]) {
|
|
return {
|
|
success: false,
|
|
msg: "User not found"
|
|
};
|
|
}
|
|
const deleteUser = await deleteDbEntry({
|
|
dbContext: "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: "users",
|
|
identifierColumnName: "id",
|
|
identifierValue: deletedUserId,
|
|
useLocal
|
|
});
|
|
return {
|
|
success: true,
|
|
result: deleteUser
|
|
};
|
|
}
|
|
var init_api_delete_user = __esm(() => {
|
|
init_deleteDbEntry();
|
|
init_varDatabaseDbHandler();
|
|
});
|
|
|
|
// users/delete-user.ts
|
|
var exports_delete_user = {};
|
|
__export(exports_delete_user, {
|
|
default: () => deleteUser
|
|
});
|
|
import path16 from "path";
|
|
import fs21 from "fs";
|
|
async function deleteUser({
|
|
key,
|
|
database,
|
|
user_id,
|
|
useLocal,
|
|
deletedUserId
|
|
}) {
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path16.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs21.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiDeleteUser({
|
|
dbFullName: DSQL_DB_NAME,
|
|
useLocal,
|
|
deletedUserId
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
database,
|
|
deletedUserId
|
|
});
|
|
const httpsRequest2 = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY || key
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/delete-user`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest2.write(reqPayload);
|
|
httpsRequest2.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
var init_delete_user = __esm(() => {
|
|
init_grab_host_names();
|
|
init_api_delete_user();
|
|
});
|
|
|
|
// users/validate-temp-email-code.ts
|
|
var exports_validate_temp_email_code = {};
|
|
__export(exports_validate_temp_email_code, {
|
|
default: () => validateTempEmailCode
|
|
});
|
|
async function validateTempEmailCode({
|
|
request,
|
|
email,
|
|
cookieString
|
|
}) {
|
|
try {
|
|
const keyNames = getAuthCookieNames();
|
|
const oneTimeCodeCookieName = keyNames.oneTimeCodeName;
|
|
const cookies = parseCookies({ request, cookieString });
|
|
const encryptedOneTimeCode = cookies[oneTimeCodeCookieName];
|
|
const encryptedPayload = decrypt({
|
|
encryptedString: encryptedOneTimeCode
|
|
});
|
|
const payload = ejson_default.parse(encryptedPayload);
|
|
if (payload?.email && !email) {
|
|
return payload;
|
|
}
|
|
if (payload?.email && payload.email === email) {
|
|
return payload;
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
console.log("validateTempEmailCode error:", error.message);
|
|
return null;
|
|
}
|
|
}
|
|
var init_validate_temp_email_code = __esm(() => {
|
|
init_decrypt();
|
|
init_ejson();
|
|
});
|
|
|
|
// utils/get.ts
|
|
init_grab_host_names();
|
|
import path from "path";
|
|
import fs4 from "fs";
|
|
|
|
// package-shared/functions/api/query/get.ts
|
|
var import_lodash = __toESM(require_lodash(), 1);
|
|
init_serverError();
|
|
|
|
// package-shared/functions/backend/fullAccessDbHandler.ts
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_LOCAL_DB_HANDLER();
|
|
init_parseDbResults();
|
|
init_serverError();
|
|
async function fullAccessDbHandler({
|
|
queryString,
|
|
database,
|
|
tableSchema,
|
|
queryValuesArray,
|
|
local
|
|
}) {
|
|
let results;
|
|
try {
|
|
results = local ? await LOCAL_DB_HANDLER(queryString, queryValuesArray) : await DSQL_USER_DB_HANDLER({
|
|
paradigm: "Full Access",
|
|
database,
|
|
queryString,
|
|
queryValues: queryValuesArray
|
|
});
|
|
} catch (error) {
|
|
serverError({
|
|
component: "fullAccessDbHandler",
|
|
message: error.message
|
|
});
|
|
return error.message;
|
|
}
|
|
if (results && tableSchema) {
|
|
const unparsedResults = results;
|
|
const parsedResults = await parseDbResults({
|
|
unparsedResults,
|
|
tableSchema
|
|
});
|
|
return parsedResults;
|
|
} else if (results) {
|
|
return results;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/varReadOnlyDatabaseDbHandler.ts
|
|
init_serverError();
|
|
init_parseDbResults();
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_LOCAL_DB_HANDLER();
|
|
async function varReadOnlyDatabaseDbHandler({
|
|
queryString,
|
|
database,
|
|
queryValuesArray,
|
|
tableSchema,
|
|
useLocal
|
|
}) {
|
|
let results;
|
|
try {
|
|
results = useLocal ? await LOCAL_DB_HANDLER(queryString, queryValuesArray) : await DSQL_USER_DB_HANDLER({
|
|
paradigm: "Read Only",
|
|
database,
|
|
queryString,
|
|
queryValues: queryValuesArray
|
|
});
|
|
} catch (error) {
|
|
serverError({
|
|
component: "varReadOnlyDatabaseDbHandler",
|
|
message: error.message,
|
|
noMail: true
|
|
});
|
|
return error.message;
|
|
}
|
|
if (results) {
|
|
const unparsedResults = results;
|
|
const parsedResults = await parseDbResults({
|
|
unparsedResults,
|
|
tableSchema
|
|
});
|
|
return parsedResults;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/db/runQuery.ts
|
|
init_serverError();
|
|
|
|
// package-shared/functions/backend/db/addDbEntry.ts
|
|
var import_sanitize_html2 = __toESM(require_sanitize_html(), 1);
|
|
|
|
// package-shared/functions/backend/html/sanitizeHtmlOptions.ts
|
|
var sanitizeHtmlOptions = {
|
|
allowedTags: [
|
|
"b",
|
|
"i",
|
|
"em",
|
|
"strong",
|
|
"a",
|
|
"p",
|
|
"span",
|
|
"ul",
|
|
"ol",
|
|
"li",
|
|
"h1",
|
|
"h2",
|
|
"h3",
|
|
"h4",
|
|
"h5",
|
|
"h6",
|
|
"img",
|
|
"div",
|
|
"button",
|
|
"pre",
|
|
"code",
|
|
"br"
|
|
],
|
|
allowedAttributes: {
|
|
a: ["href"],
|
|
img: ["src", "alt", "width", "height", "class", "style"],
|
|
"*": ["style", "class"]
|
|
}
|
|
};
|
|
var sanitizeHtmlOptions_default = sanitizeHtmlOptions;
|
|
|
|
// package-shared/functions/backend/db/updateDbEntry.ts
|
|
var import_sanitize_html = __toESM(require_sanitize_html(), 1);
|
|
init_DB_HANDLER();
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_encrypt();
|
|
init_LOCAL_DB_HANDLER();
|
|
async function updateDbEntry({
|
|
dbContext,
|
|
paradigm,
|
|
dbFullName,
|
|
tableName,
|
|
data,
|
|
tableSchema,
|
|
identifierColumnName,
|
|
identifierValue,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
useLocal
|
|
}) {
|
|
if (!data || !Object.keys(data).length)
|
|
return null;
|
|
const isMaster = useLocal ? true : dbContext?.match(/dsql.user/i) ? false : dbFullName && !dbFullName.match(/^datasquirel$/) ? false : true;
|
|
const dbHandler = useLocal ? LOCAL_DB_HANDLER : isMaster ? DB_HANDLER : DSQL_USER_DB_HANDLER;
|
|
const dataKeys = Object.keys(data);
|
|
let updateKeyValueArray = [];
|
|
let updateValues = [];
|
|
for (let i = 0;i < dataKeys.length; i++) {
|
|
try {
|
|
const dataKey = dataKeys[i];
|
|
let value = data[dataKey];
|
|
const targetFieldSchemaArray = tableSchema ? tableSchema?.fields?.filter((field) => field.fieldName === dataKey) : null;
|
|
const targetFieldSchema = targetFieldSchemaArray && targetFieldSchemaArray[0] ? targetFieldSchemaArray[0] : null;
|
|
if (value == null || value == undefined)
|
|
continue;
|
|
const htmlRegex = /<[^>]+>/g;
|
|
if (targetFieldSchema?.richText || String(value).match(htmlRegex)) {
|
|
value = import_sanitize_html.default(value, sanitizeHtmlOptions_default);
|
|
}
|
|
if (targetFieldSchema?.encrypted) {
|
|
value = encrypt({
|
|
data: value,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
});
|
|
}
|
|
if (typeof value === "object") {
|
|
value = JSON.stringify(value);
|
|
}
|
|
if (targetFieldSchema?.pattern) {
|
|
const pattern = new RegExp(targetFieldSchema.pattern, targetFieldSchema.patternFlags || "");
|
|
if (!pattern.test(value)) {
|
|
console.log("DSQL: Pattern not matched =>", value);
|
|
value = "";
|
|
}
|
|
}
|
|
if (typeof value === "string" && value.match(/^null$/i)) {
|
|
value = {
|
|
toSqlString: function() {
|
|
return "NULL";
|
|
}
|
|
};
|
|
}
|
|
if (typeof value === "string" && !value.match(/./i)) {
|
|
value = {
|
|
toSqlString: function() {
|
|
return "NULL";
|
|
}
|
|
};
|
|
}
|
|
updateKeyValueArray.push(`\`${dataKey}\`=?`);
|
|
if (typeof value == "number") {
|
|
updateValues.push(String(value));
|
|
} else {
|
|
updateValues.push(value);
|
|
}
|
|
} catch (error) {
|
|
console.log("DSQL: Error in parsing data keys in update function =>", error.message);
|
|
continue;
|
|
}
|
|
}
|
|
updateKeyValueArray.push(`date_updated='${Date()}'`);
|
|
updateKeyValueArray.push(`date_updated_code='${Date.now()}'`);
|
|
const query = `UPDATE ${tableName} SET ${updateKeyValueArray.join(",")} WHERE \`${identifierColumnName}\`=?`;
|
|
updateValues.push(identifierValue);
|
|
const updatedEntry = isMaster ? await dbHandler(query, updateValues) : await dbHandler({
|
|
paradigm,
|
|
database: dbFullName,
|
|
queryString: query,
|
|
queryValues: updateValues
|
|
});
|
|
return updatedEntry;
|
|
}
|
|
|
|
// package-shared/functions/backend/db/addDbEntry.ts
|
|
init_DB_HANDLER();
|
|
init_DSQL_USER_DB_HANDLER();
|
|
init_encrypt();
|
|
init_LOCAL_DB_HANDLER();
|
|
async function addDbEntry({
|
|
dbContext,
|
|
paradigm,
|
|
dbFullName,
|
|
tableName,
|
|
data,
|
|
tableSchema,
|
|
duplicateColumnName,
|
|
duplicateColumnValue,
|
|
update,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
useLocal
|
|
}) {
|
|
const isMaster = useLocal ? true : dbContext?.match(/dsql.user/i) ? false : dbFullName && !dbFullName.match(/^datasquirel$/) ? false : true;
|
|
const dbHandler = useLocal ? LOCAL_DB_HANDLER : isMaster ? DB_HANDLER : DSQL_USER_DB_HANDLER;
|
|
if (data?.["date_created_timestamp"])
|
|
delete data["date_created_timestamp"];
|
|
if (data?.["date_updated_timestamp"])
|
|
delete data["date_updated_timestamp"];
|
|
if (data?.["date_updated"])
|
|
delete data["date_updated"];
|
|
if (data?.["date_updated_code"])
|
|
delete data["date_updated_code"];
|
|
if (data?.["date_created"])
|
|
delete data["date_created"];
|
|
if (data?.["date_created_code"])
|
|
delete data["date_created_code"];
|
|
if (duplicateColumnName && typeof duplicateColumnName === "string") {
|
|
const duplicateValue = isMaster ? await dbHandler(`SELECT * FROM \`${tableName}\` WHERE \`${duplicateColumnName}\`=?`, [duplicateColumnValue]) : await dbHandler({
|
|
paradigm: "Read Only",
|
|
database: dbFullName,
|
|
queryString: `SELECT * FROM \`${tableName}\` WHERE \`${duplicateColumnName}\`=?`,
|
|
queryValues: [duplicateColumnValue]
|
|
});
|
|
if (duplicateValue?.[0] && !update) {
|
|
return null;
|
|
} else if (duplicateValue && duplicateValue[0] && update) {
|
|
return await updateDbEntry({
|
|
dbContext,
|
|
paradigm,
|
|
dbFullName,
|
|
tableName,
|
|
data,
|
|
tableSchema,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
identifierColumnName: duplicateColumnName,
|
|
identifierValue: duplicateColumnValue || ""
|
|
});
|
|
}
|
|
}
|
|
const dataKeys = Object.keys(data);
|
|
let insertKeysArray = [];
|
|
let insertValuesArray = [];
|
|
for (let i = 0;i < dataKeys.length; i++) {
|
|
try {
|
|
const dataKey = dataKeys[i];
|
|
let value = data?.[dataKey];
|
|
const targetFieldSchemaArray = tableSchema ? tableSchema?.fields?.filter((field) => field.fieldName == dataKey) : null;
|
|
const targetFieldSchema = targetFieldSchemaArray && targetFieldSchemaArray[0] ? targetFieldSchemaArray[0] : null;
|
|
if (value == null || value == undefined)
|
|
continue;
|
|
if (targetFieldSchema?.dataType?.match(/int$/i) && typeof value == "string" && !value?.match(/./))
|
|
continue;
|
|
if (targetFieldSchema?.encrypted) {
|
|
value = encrypt({
|
|
data: value,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
});
|
|
console.log("DSQL: Encrypted value =>", value);
|
|
}
|
|
const htmlRegex = /<[^>]+>/g;
|
|
if (targetFieldSchema?.richText || String(value).match(htmlRegex)) {
|
|
value = import_sanitize_html2.default(value, sanitizeHtmlOptions_default);
|
|
}
|
|
if (targetFieldSchema?.pattern) {
|
|
const pattern = new RegExp(targetFieldSchema.pattern, targetFieldSchema.patternFlags || "");
|
|
if (!pattern.test(value)) {
|
|
console.log("DSQL: Pattern not matched =>", value);
|
|
value = "";
|
|
}
|
|
}
|
|
insertKeysArray.push("`" + dataKey + "`");
|
|
if (typeof value === "object") {
|
|
value = JSON.stringify(value);
|
|
}
|
|
if (typeof value == "number") {
|
|
insertValuesArray.push(String(value));
|
|
} else {
|
|
insertValuesArray.push(value);
|
|
}
|
|
} catch (error) {
|
|
console.log("DSQL: Error in parsing data keys =>", error.message);
|
|
continue;
|
|
}
|
|
}
|
|
if (!data?.["date_created"]) {
|
|
insertKeysArray.push("`date_created`");
|
|
insertValuesArray.push(Date());
|
|
}
|
|
if (!data?.["date_created_code"]) {
|
|
insertKeysArray.push("`date_created_code`");
|
|
insertValuesArray.push(Date.now());
|
|
}
|
|
if (!data?.["date_updated"]) {
|
|
insertKeysArray.push("`date_updated`");
|
|
insertValuesArray.push(Date());
|
|
}
|
|
if (!data?.["date_updated_code"]) {
|
|
insertKeysArray.push("`date_updated_code`");
|
|
insertValuesArray.push(Date.now());
|
|
}
|
|
const query = `INSERT INTO \`${tableName}\` (${insertKeysArray.join(",")}) VALUES (${insertValuesArray.map(() => "?").join(",")})`;
|
|
const queryValuesArray = insertValuesArray;
|
|
const newInsert = isMaster ? await dbHandler(query, queryValuesArray) : await dbHandler({
|
|
paradigm,
|
|
database: dbFullName,
|
|
queryString: query,
|
|
queryValues: queryValuesArray
|
|
});
|
|
return newInsert;
|
|
}
|
|
|
|
// package-shared/functions/backend/db/runQuery.ts
|
|
init_deleteDbEntry();
|
|
|
|
// package-shared/utils/trim-sql.ts
|
|
function trimSql(sql) {
|
|
return sql.replace(/\n|\r|\n\r|\r\n/gm, " ").replace(/ {2,}/g, " ").trim();
|
|
}
|
|
|
|
// package-shared/functions/backend/db/runQuery.ts
|
|
async function runQuery({
|
|
dbFullName,
|
|
query,
|
|
readOnly,
|
|
dbSchema,
|
|
queryValuesArray,
|
|
tableName,
|
|
local
|
|
}) {
|
|
let result;
|
|
let error;
|
|
let tableSchema;
|
|
if (dbSchema) {
|
|
try {
|
|
const table = tableName ? tableName : typeof query == "string" ? null : query ? query?.table : null;
|
|
if (!table)
|
|
throw new Error("No table name provided");
|
|
tableSchema = dbSchema.tables.filter((tb) => tb?.tableName === table)[0];
|
|
} catch (_err) {
|
|
}
|
|
}
|
|
try {
|
|
if (typeof query === "string") {
|
|
const formattedQuery = trimSql(query);
|
|
if (readOnly && formattedQuery.match(/^alter|^delete|information_schema|^create/i)) {
|
|
throw new Error("Wrong Input!");
|
|
}
|
|
if (readOnly) {
|
|
result = await varReadOnlyDatabaseDbHandler({
|
|
queryString: formattedQuery,
|
|
queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
|
|
database: dbFullName,
|
|
tableSchema,
|
|
useLocal: local
|
|
});
|
|
} else {
|
|
result = await fullAccessDbHandler({
|
|
queryString: formattedQuery,
|
|
queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
|
|
database: dbFullName,
|
|
tableSchema,
|
|
local
|
|
});
|
|
}
|
|
} else if (typeof query === "object") {
|
|
const {
|
|
data,
|
|
action,
|
|
table,
|
|
identifierColumnName,
|
|
identifierValue,
|
|
update,
|
|
duplicateColumnName,
|
|
duplicateColumnValue
|
|
} = query;
|
|
switch (action.toLowerCase()) {
|
|
case "insert":
|
|
result = await addDbEntry({
|
|
dbContext: local ? "Master" : "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: table,
|
|
data,
|
|
update,
|
|
duplicateColumnName,
|
|
duplicateColumnValue,
|
|
tableSchema,
|
|
useLocal: local
|
|
});
|
|
if (!result?.insertId) {
|
|
error = new Error("Couldn't insert data");
|
|
}
|
|
break;
|
|
case "update":
|
|
result = await updateDbEntry({
|
|
dbContext: local ? "Master" : "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: table,
|
|
data,
|
|
identifierColumnName,
|
|
identifierValue,
|
|
tableSchema,
|
|
useLocal: local
|
|
});
|
|
break;
|
|
case "delete":
|
|
result = await deleteDbEntry({
|
|
dbContext: local ? "Master" : "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: table,
|
|
identifierColumnName,
|
|
identifierValue,
|
|
tableSchema,
|
|
useLocal: local
|
|
});
|
|
break;
|
|
default:
|
|
result = null;
|
|
break;
|
|
}
|
|
}
|
|
} catch (error2) {
|
|
serverError({
|
|
component: "functions/backend/runQuery",
|
|
message: error2.message
|
|
});
|
|
result = null;
|
|
error2 = error2.message;
|
|
}
|
|
return { result, error };
|
|
}
|
|
|
|
// package-shared/functions/api/query/get.ts
|
|
async function apiGet({
|
|
query,
|
|
dbFullName,
|
|
queryValues,
|
|
tableName,
|
|
dbSchema,
|
|
useLocal
|
|
}) {
|
|
if (typeof query == "string" && query.match(/^alter|^delete|information_schema|databases|^create/i)) {
|
|
return { success: false, msg: "Wrong Input." };
|
|
}
|
|
let results;
|
|
try {
|
|
let { result, error } = await runQuery({
|
|
dbFullName,
|
|
query,
|
|
queryValuesArray: queryValues,
|
|
readOnly: true,
|
|
dbSchema,
|
|
tableName,
|
|
local: useLocal
|
|
});
|
|
let tableSchema;
|
|
if (dbSchema) {
|
|
const targetTable = dbSchema.tables.find((table) => table.tableName === tableName);
|
|
if (targetTable) {
|
|
const clonedTargetTable = import_lodash.default.cloneDeep(targetTable);
|
|
delete clonedTargetTable.childTable;
|
|
delete clonedTargetTable.childTableDbFullName;
|
|
delete clonedTargetTable.childTableName;
|
|
delete clonedTargetTable.childrenTables;
|
|
delete clonedTargetTable.updateData;
|
|
delete clonedTargetTable.tableNameOld;
|
|
delete clonedTargetTable.indexes;
|
|
tableSchema = clonedTargetTable;
|
|
}
|
|
}
|
|
if (error)
|
|
throw error;
|
|
if (result.error)
|
|
throw new Error(result.error);
|
|
results = result;
|
|
const resObject = {
|
|
success: true,
|
|
payload: results,
|
|
schema: tableName && tableSchema ? tableSchema : undefined
|
|
};
|
|
return resObject;
|
|
} catch (error) {
|
|
serverError({
|
|
component: "/api/query/get/lines-85-94",
|
|
message: error.message
|
|
});
|
|
return { success: false, payload: null, error: error.message };
|
|
}
|
|
}
|
|
|
|
// package-shared/utils/serialize-query.ts
|
|
init_ejson();
|
|
function serializeQuery(query) {
|
|
let str = "?";
|
|
if (typeof query !== "object") {
|
|
console.log("Invalid Query type");
|
|
return str;
|
|
}
|
|
if (Array.isArray(query)) {
|
|
console.log("Query is an Array. This is invalid.");
|
|
return str;
|
|
}
|
|
if (!query) {
|
|
console.log("No Query provided.");
|
|
return str;
|
|
}
|
|
const keys = Object.keys(query);
|
|
const queryArr = [];
|
|
keys.forEach((key) => {
|
|
if (!key || !query[key])
|
|
return;
|
|
const value = query[key];
|
|
if (typeof value === "object") {
|
|
const jsonStr = ejson_default.stringify(value);
|
|
queryArr.push(`${key}=${encodeURIComponent(String(jsonStr))}`);
|
|
} else if (typeof value === "string" || typeof value === "number") {
|
|
queryArr.push(`${key}=${encodeURIComponent(value)}`);
|
|
} else {
|
|
queryArr.push(`${key}=${String(value)}`);
|
|
}
|
|
});
|
|
str += queryArr.join("&");
|
|
return str;
|
|
}
|
|
|
|
// utils/get.ts
|
|
async function get({
|
|
key,
|
|
db,
|
|
query,
|
|
queryValues,
|
|
tableName,
|
|
useLocal,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs4.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiGet({
|
|
dbFullName: DSQL_DB_NAME,
|
|
query,
|
|
queryValues,
|
|
tableName,
|
|
dbSchema,
|
|
useLocal
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const queryObject = {
|
|
db: process.env.DSQL_API_DB_NAME || String(db),
|
|
query: String(query.replace(/\n|\r|\n\r/g, "").replace(/ {2,}/g, " ")),
|
|
queryValues: queryValues ? JSON.stringify(queryValues) : undefined,
|
|
tableName
|
|
};
|
|
const queryString = serializeQuery({ ...queryObject });
|
|
let path2 = `/api/query/${user_id || grabedHostNames.user_id}/get${queryString}`;
|
|
const requestObject = {
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Authorization: key || process.env.DSQL_READ_ONLY_API_KEY || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: path2
|
|
};
|
|
scheme.request(requestObject, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
try {
|
|
resolve(JSON.parse(str));
|
|
} catch (error) {
|
|
reject({
|
|
error: error.message,
|
|
result: str
|
|
});
|
|
}
|
|
});
|
|
response.on("error", (err) => {
|
|
console.log("DSQL get Error,", err.message);
|
|
resolve(null);
|
|
});
|
|
}).end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
|
|
// utils/post.ts
|
|
init_grab_host_names();
|
|
import path2 from "path";
|
|
import fs5 from "fs";
|
|
|
|
// package-shared/functions/api/query/post.ts
|
|
var import_lodash2 = __toESM(require_lodash(), 1);
|
|
init_serverError();
|
|
async function apiPost({
|
|
query,
|
|
dbFullName,
|
|
queryValues,
|
|
tableName,
|
|
dbSchema,
|
|
useLocal
|
|
}) {
|
|
if (typeof query === "string" && query?.match(/^create |^alter |^drop /i)) {
|
|
return { success: false, msg: "Wrong Input" };
|
|
}
|
|
if (typeof query === "object" && query?.action?.match(/^create |^alter |^drop /i)) {
|
|
return { success: false, msg: "Wrong Input" };
|
|
}
|
|
let results;
|
|
try {
|
|
let { result, error } = await runQuery({
|
|
dbFullName,
|
|
query,
|
|
dbSchema,
|
|
queryValuesArray: queryValues,
|
|
tableName,
|
|
local: useLocal
|
|
});
|
|
results = result;
|
|
if (error)
|
|
throw error;
|
|
let tableSchema;
|
|
if (dbSchema) {
|
|
const targetTable = dbSchema.tables.find((table) => table.tableName === tableName);
|
|
if (targetTable) {
|
|
const clonedTargetTable = import_lodash2.default.cloneDeep(targetTable);
|
|
delete clonedTargetTable.childTable;
|
|
delete clonedTargetTable.childTableDbFullName;
|
|
delete clonedTargetTable.childTableName;
|
|
delete clonedTargetTable.childrenTables;
|
|
delete clonedTargetTable.updateData;
|
|
delete clonedTargetTable.tableNameOld;
|
|
delete clonedTargetTable.indexes;
|
|
tableSchema = clonedTargetTable;
|
|
}
|
|
}
|
|
return {
|
|
success: true,
|
|
payload: results,
|
|
error,
|
|
schema: tableName && tableSchema ? tableSchema : undefined
|
|
};
|
|
} catch (error) {
|
|
serverError({
|
|
component: "/api/query/post/lines-132-142",
|
|
message: error.message
|
|
});
|
|
return {
|
|
success: false,
|
|
payload: results,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
// utils/post.ts
|
|
async function post({
|
|
key,
|
|
query,
|
|
queryValues,
|
|
database,
|
|
tableName,
|
|
useLocal,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path2.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs5.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiPost({
|
|
dbFullName: DSQL_DB_NAME,
|
|
query,
|
|
dbSchema,
|
|
queryValues,
|
|
tableName,
|
|
useLocal
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayloadString = JSON.stringify({
|
|
query,
|
|
queryValues,
|
|
database: process.env.DSQL_API_DB_NAME || database,
|
|
tableName: tableName ? tableName : null
|
|
}).replace(/\n|\r|\n\r/gm, "");
|
|
try {
|
|
JSON.parse(reqPayloadString);
|
|
} catch (error) {
|
|
console.log(error);
|
|
console.log(reqPayloadString);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
error: "Query object is invalid. Please Check query data values"
|
|
};
|
|
}
|
|
const reqPayload = reqPayloadString;
|
|
const requPath = `/api/query/${user_id || grabedHostNames.user_id}/post`;
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: requPath
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
try {
|
|
resolve(JSON.parse(str));
|
|
} catch (error) {
|
|
console.log("Route ERROR:", error.message);
|
|
resolve({
|
|
success: false,
|
|
payload: null,
|
|
error: error.message,
|
|
errPayload: str
|
|
});
|
|
}
|
|
});
|
|
response.on("error", (err) => {
|
|
resolve({
|
|
success: false,
|
|
payload: null,
|
|
error: err.message
|
|
});
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.on("error", (error) => {
|
|
console.log("HTTPS request ERROR =>", error);
|
|
});
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
|
|
// utils/get-schema.ts
|
|
init_grab_host_names();
|
|
async function getSchema({
|
|
key,
|
|
database,
|
|
field,
|
|
table,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const queryObject = { database, field, table };
|
|
let query = Object.keys(queryObject).filter((k) => queryObject[k]).map((k) => `${k}=${queryObject[k]}`).join("&");
|
|
scheme.request({
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/query/${user_id || grabedHostNames.user_id}/get-schema` + (query?.match(/./) ? `?${query}` : "")
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
resolve(null);
|
|
});
|
|
}).end();
|
|
});
|
|
return {
|
|
success: true,
|
|
payload: httpResponse
|
|
};
|
|
}
|
|
|
|
// utils/upload-image.ts
|
|
init_grab_host_names();
|
|
async function uploadImage({
|
|
key,
|
|
payload,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
try {
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify(payload);
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/query/${user_id || grabedHostNames.user_id}/add-image`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
} catch (error) {
|
|
console.log("Error in uploading image: ", error.message);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
module_upload_image.exports = uploadImage;
|
|
|
|
// utils/upload-file.ts
|
|
init_grab_host_names();
|
|
async function uploadImage2({
|
|
key,
|
|
payload,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
try {
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify(payload);
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/query/${user_id || grabedHostNames.user_id}/add-file`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
} catch (error) {
|
|
console.log("Error in uploading file: ", error.message);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
// utils/delete-file.ts
|
|
init_grab_host_names();
|
|
async function deleteFile({
|
|
key,
|
|
url,
|
|
user_id
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
try {
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({ url });
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/query/${user_id || grabedHostNames.user_id}/delete-file`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
} catch (error) {
|
|
console.log("Error deleting file: ", error.message);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
module_delete_file.exports = deleteFile;
|
|
|
|
// users/add-user.ts
|
|
init_grab_host_names();
|
|
import path7 from "path";
|
|
import fs11 from "fs";
|
|
|
|
// package-shared/functions/backend/addUsersTableToDb.ts
|
|
init_serverError();
|
|
init_DB_HANDLER();
|
|
|
|
// package-shared/functions/backend/grabUserSchemaData.ts
|
|
init_serverError();
|
|
import fs6 from "fs";
|
|
import path3 from "path";
|
|
function grabUserSchemaData({
|
|
userId
|
|
}) {
|
|
try {
|
|
const userSchemaFilePath = path3.resolve(process.cwd(), `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${userId}/main.json`);
|
|
const userSchemaData = JSON.parse(fs6.readFileSync(userSchemaFilePath, "utf-8"));
|
|
return userSchemaData;
|
|
} catch (error) {
|
|
serverError({
|
|
component: "grabUserSchemaData",
|
|
message: error.message
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/setUserSchemaData.ts
|
|
init_serverError();
|
|
import fs7 from "fs";
|
|
import path4 from "path";
|
|
function setUserSchemaData({
|
|
userId,
|
|
schemaData
|
|
}) {
|
|
try {
|
|
const userSchemaFilePath = path4.resolve(process.cwd(), `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${userId}/main.json`);
|
|
fs7.writeFileSync(userSchemaFilePath, JSON.stringify(schemaData), "utf8");
|
|
return true;
|
|
} catch (error) {
|
|
serverError({
|
|
component: "/functions/backend/setUserSchemaData",
|
|
message: error.message
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// package-shared/shell/createDbFromSchema.ts
|
|
import path6 from "path";
|
|
import fs10 from "fs";
|
|
|
|
// package-shared/shell/utils/dbHandler.ts
|
|
var import_serverless_mysql4 = __toESM(require_serverless_mysql(), 1);
|
|
init_grabDbSSL();
|
|
import fs8 from "fs";
|
|
import path5 from "path";
|
|
var __dirname = "/home/benoti/Projects/Git/moduletrace/datasquirel/datasquirel/package-shared/shell/utils";
|
|
var connection = import_serverless_mysql4.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_USERNAME,
|
|
password: process.env.DSQL_DB_PASSWORD,
|
|
database: process.env.DSQL_DB_NAME,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
async function dbHandler({
|
|
query,
|
|
values,
|
|
database
|
|
}) {
|
|
let isDbCorrect = true;
|
|
if (database) {
|
|
connection = import_serverless_mysql4.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_USERNAME,
|
|
password: process.env.DSQL_DB_PASSWORD,
|
|
database,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
}
|
|
if (!isDbCorrect) {
|
|
console.log("Shell Db Handler ERROR in switching Database! Operation Failed!");
|
|
return null;
|
|
}
|
|
let results;
|
|
try {
|
|
if (query && values) {
|
|
results = await connection.query(query, values);
|
|
} else {
|
|
results = await connection.query(query);
|
|
}
|
|
await connection.end();
|
|
} catch (error) {
|
|
if (process.env.FIRST_RUN) {
|
|
return null;
|
|
}
|
|
console.log("ERROR in dbHandler =>", error.message);
|
|
console.log(error);
|
|
console.log(connection.config());
|
|
fs8.appendFileSync(path5.resolve(__dirname, "../.tmp/dbErrorLogs.txt"), JSON.stringify(error, null, 4) + "\n" + Date() + "\n\n\n", "utf8");
|
|
results = null;
|
|
}
|
|
if (results) {
|
|
return JSON.parse(JSON.stringify(results));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/shell/utils/noDatabaseDbHandler.ts
|
|
async function noDatabaseDbHandler(queryString) {
|
|
let results;
|
|
try {
|
|
results = await dbHandler({ query: queryString });
|
|
} catch (error) {
|
|
console.log("ERROR in noDatabaseDbHandler =>", error.message);
|
|
}
|
|
if (results) {
|
|
return results;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/shell/utils/varDatabaseDbHandler.ts
|
|
async function varDatabaseDbHandler({
|
|
queryString,
|
|
queryValuesArray,
|
|
database,
|
|
tableSchema
|
|
}) {
|
|
let results;
|
|
try {
|
|
if (queryString && queryValuesArray && Array.isArray(queryValuesArray) && queryValuesArray[0]) {
|
|
results = await dbHandler({
|
|
query: queryString,
|
|
values: queryValuesArray,
|
|
database
|
|
});
|
|
} else {
|
|
results = await dbHandler({
|
|
query: queryString,
|
|
database
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.log("Shell Vardb Error =>", error.message);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
// package-shared/shell/utils/generateColumnDescription.ts
|
|
function generateColumnDescription({
|
|
columnData,
|
|
primaryKeySet
|
|
}) {
|
|
const {
|
|
fieldName,
|
|
dataType,
|
|
nullValue,
|
|
primaryKey,
|
|
autoIncrement,
|
|
defaultValue,
|
|
defaultValueLiteral,
|
|
onUpdateLiteral,
|
|
notNullValue
|
|
} = columnData;
|
|
let fieldEntryText = "";
|
|
fieldEntryText += `\`${fieldName}\` ${dataType}`;
|
|
if (nullValue) {
|
|
fieldEntryText += " DEFAULT NULL";
|
|
} else if (defaultValueLiteral) {
|
|
fieldEntryText += ` DEFAULT ${defaultValueLiteral}`;
|
|
} else if (defaultValue) {
|
|
if (String(defaultValue).match(/uuid\(\)/i)) {
|
|
fieldEntryText += ` DEFAULT UUID()`;
|
|
} else {
|
|
fieldEntryText += ` DEFAULT '${defaultValue}'`;
|
|
}
|
|
} else if (notNullValue) {
|
|
fieldEntryText += ` NOT NULL`;
|
|
}
|
|
if (onUpdateLiteral) {
|
|
fieldEntryText += ` ON UPDATE ${onUpdateLiteral}`;
|
|
}
|
|
if (primaryKey && !primaryKeySet) {
|
|
fieldEntryText += " PRIMARY KEY";
|
|
primaryKeySet = true;
|
|
}
|
|
if (autoIncrement) {
|
|
fieldEntryText += " AUTO_INCREMENT";
|
|
primaryKeySet = true;
|
|
}
|
|
return {
|
|
fieldEntryText,
|
|
newPrimaryKeySet: primaryKeySet || false
|
|
};
|
|
}
|
|
|
|
// package-shared/shell/utils/supplementTable.ts
|
|
function supplementTable({ tableInfoArray }) {
|
|
let finalTableArray = tableInfoArray;
|
|
const defaultFields = require_defaultFields();
|
|
let primaryKeyExists = finalTableArray.filter((_field) => _field.primaryKey);
|
|
defaultFields.forEach((field) => {
|
|
let fieldExists = finalTableArray.filter((_field) => _field.fieldName === field.fieldName);
|
|
if (fieldExists && fieldExists[0]) {
|
|
return;
|
|
} else if (field.fieldName === "id" && !primaryKeyExists[0]) {
|
|
finalTableArray.unshift(field);
|
|
} else {
|
|
finalTableArray.push(field);
|
|
}
|
|
});
|
|
return finalTableArray;
|
|
}
|
|
|
|
// package-shared/shell/utils/createTable.ts
|
|
async function createTable({
|
|
dbFullName,
|
|
tableName,
|
|
tableInfoArray,
|
|
dbSchema,
|
|
clone,
|
|
tableSchema,
|
|
recordedDbEntry
|
|
}) {
|
|
const finalTable = supplementTable({ tableInfoArray });
|
|
const createTableQueryArray = [];
|
|
createTableQueryArray.push(`CREATE TABLE IF NOT EXISTS \`${tableName}\` (`);
|
|
try {
|
|
if (!recordedDbEntry) {
|
|
throw new Error("Recorded Db entry not found!");
|
|
}
|
|
const existingTable = await varDatabaseDbHandler({
|
|
database: "datasquirel",
|
|
queryString: `SELECT * FROM user_database_tables WHERE db_id = ? AND table_slug = ?`,
|
|
queryValuesArray: [recordedDbEntry.id, tableSchema?.tableName]
|
|
});
|
|
const table = existingTable?.[0];
|
|
if (!table?.id) {
|
|
const newTableEntry = await dbHandler({
|
|
query: `INSERT INTO user_database_tables SET ?`,
|
|
values: {
|
|
user_id: recordedDbEntry.user_id,
|
|
db_id: recordedDbEntry.id,
|
|
db_slug: recordedDbEntry.db_slug,
|
|
table_name: tableSchema?.tableFullName,
|
|
table_slug: tableSchema?.tableName,
|
|
child_table: tableSchema?.childTable ? "1" : null,
|
|
child_table_parent_database: tableSchema?.childTableDbFullName || null,
|
|
child_table_parent_table: tableSchema?.childTableName || null,
|
|
date_created: Date(),
|
|
date_created_code: Date.now(),
|
|
date_updated: Date(),
|
|
date_updated_code: Date.now()
|
|
},
|
|
database: "datasquirel"
|
|
});
|
|
}
|
|
} catch (error) {
|
|
}
|
|
let primaryKeySet = false;
|
|
let foreignKeys = [];
|
|
for (let i = 0;i < finalTable.length; i++) {
|
|
const column = finalTable[i];
|
|
const {
|
|
fieldName,
|
|
dataType,
|
|
nullValue,
|
|
primaryKey,
|
|
autoIncrement,
|
|
defaultValue,
|
|
defaultValueLiteral,
|
|
foreignKey,
|
|
updatedField,
|
|
onUpdate,
|
|
onUpdateLiteral,
|
|
onDelete,
|
|
onDeleteLiteral,
|
|
defaultField,
|
|
encrypted,
|
|
json,
|
|
newTempField,
|
|
notNullValue,
|
|
originName,
|
|
plainText,
|
|
pattern,
|
|
patternFlags,
|
|
richText
|
|
} = column;
|
|
if (foreignKey) {
|
|
foreignKeys.push({
|
|
...column
|
|
});
|
|
}
|
|
let { fieldEntryText, newPrimaryKeySet } = generateColumnDescription({
|
|
columnData: column,
|
|
primaryKeySet
|
|
});
|
|
primaryKeySet = newPrimaryKeySet;
|
|
const comma = (() => {
|
|
if (foreignKeys[0])
|
|
return ",";
|
|
if (i === finalTable.length - 1)
|
|
return "";
|
|
return ",";
|
|
})();
|
|
createTableQueryArray.push(" " + fieldEntryText + comma);
|
|
}
|
|
if (foreignKeys[0]) {
|
|
foreignKeys.forEach((foreighKey, index, array) => {
|
|
const fieldName = foreighKey.fieldName;
|
|
const destinationTableName = foreighKey.foreignKey?.destinationTableName;
|
|
const destinationTableColumnName = foreighKey.foreignKey?.destinationTableColumnName;
|
|
const cascadeDelete = foreighKey.foreignKey?.cascadeDelete;
|
|
const cascadeUpdate = foreighKey.foreignKey?.cascadeUpdate;
|
|
const foreignKeyName = foreighKey.foreignKey?.foreignKeyName;
|
|
const comma = (() => {
|
|
if (index === foreignKeys.length - 1)
|
|
return "";
|
|
return ",";
|
|
})();
|
|
createTableQueryArray.push(` CONSTRAINT \`${foreignKeyName}\` FOREIGN KEY (\`${fieldName}\`) REFERENCES \`${destinationTableName}\`(${destinationTableColumnName})${cascadeDelete ? " ON DELETE CASCADE" : ""}${cascadeUpdate ? " ON UPDATE CASCADE" : ""}${comma}`);
|
|
});
|
|
}
|
|
createTableQueryArray.push(`) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`);
|
|
const createTableQuery = createTableQueryArray.join("\n");
|
|
const newTable = await varDatabaseDbHandler({
|
|
queryString: createTableQuery,
|
|
database: dbFullName
|
|
});
|
|
return newTable;
|
|
}
|
|
|
|
// package-shared/shell/utils/updateTable.ts
|
|
import fs9 from "fs";
|
|
var defaultFieldsRegexp2 = /^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
|
|
async function updateTable({
|
|
dbFullName,
|
|
tableName,
|
|
tableInfoArray,
|
|
userId,
|
|
dbSchema,
|
|
tableIndexes,
|
|
tableSchema,
|
|
clone,
|
|
childDb,
|
|
tableIndex,
|
|
tableNameFull,
|
|
recordedDbEntry
|
|
}) {
|
|
let errorLogs = [];
|
|
let upToDateTableFieldsArray = tableInfoArray;
|
|
try {
|
|
const updateTableQueryArray = [];
|
|
const constraintsQueryArray = [];
|
|
updateTableQueryArray.push(`ALTER TABLE \`${tableName}\``);
|
|
if (childDb) {
|
|
try {
|
|
if (!recordedDbEntry) {
|
|
throw new Error("Recorded Db entry not found!");
|
|
}
|
|
const existingTable = await varDatabaseDbHandler({
|
|
database: "datasquirel",
|
|
queryString: `SELECT * FROM user_database_tables WHERE db_id = ? AND table_slug = ?`,
|
|
queryValuesArray: [recordedDbEntry.id, tableName]
|
|
});
|
|
const table = existingTable?.[0];
|
|
if (!table?.id) {
|
|
const newTableEntry = await dbHandler({
|
|
query: `INSERT INTO user_database_tables SET ?`,
|
|
values: {
|
|
user_id: recordedDbEntry.user_id,
|
|
db_id: recordedDbEntry.id,
|
|
db_slug: recordedDbEntry.db_slug,
|
|
table_name: tableNameFull,
|
|
table_slug: tableName,
|
|
child_table: tableSchema?.childTable ? "1" : null,
|
|
child_table_parent_database: tableSchema?.childTableDbFullName || null,
|
|
child_table_parent_table: tableSchema.childTableName || null,
|
|
date_created: Date(),
|
|
date_created_code: Date.now(),
|
|
date_updated: Date(),
|
|
date_updated_code: Date.now()
|
|
},
|
|
database: "datasquirel"
|
|
});
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
const allExistingIndexes = await varDatabaseDbHandler({
|
|
queryString: `SHOW INDEXES FROM \`${tableName}\``,
|
|
database: dbFullName
|
|
});
|
|
const allExistingColumns = await varDatabaseDbHandler({
|
|
queryString: `SHOW COLUMNS FROM \`${tableName}\``,
|
|
database: dbFullName
|
|
});
|
|
const updatedColumnsArray = [];
|
|
for (let e = 0;e < allExistingColumns.length; e++) {
|
|
const { Field } = allExistingColumns[e];
|
|
if (Field.match(defaultFieldsRegexp2))
|
|
continue;
|
|
let existingEntry = upToDateTableFieldsArray.filter((column) => column.fieldName === Field || column.originName === Field);
|
|
if (existingEntry && existingEntry[0]) {
|
|
if (existingEntry[0].updatedField && existingEntry[0].fieldName) {
|
|
updatedColumnsArray.push(existingEntry[0].fieldName);
|
|
const renameColumn = await varDatabaseDbHandler({
|
|
queryString: `ALTER TABLE ${tableName} RENAME COLUMN \`${existingEntry[0].originName}\` TO \`${existingEntry[0].fieldName}\``,
|
|
database: dbFullName
|
|
});
|
|
console.log(`Column Renamed from "${existingEntry[0].originName}" to "${existingEntry[0].fieldName}"`);
|
|
try {
|
|
const userSchemaData = dbSchema;
|
|
const targetDbIndex = userSchemaData.findIndex((db) => db.dbFullName === dbFullName);
|
|
const targetTableIndex = userSchemaData[targetDbIndex].tables.findIndex((table) => table.tableName === tableName);
|
|
const targetFieldIndex = userSchemaData[targetDbIndex].tables[targetTableIndex].fields.findIndex((field) => field.fieldName === existingEntry[0].fieldName);
|
|
delete userSchemaData[targetDbIndex].tables[targetTableIndex].fields[targetFieldIndex]["originName"];
|
|
delete userSchemaData[targetDbIndex].tables[targetTableIndex].fields[targetFieldIndex]["updatedField"];
|
|
upToDateTableFieldsArray = userSchemaData[targetDbIndex].tables[targetTableIndex].fields;
|
|
fs9.writeFileSync(`${String(process.env.DSQL_USER_DB_SCHEMA_PATH)}/user-${userId}/main.json`, JSON.stringify(userSchemaData), "utf8");
|
|
} catch (error) {
|
|
console.log("Update table error =>", error.message);
|
|
}
|
|
}
|
|
continue;
|
|
} else {
|
|
await varDatabaseDbHandler({
|
|
queryString: `ALTER TABLE ${tableName} DROP COLUMN \`${Field}\``,
|
|
database: dbFullName
|
|
});
|
|
}
|
|
}
|
|
for (let f = 0;f < allExistingIndexes.length; f++) {
|
|
const { Key_name, Index_comment } = allExistingIndexes[f];
|
|
if (Index_comment?.match(/schema_index/)) {
|
|
try {
|
|
const existingKeyInSchema = tableIndexes?.filter((indexObject) => indexObject.alias === Key_name);
|
|
if (!existingKeyInSchema?.[0])
|
|
throw new Error(`This Index(${Key_name}) Has been Deleted!`);
|
|
} catch (error) {
|
|
await varDatabaseDbHandler({
|
|
queryString: `ALTER TABLE ${tableName} DROP INDEX \`${Key_name}\``,
|
|
database: dbFullName
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (tableIndexes && tableIndexes[0]) {
|
|
for (let g = 0;g < tableIndexes.length; g++) {
|
|
const { indexType, indexName, indexTableFields, alias } = tableIndexes[g];
|
|
if (!alias?.match(/./))
|
|
continue;
|
|
try {
|
|
const existingKeyInDb = allExistingIndexes.filter((indexObject) => indexObject.Key_name === alias);
|
|
if (!existingKeyInDb[0])
|
|
throw new Error("This Index Does not Exist");
|
|
} catch (error) {
|
|
await varDatabaseDbHandler({
|
|
queryString: `CREATE${indexType?.match(/fullText/i) ? " FULLTEXT" : ""} INDEX \`${alias}\` ON ${tableName}(${indexTableFields?.map((nm) => nm.value).map((nm) => `\`${nm}\``).join(",")}) COMMENT 'schema_index'`,
|
|
database: dbFullName
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const allForeignKeys = await varDatabaseDbHandler({
|
|
queryString: `SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = '${dbFullName}' AND TABLE_NAME='${tableName}' AND CONSTRAINT_TYPE='FOREIGN KEY'`,
|
|
database: dbFullName
|
|
});
|
|
if (allForeignKeys) {
|
|
for (let c = 0;c < allForeignKeys.length; c++) {
|
|
const { CONSTRAINT_NAME } = allForeignKeys[c];
|
|
if (CONSTRAINT_NAME.match(/PRIMARY/))
|
|
continue;
|
|
const dropForeignKey = await varDatabaseDbHandler({
|
|
queryString: `ALTER TABLE ${tableName} DROP FOREIGN KEY \`${CONSTRAINT_NAME}\``,
|
|
database: dbFullName
|
|
});
|
|
}
|
|
}
|
|
for (let i = 0;i < upToDateTableFieldsArray.length; i++) {
|
|
const column = upToDateTableFieldsArray[i];
|
|
const prevColumn = upToDateTableFieldsArray[i - 1];
|
|
const nextColumn = upToDateTableFieldsArray[i + 1];
|
|
const {
|
|
fieldName,
|
|
dataType,
|
|
nullValue,
|
|
primaryKey,
|
|
autoIncrement,
|
|
defaultValue,
|
|
defaultValueLiteral,
|
|
foreignKey,
|
|
updatedField
|
|
} = column;
|
|
if (fieldName?.match(/^id$|^date_/))
|
|
continue;
|
|
let updateText = "";
|
|
let existingColumnIndex;
|
|
let existingColumn = allExistingColumns && allExistingColumns[0] ? allExistingColumns.filter((_column, _index) => {
|
|
if (_column.Field === fieldName) {
|
|
existingColumnIndex = _index;
|
|
return true;
|
|
}
|
|
}) : null;
|
|
let { fieldEntryText } = generateColumnDescription({
|
|
columnData: column
|
|
});
|
|
if (existingColumn && existingColumn[0]?.Field) {
|
|
const { Field, Type, Null, Key, Default, Extra } = existingColumn[0];
|
|
let isColumnReordered = i < existingColumnIndex;
|
|
if (Field === fieldName && !isColumnReordered && dataType?.toUpperCase() === Type.toUpperCase()) {
|
|
updateText += `MODIFY COLUMN ${fieldEntryText}`;
|
|
} else {
|
|
if (userId) {
|
|
updateText += `MODIFY COLUMN ${fieldEntryText}${isColumnReordered ? prevColumn?.fieldName ? " AFTER `" + prevColumn.fieldName + "`" : nextColumn?.fieldName ? " BEFORE `" + nextColumn.fieldName + "`" : "" : ""}`;
|
|
} else {
|
|
updateText += `MODIFY COLUMN ${fieldEntryText}`;
|
|
}
|
|
}
|
|
} else if (prevColumn && prevColumn.fieldName) {
|
|
updateText += `ADD COLUMN ${fieldEntryText} AFTER \`${prevColumn.fieldName}\``;
|
|
} else if (nextColumn && nextColumn.fieldName) {
|
|
updateText += `ADD COLUMN ${fieldEntryText} BEFORE \`${nextColumn.fieldName}\``;
|
|
} else {
|
|
updateText += `ADD COLUMN ${fieldEntryText}`;
|
|
}
|
|
updateTableQueryArray.push(updateText + ",");
|
|
if (!clone && foreignKey) {
|
|
const {
|
|
destinationTableName,
|
|
destinationTableColumnName,
|
|
cascadeDelete,
|
|
cascadeUpdate,
|
|
foreignKeyName
|
|
} = foreignKey;
|
|
const foreinKeyText = `ADD CONSTRAINT \`${foreignKeyName}\` FOREIGN KEY (\`${fieldName}\`) REFERENCES \`${destinationTableName}\`(\`${destinationTableColumnName}\`)${cascadeDelete ? " ON DELETE CASCADE" : ""}${cascadeUpdate ? " ON UPDATE CASCADE" : ""}`;
|
|
const finalQueryString = `ALTER TABLE \`${tableName}\` ${foreinKeyText}`;
|
|
const addForeignKey = await varDatabaseDbHandler({
|
|
database: dbFullName,
|
|
queryString: finalQueryString
|
|
});
|
|
if (!addForeignKey?.serverStatus) {
|
|
errorLogs.push(addForeignKey);
|
|
}
|
|
}
|
|
}
|
|
const updateTableQuery = updateTableQueryArray.join(" ").replace(/,$/, "");
|
|
if (updateTableQueryArray.length > 1) {
|
|
const updateTable2 = await varDatabaseDbHandler({
|
|
queryString: updateTableQuery,
|
|
database: dbFullName
|
|
});
|
|
return updateTable2;
|
|
} else {
|
|
return "No Changes Made to Table";
|
|
}
|
|
} catch (error) {
|
|
console.log('Error in "updateTable" shell function =>', error.message);
|
|
return "Error in Updating Table";
|
|
}
|
|
}
|
|
|
|
// package-shared/shell/createDbFromSchema.ts
|
|
init_ejson();
|
|
var __dirname = "/home/benoti/Projects/Git/moduletrace/datasquirel/datasquirel/package-shared/shell";
|
|
require_main().config({ path: "./../.env" });
|
|
var execFlag = process.argv.find((arg) => arg === "--exec");
|
|
async function createDbFromSchema({
|
|
userId,
|
|
targetDatabase,
|
|
dbSchemaData
|
|
}) {
|
|
const schemaPath = userId ? path6.join(String(process.env.DSQL_USER_DB_SCHEMA_PATH), `/user-${userId}/main.json`) : path6.resolve(__dirname, "../../jsonData/dbSchemas/main.json");
|
|
const dbSchema = dbSchemaData || ejson_default.parse(fs10.readFileSync(schemaPath, "utf8"));
|
|
if (!dbSchema) {
|
|
console.log("Schema Not Found!");
|
|
return;
|
|
}
|
|
for (let i = 0;i < dbSchema.length; i++) {
|
|
const database = dbSchema[i];
|
|
const { dbFullName, tables, dbName, dbSlug, childrenDatabases } = database;
|
|
if (targetDatabase && dbFullName != targetDatabase) {
|
|
continue;
|
|
}
|
|
const dbCheck = await noDatabaseDbHandler(`SELECT SCHEMA_NAME AS dbFullName FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${dbFullName}'`);
|
|
if (dbCheck && dbCheck[0]?.dbFullName) {
|
|
} else {
|
|
const newDatabase = await noDatabaseDbHandler(`CREATE DATABASE IF NOT EXISTS \`${dbFullName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_bin`);
|
|
}
|
|
const allTables = await noDatabaseDbHandler(`SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='${dbFullName}'`);
|
|
for (let tb = 0;tb < allTables.length; tb++) {
|
|
const { TABLE_NAME } = allTables[tb];
|
|
if (!tables.filter((_table) => _table.tableName === TABLE_NAME)[0]) {
|
|
const oldTableFilteredArray = tables.filter((_table) => _table.tableNameOld && _table.tableNameOld === TABLE_NAME);
|
|
if (oldTableFilteredArray && oldTableFilteredArray[0]) {
|
|
console.log("Renaming Table");
|
|
await varDatabaseDbHandler({
|
|
queryString: `RENAME TABLE \`${oldTableFilteredArray[0].tableNameOld}\` TO \`${oldTableFilteredArray[0].tableName}\``,
|
|
database: dbFullName
|
|
});
|
|
} else {
|
|
console.log(`Dropping Table from ${dbFullName}`);
|
|
await varDatabaseDbHandler({
|
|
queryString: `DROP TABLE \`${TABLE_NAME}\``,
|
|
database: dbFullName
|
|
});
|
|
const deleteTableEntry = await dbHandler({
|
|
query: `DELETE FROM user_database_tables WHERE user_id = ? AND db_slug = ? AND table_slug = ?`,
|
|
values: [userId, dbSlug, TABLE_NAME],
|
|
database: "datasquirel"
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const recordedDbEntryArray = userId ? await varDatabaseDbHandler({
|
|
database: "datasquirel",
|
|
queryString: `SELECT * FROM user_databases WHERE db_full_name = ?`,
|
|
queryValuesArray: [dbFullName]
|
|
}) : undefined;
|
|
const recordedDbEntry = recordedDbEntryArray?.[0];
|
|
for (let t = 0;t < tables.length; t++) {
|
|
const table = tables[t];
|
|
const { tableName, fields, indexes } = table;
|
|
const tableCheck = await varDatabaseDbHandler({
|
|
queryString: `
|
|
SELECT EXISTS (
|
|
SELECT
|
|
TABLE_NAME
|
|
FROM
|
|
information_schema.TABLES
|
|
WHERE
|
|
TABLE_SCHEMA = ? AND
|
|
TABLE_NAME = ?
|
|
) AS tableExists`,
|
|
queryValuesArray: [dbFullName, table.tableName],
|
|
database: dbFullName
|
|
});
|
|
if (tableCheck && tableCheck[0]?.tableExists > 0) {
|
|
const updateExistingTable = await updateTable({
|
|
dbFullName,
|
|
tableName,
|
|
tableNameFull: table.tableFullName,
|
|
tableInfoArray: fields,
|
|
userId,
|
|
dbSchema,
|
|
tableIndexes: indexes,
|
|
tableIndex: t,
|
|
childDb: database.childDatabase || undefined,
|
|
recordedDbEntry,
|
|
tableSchema: table
|
|
});
|
|
if (table.childrenTables && table.childrenTables[0]) {
|
|
for (let ch = 0;ch < table.childrenTables.length; ch++) {
|
|
const childTable = table.childrenTables[ch];
|
|
const updateExistingChildTable = await updateTable({
|
|
dbFullName: childTable.dbNameFull,
|
|
tableName: childTable.tableName,
|
|
tableNameFull: childTable.tableNameFull,
|
|
tableInfoArray: fields,
|
|
userId,
|
|
dbSchema,
|
|
tableIndexes: indexes,
|
|
clone: true,
|
|
childDb: database.childDatabase || undefined,
|
|
recordedDbEntry,
|
|
tableSchema: table
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
const createNewTable = await createTable({
|
|
tableName,
|
|
tableInfoArray: fields,
|
|
dbFullName,
|
|
dbSchema,
|
|
tableSchema: table,
|
|
recordedDbEntry
|
|
});
|
|
if (indexes && indexes[0]) {
|
|
if (indexes && indexes[0]) {
|
|
for (let g = 0;g < indexes.length; g++) {
|
|
const {
|
|
indexType,
|
|
indexName,
|
|
indexTableFields,
|
|
alias
|
|
} = indexes[g];
|
|
if (!alias?.match(/./))
|
|
continue;
|
|
try {
|
|
const allExistingIndexes = await varDatabaseDbHandler({
|
|
queryString: `SHOW INDEXES FROM \`${tableName}\``,
|
|
database: dbFullName
|
|
});
|
|
const existingKeyInDb = allExistingIndexes.filter((indexObject) => indexObject.Key_name === alias);
|
|
if (!existingKeyInDb[0])
|
|
throw new Error("This Index Does not Exist");
|
|
} catch (error) {
|
|
await varDatabaseDbHandler({
|
|
queryString: `CREATE${indexType?.match(/fullText/i) ? " FULLTEXT" : ""} INDEX \`${alias}\` ON ${tableName}(${indexTableFields?.map((nm) => nm.value).map((nm) => `\`${nm}\``).join(",")}) COMMENT 'schema_index'`,
|
|
database: dbFullName
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (childrenDatabases?.[0]) {
|
|
for (let ch = 0;ch < childrenDatabases.length; ch++) {
|
|
const childDb = childrenDatabases[ch];
|
|
const { dbFullName: dbFullName2 } = childDb;
|
|
await createDbFromSchema({
|
|
userId,
|
|
targetDatabase: dbFullName2
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (execFlag) {
|
|
createDbFromSchema({});
|
|
}
|
|
|
|
// package-shared/functions/backend/addUsersTableToDb.ts
|
|
init_LOCAL_DB_HANDLER();
|
|
|
|
// package-shared/functions/backend/grabSchemaFieldsFromData.ts
|
|
init_serverError();
|
|
function grabSchemaFieldsFromData({
|
|
data,
|
|
fields,
|
|
excludeData,
|
|
excludeFields
|
|
}) {
|
|
try {
|
|
const possibleFields = require_possibleFields();
|
|
const dataTypes = require_dataTypes();
|
|
const finalFields = [];
|
|
let filteredFields = [];
|
|
if (data && Object.keys(data)?.[0]) {
|
|
filteredFields = Object.keys(data);
|
|
}
|
|
if (fields) {
|
|
filteredFields = [...filteredFields, ...fields];
|
|
filteredFields = [...new Set(filteredFields)];
|
|
}
|
|
filteredFields = filteredFields.filter((fld) => !excludeData || !Object.keys(excludeData).includes(fld)).filter((fld) => !excludeFields || !excludeFields.find((exlFld) => exlFld.fieldName == fld));
|
|
filteredFields.forEach((fld) => {
|
|
const value = data ? data[fld] : null;
|
|
if (typeof value == "string") {
|
|
const newField = {
|
|
fieldName: fld,
|
|
dataType: value.length > 255 ? "TEXT" : "VARCHAR(255)"
|
|
};
|
|
if (Boolean(value.match(/<[^>]+>/g))) {
|
|
newField.richText = true;
|
|
}
|
|
finalFields.push(newField);
|
|
} else if (typeof value == "number") {
|
|
finalFields.push({
|
|
fieldName: fld,
|
|
dataType: "INT"
|
|
});
|
|
} else {
|
|
finalFields.push({
|
|
fieldName: fld,
|
|
dataType: "VARCHAR(255)"
|
|
});
|
|
}
|
|
});
|
|
return finalFields;
|
|
} catch (error) {
|
|
console.log(`grabSchemaFieldsFromData.js ERROR: ${error.message}`);
|
|
serverError({
|
|
component: "grabSchemaFieldsFromData.js",
|
|
message: error.message
|
|
});
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/grabNewUsersTableSchema.ts
|
|
init_serverError();
|
|
function grabNewUsersTableSchema(params) {
|
|
try {
|
|
const userPreset = require_users();
|
|
const defaultFields = require_defaultFields();
|
|
const supplementalFields = params?.payload ? grabSchemaFieldsFromData({
|
|
data: params?.payload,
|
|
excludeData: defaultFields,
|
|
excludeFields: userPreset.fields
|
|
}) : [];
|
|
console.log("supplementalFields", supplementalFields);
|
|
const allFields = [...userPreset.fields, ...supplementalFields];
|
|
console.log("allFields", allFields);
|
|
const finalFields = [
|
|
...defaultFields.slice(0, 2),
|
|
...allFields,
|
|
...defaultFields.slice(2)
|
|
];
|
|
userPreset.fields = [...finalFields];
|
|
return userPreset;
|
|
} catch (error) {
|
|
console.log(`grabNewUsersTableSchema.js ERROR: ${error.message}`);
|
|
serverError({
|
|
component: "grabNewUsersTableSchema",
|
|
message: error.message
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/addUsersTableToDb.ts
|
|
async function addUsersTableToDb({
|
|
userId,
|
|
database,
|
|
useLocal,
|
|
payload
|
|
}) {
|
|
try {
|
|
const dbFullName = database;
|
|
const userPreset = grabNewUsersTableSchema({ payload });
|
|
if (!userPreset)
|
|
throw new Error("Couldn't Get User Preset!");
|
|
const userSchemaData = grabUserSchemaData({ userId });
|
|
if (!userSchemaData)
|
|
throw new Error("User schema data not found!");
|
|
let targetDatabase = userSchemaData.find((db) => db.dbFullName === database);
|
|
if (!targetDatabase) {
|
|
throw new Error("Couldn't Find Target Database!");
|
|
}
|
|
let existingTableIndex = targetDatabase?.tables.findIndex((table) => table.tableName === "users");
|
|
if (typeof existingTableIndex == "number" && existingTableIndex > 0) {
|
|
targetDatabase.tables[existingTableIndex] = userPreset;
|
|
} else {
|
|
targetDatabase.tables.push(userPreset);
|
|
}
|
|
setUserSchemaData({ schemaData: userSchemaData, userId });
|
|
const targetDb = useLocal ? await LOCAL_DB_HANDLER(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database]) : await DB_HANDLER(`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`, [userId, database]);
|
|
if (targetDb?.[0]) {
|
|
const newTableEntry = await addDbEntry({
|
|
dbFullName: "datasquirel",
|
|
tableName: "user_database_tables",
|
|
data: {
|
|
user_id: userId,
|
|
db_id: targetDb[0].id,
|
|
db_slug: targetDatabase.dbSlug,
|
|
table_name: "Users",
|
|
table_slug: "users"
|
|
},
|
|
useLocal
|
|
});
|
|
}
|
|
const dbShellUpdate = await createDbFromSchema({
|
|
userId,
|
|
targetDatabase: dbFullName
|
|
});
|
|
return `Done!`;
|
|
} catch (error) {
|
|
console.log(`addUsersTableToDb.js ERROR: ${error.message}`);
|
|
serverError({
|
|
component: "addUsersTableToDb",
|
|
message: error.message,
|
|
user: { id: userId }
|
|
});
|
|
return error.message;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/updateUsersTableSchema.ts
|
|
init_serverError();
|
|
async function updateUsersTableSchema({
|
|
userId,
|
|
database,
|
|
newFields,
|
|
newPayload
|
|
}) {
|
|
try {
|
|
const dbFullName = database;
|
|
const userSchemaData = grabUserSchemaData({ userId });
|
|
if (!userSchemaData)
|
|
throw new Error("User schema data not found!");
|
|
let targetDatabaseIndex = userSchemaData.findIndex((db) => db.dbFullName === database);
|
|
if (targetDatabaseIndex < 0) {
|
|
throw new Error("Couldn't Find Target Database!");
|
|
}
|
|
let existingTableIndex = userSchemaData[targetDatabaseIndex]?.tables.findIndex((table) => table.tableName === "users");
|
|
const usersTable = userSchemaData[targetDatabaseIndex].tables[existingTableIndex];
|
|
if (!usersTable?.fields?.[0])
|
|
throw new Error("Users Table Not Found!");
|
|
const additionalFields = grabSchemaFieldsFromData({
|
|
fields: newFields,
|
|
data: newPayload
|
|
});
|
|
const spliceStartIndex = usersTable.fields.findIndex((field) => field.fieldName === "date_created");
|
|
const finalSpliceStartIndex = spliceStartIndex >= 0 ? spliceStartIndex : 0;
|
|
usersTable.fields.splice(finalSpliceStartIndex, 0, ...additionalFields);
|
|
setUserSchemaData({ schemaData: userSchemaData, userId });
|
|
const dbShellUpdate = await createDbFromSchema({
|
|
userId,
|
|
targetDatabase: dbFullName
|
|
});
|
|
return `Done!`;
|
|
} catch (error) {
|
|
console.log(`addUsersTableToDb.js ERROR: ${error.message}`);
|
|
serverError({
|
|
component: "addUsersTableToDb",
|
|
message: error.message,
|
|
user: { id: userId }
|
|
});
|
|
return error.message;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/api/users/api-create-user.ts
|
|
init_varDatabaseDbHandler();
|
|
init_hashPassword();
|
|
async function apiCreateUser({
|
|
encryptionKey,
|
|
payload,
|
|
database,
|
|
userId,
|
|
useLocal
|
|
}) {
|
|
const dbFullName = database;
|
|
const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
if (!finalEncryptionKey) {
|
|
return {
|
|
success: false,
|
|
msg: "No encryption key provided",
|
|
payload: null
|
|
};
|
|
}
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
return {
|
|
success: false,
|
|
msg: "Encryption key must be at least 8 characters long",
|
|
payload: null
|
|
};
|
|
}
|
|
const hashedPassword = hashPassword({
|
|
encryptionKey: finalEncryptionKey,
|
|
password: String(payload.password)
|
|
});
|
|
payload.password = hashedPassword;
|
|
const fieldsQuery = `SHOW COLUMNS FROM users`;
|
|
let fields = await varDatabaseDbHandler2({
|
|
queryString: fieldsQuery,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
if (!fields?.[0]) {
|
|
const newTable = await addUsersTableToDb({
|
|
userId: Number(API_USER_ID),
|
|
database: dbFullName,
|
|
useLocal,
|
|
payload
|
|
});
|
|
fields = await varDatabaseDbHandler2({
|
|
queryString: fieldsQuery,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
}
|
|
if (!fields?.[0]) {
|
|
return {
|
|
success: false,
|
|
msg: "Could not create users table"
|
|
};
|
|
}
|
|
const fieldsTitles = fields.map((fieldObject) => fieldObject.Field);
|
|
let invalidField = null;
|
|
for (let i = 0;i < Object.keys(payload).length; i++) {
|
|
const key = Object.keys(payload)[i];
|
|
if (!fieldsTitles.includes(key)) {
|
|
await updateUsersTableSchema({
|
|
userId: Number(API_USER_ID),
|
|
database: dbFullName,
|
|
newPayload: {
|
|
[key]: payload[key]
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (invalidField) {
|
|
return {
|
|
success: false,
|
|
msg: `${invalidField} is not a valid field!`
|
|
};
|
|
}
|
|
const existingUserQuery = `SELECT * FROM users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
|
|
const existingUserValues = payload.username ? [payload.email, payload.username] : [payload.email];
|
|
const existingUser = await varDatabaseDbHandler2({
|
|
queryString: existingUserQuery,
|
|
queryValuesArray: existingUserValues,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
if (existingUser?.[0]) {
|
|
return {
|
|
success: false,
|
|
msg: "User Already Exists",
|
|
payload: null
|
|
};
|
|
}
|
|
const addUser = await addDbEntry({
|
|
dbContext: "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: "users",
|
|
data: {
|
|
...payload,
|
|
image: process.env.DSQL_DEFAULT_USER_IMAGE || "/images/user-preset.png",
|
|
image_thumbnail: process.env.DSQL_DEFAULT_USER_IMAGE || "/images/user-preset-thumbnail.png"
|
|
},
|
|
useLocal
|
|
});
|
|
if (addUser?.insertId) {
|
|
const newlyAddedUserQuery = `SELECT id,first_name,last_name,email,username,phone,image,image_thumbnail,city,state,country,zip_code,address,verification_status,more_user_data FROM users WHERE id='${addUser.insertId}'`;
|
|
const newlyAddedUser = await varDatabaseDbHandler2({
|
|
queryString: newlyAddedUserQuery,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
return {
|
|
success: true,
|
|
payload: newlyAddedUser[0]
|
|
};
|
|
} else {
|
|
return {
|
|
success: false,
|
|
msg: "Could not create user",
|
|
sqlResult: addUser,
|
|
payload: null
|
|
};
|
|
}
|
|
}
|
|
|
|
// users/add-user.ts
|
|
async function addUser({
|
|
key,
|
|
payload,
|
|
database,
|
|
encryptionKey,
|
|
user_id,
|
|
useLocal,
|
|
apiUserId
|
|
}) {
|
|
const {
|
|
DSQL_DB_HOST,
|
|
DSQL_DB_USERNAME,
|
|
DSQL_DB_PASSWORD,
|
|
DSQL_DB_NAME,
|
|
DSQL_API_USER_ID
|
|
} = process.env;
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path7.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs11.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiCreateUser({
|
|
database: DSQL_DB_NAME,
|
|
encryptionKey,
|
|
payload,
|
|
userId: apiUserId,
|
|
useLocal
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
payload,
|
|
database,
|
|
encryptionKey
|
|
});
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/add-user`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/update-user.ts
|
|
init_grab_host_names();
|
|
import path8 from "path";
|
|
import fs12 from "fs";
|
|
|
|
// package-shared/functions/api/users/api-update-user.ts
|
|
init_encrypt();
|
|
init_hashPassword();
|
|
init_varDatabaseDbHandler();
|
|
async function apiUpdateUser({
|
|
payload,
|
|
dbFullName,
|
|
updatedUserId,
|
|
useLocal,
|
|
dbSchema
|
|
}) {
|
|
const existingUserQuery = `SELECT * FROM users WHERE id = ?`;
|
|
const existingUserValues = [updatedUserId];
|
|
const existingUser = await varDatabaseDbHandler2({
|
|
queryString: existingUserQuery,
|
|
queryValuesArray: existingUserValues,
|
|
database: dbFullName,
|
|
useLocal
|
|
});
|
|
if (!existingUser?.[0]) {
|
|
return {
|
|
success: false,
|
|
msg: "User not found"
|
|
};
|
|
}
|
|
const data = (() => {
|
|
const reqBodyKeys = Object.keys(payload);
|
|
const targetTableSchema = (() => {
|
|
try {
|
|
const targetDatabaseSchema = dbSchema?.tables?.find((tbl) => tbl.tableName == "users");
|
|
return targetDatabaseSchema;
|
|
} catch (error) {
|
|
return;
|
|
}
|
|
})();
|
|
const finalData = {};
|
|
reqBodyKeys.forEach((key) => {
|
|
const targetFieldSchema = targetTableSchema?.fields?.find((field) => field.fieldName == key);
|
|
if (key?.match(/^date_|^id$|^uuid$/))
|
|
return;
|
|
let value = payload[key];
|
|
if (targetFieldSchema?.encrypted) {
|
|
value = encrypt({ data: value });
|
|
}
|
|
finalData[key] = value;
|
|
});
|
|
if (finalData.password && typeof finalData.password == "string") {
|
|
finalData.password = hashPassword({ password: finalData.password });
|
|
}
|
|
return finalData;
|
|
})();
|
|
const updateUser = await updateDbEntry({
|
|
dbContext: "Dsql User",
|
|
paradigm: "Full Access",
|
|
dbFullName,
|
|
tableName: "users",
|
|
identifierColumnName: "id",
|
|
identifierValue: updatedUserId,
|
|
data,
|
|
useLocal
|
|
});
|
|
return {
|
|
success: true,
|
|
payload: updateUser
|
|
};
|
|
}
|
|
|
|
// users/update-user.ts
|
|
async function updateUser({
|
|
key,
|
|
payload,
|
|
database,
|
|
user_id,
|
|
useLocal,
|
|
updatedUserId
|
|
}) {
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path8.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs12.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiUpdateUser({
|
|
payload,
|
|
dbFullName: DSQL_DB_NAME,
|
|
useLocal,
|
|
updatedUserId,
|
|
dbSchema
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
payload,
|
|
database,
|
|
updatedUserId
|
|
});
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY || key
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/update-user`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/login-user.ts
|
|
init_encrypt();
|
|
init_grab_host_names();
|
|
import fs14 from "fs";
|
|
import path10 from "path";
|
|
|
|
// package-shared/functions/api/users/api-login.ts
|
|
init_varDatabaseDbHandler();
|
|
init_hashPassword();
|
|
async function apiLoginUser({
|
|
encryptionKey,
|
|
email,
|
|
username,
|
|
password,
|
|
database,
|
|
additionalFields,
|
|
email_login,
|
|
email_login_code,
|
|
email_login_field,
|
|
token,
|
|
skipPassword,
|
|
social,
|
|
useLocal
|
|
}) {
|
|
const dbFullName = database;
|
|
if (email?.match(/ /) || username && username?.match(/ /) || password && password?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
msg: "Invalid Email/Password format"
|
|
};
|
|
}
|
|
let hashedPassword = password ? hashPassword({
|
|
encryptionKey,
|
|
password
|
|
}) : null;
|
|
let foundUser = await varDatabaseDbHandler2({
|
|
queryString: `SELECT * FROM users WHERE email = ? OR username = ?`,
|
|
queryValuesArray: [email, username],
|
|
database: dbFullName.replace(/[^a-z0-9_]/g, ""),
|
|
useLocal
|
|
});
|
|
if ((!foundUser || !foundUser[0]) && !social)
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "No user found"
|
|
};
|
|
let isPasswordCorrect = false;
|
|
if (foundUser?.[0] && !email_login && skipPassword) {
|
|
isPasswordCorrect = true;
|
|
} else if (foundUser?.[0] && !email_login) {
|
|
isPasswordCorrect = hashedPassword === foundUser[0].password;
|
|
} else if (foundUser && foundUser[0] && email_login && email_login_code && email_login_field) {
|
|
const tempCode = foundUser[0][email_login_field];
|
|
if (!tempCode)
|
|
throw new Error("No code Found!");
|
|
const tempCodeArray = tempCode.split("-");
|
|
const [code, codeDate] = tempCodeArray;
|
|
const millisecond15mins = 1000 * 60 * 15;
|
|
if (Date.now() - Number(codeDate) > millisecond15mins) {
|
|
throw new Error("Code Expired");
|
|
}
|
|
isPasswordCorrect = code === email_login_code;
|
|
}
|
|
let socialUserValid = false;
|
|
if (!isPasswordCorrect && !socialUserValid) {
|
|
return {
|
|
success: false,
|
|
msg: "Wrong password, no social login validity",
|
|
payload: null
|
|
};
|
|
}
|
|
if (isPasswordCorrect && email_login) {
|
|
const resetTempCode = await varDatabaseDbHandler2({
|
|
queryString: `UPDATE users SET ${email_login_field} = '' WHERE email = ? OR username = ?`,
|
|
queryValuesArray: [email, username],
|
|
database: dbFullName.replace(/[^a-z0-9_]/g, ""),
|
|
useLocal
|
|
});
|
|
}
|
|
let csrfKey = Math.random().toString(36).substring(2) + "-" + Math.random().toString(36).substring(2);
|
|
let userPayload = {
|
|
id: foundUser[0].id,
|
|
first_name: foundUser[0].first_name,
|
|
last_name: foundUser[0].last_name,
|
|
username: foundUser[0].username,
|
|
email: foundUser[0].email,
|
|
phone: foundUser[0].phone,
|
|
social_id: foundUser[0].social_id,
|
|
image: foundUser[0].image,
|
|
image_thumbnail: foundUser[0].image_thumbnail,
|
|
verification_status: foundUser[0].verification_status,
|
|
social_login: foundUser[0].social_login,
|
|
social_platform: foundUser[0].social_platform,
|
|
csrf_k: csrfKey,
|
|
more_data: foundUser[0].more_user_data,
|
|
logged_in_status: true,
|
|
date: Date.now()
|
|
};
|
|
const resposeObject = {
|
|
success: true,
|
|
msg: "Login Successful",
|
|
payload: userPayload,
|
|
userId: foundUser[0].id,
|
|
csrf: csrfKey
|
|
};
|
|
if (additionalFields && Array.isArray(additionalFields) && additionalFields.length > 0) {
|
|
additionalFields.forEach((key) => {
|
|
userPayload[key] = foundUser[0][key];
|
|
});
|
|
}
|
|
return resposeObject;
|
|
}
|
|
// package-shared/functions/backend/auth/write-auth-files.ts
|
|
import fs13 from "fs";
|
|
import path9 from "path";
|
|
var grabAuthDirs = () => {
|
|
const DSQL_AUTH_DIR = process.env.DSQL_AUTH_DIR;
|
|
const ROOT_DIR = DSQL_AUTH_DIR?.match(/./) ? DSQL_AUTH_DIR : path9.resolve(process.cwd(), "./.tmp");
|
|
const AUTH_DIR = path9.join(ROOT_DIR, "logins");
|
|
return { root: ROOT_DIR, auth: AUTH_DIR };
|
|
};
|
|
var initAuthFiles = () => {
|
|
try {
|
|
const authDirs = grabAuthDirs();
|
|
if (!fs13.existsSync(authDirs.root))
|
|
fs13.mkdirSync(authDirs.root, { recursive: true });
|
|
if (!fs13.existsSync(authDirs.auth))
|
|
fs13.mkdirSync(authDirs.auth, { recursive: true });
|
|
return true;
|
|
} catch (error) {
|
|
console.log(`Error initializing Auth Files: ${error.message}`);
|
|
return false;
|
|
}
|
|
};
|
|
var writeAuthFile = (name, data) => {
|
|
initAuthFiles();
|
|
try {
|
|
fs13.writeFileSync(path9.join(grabAuthDirs().auth, name), data);
|
|
return true;
|
|
} catch (error) {
|
|
console.log(`Error writing Auth File: ${error.message}`);
|
|
return false;
|
|
}
|
|
};
|
|
var deleteAuthFile = (name) => {
|
|
try {
|
|
return fs13.rmSync(path9.join(grabAuthDirs().auth, name));
|
|
} catch (error) {
|
|
console.log(`Error deleting Auth File: ${error.message}`);
|
|
return null;
|
|
}
|
|
};
|
|
var checkAuthFile = (name) => {
|
|
try {
|
|
return fs13.existsSync(path9.join(grabAuthDirs().auth, name));
|
|
return true;
|
|
} catch (error) {
|
|
console.log(`Error checking Auth File: ${error.message}`);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// users/login-user.ts
|
|
async function loginUser({
|
|
key,
|
|
payload,
|
|
database,
|
|
additionalFields,
|
|
response,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
email_login,
|
|
email_login_code,
|
|
temp_code_field,
|
|
token,
|
|
user_id,
|
|
skipPassword,
|
|
useLocal,
|
|
apiUserID,
|
|
skipWriteAuthFile
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const defaultTempLoginFieldName = "temp_login_code";
|
|
const emailLoginTempCodeFieldName = email_login ? temp_code_field ? temp_code_field : defaultTempLoginFieldName : undefined;
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
console.log("Encryption key is invalid");
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Encryption key is invalid"
|
|
};
|
|
}
|
|
if (!finalEncryptionSalt?.match(/.{8,}/)) {
|
|
console.log("Encryption salt is invalid");
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Encryption salt is invalid"
|
|
};
|
|
}
|
|
if (!payload.email) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Email Required"
|
|
};
|
|
}
|
|
let httpResponse = {
|
|
success: false
|
|
};
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path10.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs14.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
httpResponse = await apiLoginUser({
|
|
database: process.env.DSQL_DB_NAME || "",
|
|
email: payload.email,
|
|
username: payload.username,
|
|
password: payload.password,
|
|
skipPassword,
|
|
encryptionKey: finalEncryptionKey,
|
|
additionalFields,
|
|
email_login,
|
|
email_login_code,
|
|
email_login_field: emailLoginTempCodeFieldName,
|
|
token,
|
|
useLocal
|
|
});
|
|
} else {
|
|
httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = {
|
|
encryptionKey: finalEncryptionKey,
|
|
payload,
|
|
database,
|
|
additionalFields,
|
|
email_login,
|
|
email_login_code,
|
|
email_login_field: emailLoginTempCodeFieldName,
|
|
token,
|
|
skipPassword
|
|
};
|
|
const reqPayloadJSON = JSON.stringify(reqPayload);
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayloadJSON).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/login-user`
|
|
}, (res) => {
|
|
var str = "";
|
|
res.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
res.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
res.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayloadJSON);
|
|
httpsRequest.end();
|
|
});
|
|
}
|
|
if (httpResponse?.success) {
|
|
let encryptedPayload = encrypt({
|
|
data: JSON.stringify(httpResponse.payload),
|
|
encryptionKey: finalEncryptionKey,
|
|
encryptionSalt: finalEncryptionSalt
|
|
});
|
|
try {
|
|
if (token && encryptedPayload)
|
|
httpResponse["token"] = encryptedPayload;
|
|
} catch (error) {
|
|
}
|
|
const cookieNames = getAuthCookieNames({
|
|
database,
|
|
userId: apiUserID || user_id || grabedHostNames.user_id
|
|
});
|
|
if (httpResponse.csrf && !skipWriteAuthFile) {
|
|
writeAuthFile(httpResponse.csrf, JSON.stringify(httpResponse.payload));
|
|
}
|
|
httpResponse["cookieNames"] = cookieNames;
|
|
httpResponse["key"] = String(encryptedPayload);
|
|
const authKeyName = cookieNames.keyCookieName;
|
|
const csrfName = cookieNames.csrfCookieName;
|
|
response?.setHeader("Set-Cookie", [
|
|
`${authKeyName}=${encryptedPayload};samesite=strict;path=/;HttpOnly=true;Secure=true`,
|
|
`${csrfName}=${httpResponse.payload?.csrf_k};samesite=strict;path=/;HttpOnly=true`
|
|
]);
|
|
}
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/send-email-code.ts
|
|
init_grab_host_names();
|
|
import fs15 from "fs";
|
|
import path11 from "path";
|
|
|
|
// package-shared/functions/api/users/api-send-email-code.ts
|
|
init_varDatabaseDbHandler();
|
|
var import_nodemailer = __toESM(require_nodemailer(), 1);
|
|
init_encrypt();
|
|
|
|
// package-shared/utils/serialize-cookies.ts
|
|
function serializeCookies({
|
|
cookies
|
|
}) {
|
|
let cookiesStringsArray = [];
|
|
for (let i = 0;i < cookies.length; i++) {
|
|
const cookieObject = cookies[i];
|
|
let cookieString = `${cookieObject.name}=${cookieObject.value}`;
|
|
if (cookieObject.maxAge) {
|
|
cookieString += `;Max-Age=${cookieObject.maxAge}`;
|
|
}
|
|
if (cookieObject.path) {
|
|
cookieString += `;Path=${cookieObject.path}`;
|
|
}
|
|
if (cookieObject.domain) {
|
|
cookieString += `;Domain=${cookieObject.domain}`;
|
|
}
|
|
if (cookieObject.secure) {
|
|
cookieString += ";Secure";
|
|
}
|
|
if (cookieObject.httpOnly) {
|
|
cookieString += ";HttpOnly";
|
|
}
|
|
if (cookieObject.sameSite) {
|
|
cookieString += `;SameSite=${cookieObject.sameSite}`;
|
|
}
|
|
if (cookieObject.expires) {
|
|
cookieString += `;expires=${cookieObject.expires}`;
|
|
}
|
|
if (cookieObject.priority) {
|
|
cookieString += `;priority=${cookieObject.priority}`;
|
|
}
|
|
cookiesStringsArray.push(cookieString);
|
|
}
|
|
return cookiesStringsArray;
|
|
}
|
|
|
|
// package-shared/functions/api/users/api-send-email-code.ts
|
|
async function apiSendEmailCode({
|
|
email,
|
|
database,
|
|
email_login_field,
|
|
mail_domain,
|
|
mail_port,
|
|
sender,
|
|
mail_username,
|
|
mail_password,
|
|
html,
|
|
useLocal,
|
|
response,
|
|
extraCookies
|
|
}) {
|
|
if (email?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
msg: "Invalid Email/Password format"
|
|
};
|
|
}
|
|
const createdAt = Date.now();
|
|
const foundUserQuery = `SELECT * FROM users WHERE email = ?`;
|
|
const foundUserValues = [email];
|
|
let foundUser = await varDatabaseDbHandler2({
|
|
queryString: foundUserQuery,
|
|
queryValuesArray: foundUserValues,
|
|
database,
|
|
useLocal
|
|
});
|
|
if (!foundUser || !foundUser[0]) {
|
|
return {
|
|
success: false,
|
|
msg: "No user found"
|
|
};
|
|
}
|
|
function generateCode() {
|
|
const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
let code = "";
|
|
for (let i = 0;i < 8; i++) {
|
|
code += chars[Math.floor(Math.random() * chars.length)];
|
|
}
|
|
return code;
|
|
}
|
|
if (foundUser?.[0] && email_login_field) {
|
|
const tempCode = generateCode();
|
|
let transporter = import_nodemailer.default.createTransport({
|
|
host: mail_domain || process.env.DSQL_MAIL_HOST,
|
|
port: mail_port ? mail_port : process.env.DSQL_MAIL_PORT ? Number(process.env.DSQL_MAIL_PORT) : 465,
|
|
secure: true,
|
|
auth: {
|
|
user: mail_username || process.env.DSQL_MAIL_EMAIL,
|
|
pass: mail_password || process.env.DSQL_MAIL_PASSWORD
|
|
}
|
|
});
|
|
let mailObject = {};
|
|
mailObject["from"] = `"Datasquirel SSO" <${sender || "support@datasquirel.com"}>`;
|
|
mailObject["sender"] = sender || "support@datasquirel.com";
|
|
mailObject["to"] = email;
|
|
mailObject["subject"] = "One Time Login Code";
|
|
mailObject["html"] = html.replace(/{{code}}/, tempCode);
|
|
const info = await transporter.sendMail(mailObject);
|
|
if (!info?.accepted)
|
|
throw new Error("Mail not Sent!");
|
|
const setTempCodeQuery = `UPDATE users SET ${email_login_field} = ? WHERE email = ?`;
|
|
const setTempCodeValues = [tempCode + `-${createdAt}`, email];
|
|
let setTempCode = await varDatabaseDbHandler2({
|
|
queryString: setTempCodeQuery,
|
|
queryValuesArray: setTempCodeValues,
|
|
database,
|
|
useLocal
|
|
});
|
|
const resObject = {
|
|
success: true,
|
|
code: tempCode,
|
|
email,
|
|
createdAt,
|
|
msg: "Success"
|
|
};
|
|
if (response) {
|
|
const cookieKeyNames = getAuthCookieNames();
|
|
const oneTimeCodeCookieName = cookieKeyNames.oneTimeCodeName;
|
|
const encryptedPayload = encrypt({
|
|
data: JSON.stringify(resObject)
|
|
});
|
|
if (!encryptedPayload) {
|
|
throw new Error("apiSendEmailCode Error: Failed to encrypt payload");
|
|
}
|
|
const oneTimeCookieObject = {
|
|
name: oneTimeCodeCookieName,
|
|
value: encryptedPayload,
|
|
sameSite: "Strict",
|
|
path: "/",
|
|
httpOnly: true,
|
|
secure: true
|
|
};
|
|
const cookiesObjectArray = extraCookies ? [...extraCookies, oneTimeCookieObject] : [oneTimeCookieObject];
|
|
const serializedCookies = serializeCookies({
|
|
cookies: cookiesObjectArray
|
|
});
|
|
response.setHeader("Set-Cookie", serializedCookies);
|
|
}
|
|
return resObject;
|
|
} else {
|
|
return {
|
|
success: false,
|
|
msg: "Invalid Email/Password format"
|
|
};
|
|
}
|
|
}
|
|
|
|
// users/send-email-code.ts
|
|
var __dirname = "/home/benoti/Projects/Git/moduletrace/datasquirel/datasquirel/users";
|
|
async function sendEmailCode({
|
|
key,
|
|
email,
|
|
database,
|
|
temp_code_field_name,
|
|
mail_domain,
|
|
mail_password,
|
|
mail_username,
|
|
mail_port,
|
|
sender,
|
|
user_id,
|
|
useLocal,
|
|
response,
|
|
extraCookies
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const defaultTempLoginFieldName = "temp_login_code";
|
|
const emailLoginTempCodeFieldName = temp_code_field_name ? temp_code_field_name : defaultTempLoginFieldName;
|
|
const emailHtml = fs15.readFileSync(path11.resolve(__dirname, "../package-shared/html/one-time-code.html"), "utf-8");
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path11.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs15.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiSendEmailCode({
|
|
database: DSQL_DB_NAME,
|
|
email,
|
|
email_login_field: emailLoginTempCodeFieldName,
|
|
html: emailHtml,
|
|
mail_domain,
|
|
mail_password,
|
|
mail_port,
|
|
mail_username,
|
|
sender,
|
|
useLocal,
|
|
response,
|
|
extraCookies
|
|
});
|
|
} else {
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
email,
|
|
database,
|
|
email_login_field: emailLoginTempCodeFieldName,
|
|
mail_domain,
|
|
mail_password,
|
|
mail_username,
|
|
mail_port,
|
|
sender,
|
|
html: emailHtml
|
|
});
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/send-email-code`
|
|
}, (res) => {
|
|
var str = "";
|
|
res.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
res.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
res.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
}
|
|
|
|
// users/logout-user.ts
|
|
init_decrypt();
|
|
init_ejson();
|
|
function logoutUser({
|
|
response,
|
|
database,
|
|
dsqlUserId,
|
|
encryptedUserString,
|
|
request,
|
|
cookieString
|
|
}) {
|
|
try {
|
|
const cookieNames = getAuthCookieNames({
|
|
database,
|
|
userId: dsqlUserId || process.env.DSQL_API_USER_ID
|
|
});
|
|
const authKeyName = cookieNames.keyCookieName;
|
|
const csrfName = cookieNames.csrfCookieName;
|
|
const oneTimeCodeName = getAuthCookieNames().oneTimeCodeName;
|
|
const decryptedUserJSON = (() => {
|
|
try {
|
|
if (request) {
|
|
const cookiesObject = parseCookies({
|
|
request,
|
|
cookieString
|
|
});
|
|
return decrypt({
|
|
encryptedString: cookiesObject[authKeyName]
|
|
});
|
|
} else if (encryptedUserString) {
|
|
return decrypt({
|
|
encryptedString: encryptedUserString
|
|
});
|
|
} else {
|
|
return;
|
|
}
|
|
} catch (error) {
|
|
console.log("Error getting decrypted User JSON to logout:", error.message);
|
|
return;
|
|
}
|
|
})();
|
|
if (!decryptedUserJSON)
|
|
throw new Error("Invalid User");
|
|
const userObject = ejson_default.parse(decryptedUserJSON);
|
|
if (!userObject?.csrf_k)
|
|
throw new Error("Invalid User. Please check key");
|
|
response?.setHeader("Set-Cookie", [
|
|
`${authKeyName}=null;max-age=0`,
|
|
`${csrfName}=null;max-age=0`,
|
|
`${oneTimeCodeName}=null;max-age=0`
|
|
]);
|
|
const csrf = userObject.csrf_k;
|
|
deleteAuthFile(csrf);
|
|
return {
|
|
success: true,
|
|
msg: "User Logged Out",
|
|
cookieNames
|
|
};
|
|
} catch (error) {
|
|
console.log("Logout Error:", error.message);
|
|
return {
|
|
success: false,
|
|
msg: "Logout Failed"
|
|
};
|
|
}
|
|
}
|
|
module_logout_user.exports = logoutUser;
|
|
|
|
// users/user-auth.ts
|
|
init_decrypt();
|
|
var minuteInMilliseconds = 60000;
|
|
var hourInMilliseconds = minuteInMilliseconds * 60;
|
|
var dayInMilliseconds = hourInMilliseconds * 24;
|
|
var weekInMilliseconds = dayInMilliseconds * 7;
|
|
var monthInMilliseconds = dayInMilliseconds * 30;
|
|
var yearInMilliseconds = dayInMilliseconds * 365;
|
|
function userAuth({
|
|
request,
|
|
req,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
level,
|
|
database,
|
|
dsqlUserId,
|
|
encryptedUserString,
|
|
expiry = weekInMilliseconds,
|
|
cookieString,
|
|
csrfHeaderIsValue,
|
|
csrfHeaderName
|
|
}) {
|
|
try {
|
|
const finalRequest = req || request;
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
const cookies = parseCookies({
|
|
request: finalRequest,
|
|
cookieString
|
|
});
|
|
const keyNames = getAuthCookieNames({
|
|
userId: dsqlUserId || process.env.DSQL_API_USER_ID,
|
|
database: database || process.env.DSQL_DB_NAME
|
|
});
|
|
const authKeyName = keyNames.keyCookieName;
|
|
const csrfName = keyNames.csrfCookieName;
|
|
const key = encryptedUserString ? encryptedUserString : cookies[authKeyName];
|
|
const csrf = cookies[csrfName];
|
|
let userPayloadJSON = decrypt({
|
|
encryptedString: key,
|
|
encryptionKey: finalEncryptionKey,
|
|
encryptionSalt: finalEncryptionSalt
|
|
});
|
|
if (!userPayloadJSON) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Couldn't Decrypt cookie"
|
|
};
|
|
}
|
|
let userObject = JSON.parse(userPayloadJSON);
|
|
if (!userObject.csrf_k) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "No CSRF_K in decrypted payload"
|
|
};
|
|
}
|
|
if (!checkAuthFile(userObject.csrf_k)) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Auth file doesn't exist"
|
|
};
|
|
}
|
|
if (level?.match(/deep/i) && finalRequest) {
|
|
if (csrfHeaderName && finalRequest.headers[csrfHeaderName] !== userObject.csrf_k) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "CSRF_K mismatch"
|
|
};
|
|
}
|
|
const targetCsrfHeaderKey = Object.keys(finalRequest.headers).map((k) => k.replace(/[^a-zA-Z0-9\-]/g, "")).find((k) => k == userObject.csrf_k);
|
|
if (csrfHeaderIsValue && !targetCsrfHeaderKey) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "CSRF_K Header Key mismatch"
|
|
};
|
|
}
|
|
}
|
|
const payloadCreationDate = Number(userObject.date);
|
|
if (Number.isNaN(payloadCreationDate) || typeof payloadCreationDate !== "number") {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Payload Creation Date is not a number"
|
|
};
|
|
}
|
|
const timeElapsed = Date.now() - payloadCreationDate;
|
|
const finalExpiry = process.env.DSQL_SESSION_EXPIRY_TIME ? Number(process.env.DSQL_SESSION_EXPIRY_TIME) : expiry;
|
|
if (timeElapsed > finalExpiry) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Session has expired"
|
|
};
|
|
}
|
|
return {
|
|
success: true,
|
|
payload: userObject
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
// users/reauth-user.ts
|
|
init_encrypt();
|
|
import fs16 from "fs";
|
|
import path12 from "path";
|
|
init_grab_host_names();
|
|
|
|
// package-shared/functions/api/users/api-reauth-user.ts
|
|
init_varDatabaseDbHandler();
|
|
async function apiReauthUser({
|
|
existingUser,
|
|
database,
|
|
additionalFields,
|
|
useLocal
|
|
}) {
|
|
let foundUser = existingUser?.id && existingUser.id.toString().match(/./) ? await varDatabaseDbHandler2({
|
|
queryString: `SELECT * FROM users WHERE id=?`,
|
|
queryValuesArray: [existingUser.id.toString()],
|
|
database,
|
|
useLocal
|
|
}) : null;
|
|
if (!foundUser || !foundUser[0])
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "No user found"
|
|
};
|
|
let csrfKey = Math.random().toString(36).substring(2) + "-" + Math.random().toString(36).substring(2);
|
|
let userPayload = {
|
|
id: foundUser[0].id,
|
|
first_name: foundUser[0].first_name,
|
|
last_name: foundUser[0].last_name,
|
|
username: foundUser[0].username,
|
|
email: foundUser[0].email,
|
|
phone: foundUser[0].phone,
|
|
social_id: foundUser[0].social_id,
|
|
image: foundUser[0].image,
|
|
image_thumbnail: foundUser[0].image_thumbnail,
|
|
verification_status: foundUser[0].verification_status,
|
|
social_login: foundUser[0].social_login,
|
|
social_platform: foundUser[0].social_platform,
|
|
csrf_k: csrfKey,
|
|
more_data: foundUser[0].more_user_data,
|
|
logged_in_status: true,
|
|
date: Date.now()
|
|
};
|
|
if (additionalFields && Array.isArray(additionalFields) && additionalFields.length > 0) {
|
|
additionalFields.forEach((key) => {
|
|
userPayload[key] = foundUser[0][key];
|
|
});
|
|
}
|
|
return {
|
|
success: true,
|
|
msg: "Login Successful",
|
|
payload: userPayload,
|
|
csrf: csrfKey
|
|
};
|
|
}
|
|
|
|
// users/reauth-user.ts
|
|
async function reauthUser({
|
|
key,
|
|
database,
|
|
response,
|
|
request,
|
|
level,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
additionalFields,
|
|
encryptedUserString,
|
|
user_id,
|
|
useLocal
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
const existingUser = userAuth({
|
|
database,
|
|
encryptionKey: finalEncryptionKey,
|
|
encryptionSalt: finalEncryptionSalt,
|
|
level,
|
|
request,
|
|
encryptedUserString
|
|
});
|
|
if (!existingUser?.payload?.id) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Cookie Credentials Invalid"
|
|
};
|
|
}
|
|
let httpResponse;
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path12.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs16.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
httpResponse = await apiReauthUser({
|
|
existingUser: existingUser.payload,
|
|
additionalFields,
|
|
useLocal
|
|
});
|
|
} else {
|
|
httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
existingUser: existingUser.payload,
|
|
database,
|
|
additionalFields
|
|
});
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/reauth-user`
|
|
}, (response2) => {
|
|
var str = "";
|
|
response2.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response2.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response2.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
}
|
|
if (httpResponse?.success) {
|
|
let encryptedPayload = encrypt({
|
|
data: JSON.stringify(httpResponse.payload),
|
|
encryptionKey: finalEncryptionKey,
|
|
encryptionSalt: finalEncryptionSalt
|
|
});
|
|
const cookieNames = getAuthCookieNames({
|
|
database,
|
|
userId: user_id || grabedHostNames.user_id
|
|
});
|
|
httpResponse["cookieNames"] = cookieNames;
|
|
httpResponse["key"] = String(encryptedPayload);
|
|
const authKeyName = cookieNames.keyCookieName;
|
|
const csrfName = cookieNames.csrfCookieName;
|
|
response?.setHeader("Set-Cookie", [
|
|
`${authKeyName}=${encryptedPayload};samesite=strict;path=/;HttpOnly=true;Secure=true`,
|
|
`${csrfName}=${httpResponse.payload?.csrf_k};samesite=strict;path=/;HttpOnly=true`
|
|
]);
|
|
if (httpResponse.csrf) {
|
|
deleteAuthFile(String(existingUser.payload.csrf_k));
|
|
writeAuthFile(httpResponse.csrf, JSON.stringify(httpResponse.payload));
|
|
}
|
|
}
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/get-user.ts
|
|
init_grab_host_names();
|
|
import path13 from "path";
|
|
import fs17 from "fs";
|
|
|
|
// package-shared/functions/api/users/api-get-user.ts
|
|
init_varDatabaseDbHandler();
|
|
async function apiGetUser({
|
|
fields,
|
|
dbFullName,
|
|
userId,
|
|
useLocal
|
|
}) {
|
|
const query = `SELECT ${fields.join(",")} FROM users WHERE id=?`;
|
|
const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
|
|
let foundUser = await varDatabaseDbHandler2({
|
|
queryString: query,
|
|
queryValuesArray: [API_USER_ID],
|
|
database: dbFullName.replace(/[^a-z0-9_]/g, ""),
|
|
useLocal
|
|
});
|
|
if (!foundUser || !foundUser[0]) {
|
|
return {
|
|
success: false,
|
|
payload: null
|
|
};
|
|
}
|
|
return {
|
|
success: true,
|
|
payload: foundUser[0]
|
|
};
|
|
}
|
|
|
|
// users/get-user.ts
|
|
async function getUser({
|
|
key,
|
|
userId,
|
|
database,
|
|
fields,
|
|
apiUserId,
|
|
useLocal
|
|
}) {
|
|
const defaultFields = [
|
|
"id",
|
|
"first_name",
|
|
"last_name",
|
|
"email",
|
|
"username",
|
|
"image",
|
|
"image_thumbnail",
|
|
"verification_status",
|
|
"date_created",
|
|
"date_created_code",
|
|
"date_created_timestamp",
|
|
"date_updated",
|
|
"date_updated_code",
|
|
"date_updated_timestamp"
|
|
];
|
|
const updatedFields = fields && fields[0] ? [...defaultFields, ...fields] : defaultFields;
|
|
const reqPayload = JSON.stringify({
|
|
userId,
|
|
database,
|
|
fields: [...new Set(updatedFields)]
|
|
});
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path13.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs17.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
return await apiGetUser({
|
|
userId,
|
|
fields: [...new Set(updatedFields)],
|
|
dbFullName: DSQL_DB_NAME,
|
|
useLocal
|
|
});
|
|
}
|
|
const httpResponse = await new Promise((resolve, reject) => {
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${apiUserId || grabedHostNames.user_id}/get-user`
|
|
}, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/social/google-auth.ts
|
|
init_encrypt();
|
|
init_grab_host_names();
|
|
|
|
// package-shared/functions/api/users/social/api-google-login.ts
|
|
import https2 from "https";
|
|
|
|
// package-shared/functions/api/social-login/handleSocialDb.ts
|
|
import fs19 from "fs";
|
|
|
|
// package-shared/functions/backend/handleNodemailer.ts
|
|
var import_nodemailer2 = __toESM(require_nodemailer(), 1);
|
|
import fs18 from "fs";
|
|
var transporter = import_nodemailer2.default.createTransport({
|
|
host: process.env.DSQL_MAIL_HOST,
|
|
port: 465,
|
|
secure: true,
|
|
auth: {
|
|
user: process.env.DSQL_MAIL_EMAIL,
|
|
pass: process.env.DSQL_MAIL_PASSWORD
|
|
}
|
|
});
|
|
async function handleNodemailer({
|
|
to,
|
|
subject,
|
|
text,
|
|
html,
|
|
alias,
|
|
senderName
|
|
}) {
|
|
if (!process.env.DSQL_MAIL_HOST || !process.env.DSQL_MAIL_EMAIL || !process.env.DSQL_MAIL_PASSWORD) {
|
|
return null;
|
|
}
|
|
const sender = (() => {
|
|
if (alias?.match(/support/i))
|
|
return process.env.DSQL_MAIL_EMAIL;
|
|
return process.env.DSQL_MAIL_EMAIL;
|
|
})();
|
|
let sentMessage;
|
|
if (!fs18.existsSync("./email/index.html")) {
|
|
return;
|
|
}
|
|
let mailRoot = fs18.readFileSync("./email/index.html", "utf8");
|
|
let finalHtml = mailRoot.replace(/{{email_body}}/, html ? html : "").replace(/{{issue_date}}/, Date().substring(0, 24));
|
|
try {
|
|
let mailObject = {};
|
|
mailObject["from"] = `"${senderName || "Datasquirel"}" <${sender}>`;
|
|
mailObject["sender"] = sender;
|
|
if (alias)
|
|
mailObject["replyTo"] = sender;
|
|
mailObject["to"] = to;
|
|
mailObject["subject"] = subject;
|
|
mailObject["text"] = text;
|
|
mailObject["html"] = finalHtml;
|
|
let info = await transporter.sendMail(mailObject);
|
|
sentMessage = info;
|
|
} catch (error) {
|
|
console.log("ERROR in handleNodemailer Function =>", error.message);
|
|
}
|
|
return sentMessage;
|
|
}
|
|
|
|
// package-shared/functions/api/social-login/handleSocialDb.ts
|
|
import path14 from "path";
|
|
|
|
// package-shared/functions/backend/addMariadbUser.ts
|
|
var import_generate_password = __toESM(require_generate(), 1);
|
|
init_DB_HANDLER();
|
|
|
|
// package-shared/utils/backend/global-db/NO_DB_HANDLER.ts
|
|
var import_serverless_mysql5 = __toESM(require_serverless_mysql(), 1);
|
|
init_grabDbSSL();
|
|
var NO_DB = import_serverless_mysql5.default({
|
|
config: {
|
|
host: process.env.DSQL_DB_HOST,
|
|
user: process.env.DSQL_DB_USERNAME,
|
|
password: process.env.DSQL_DB_PASSWORD,
|
|
charset: "utf8mb4",
|
|
ssl: grabDbSSL()
|
|
}
|
|
});
|
|
function NO_DB_HANDLER(...args) {
|
|
try {
|
|
return new Promise((resolve, reject) => {
|
|
NO_DB.query(...args).then((results) => {
|
|
NO_DB.end();
|
|
resolve(JSON.parse(JSON.stringify(results)));
|
|
}).catch((err) => {
|
|
NO_DB.end();
|
|
resolve({
|
|
error: err.message,
|
|
sql: err.sql
|
|
});
|
|
});
|
|
});
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/backend/addMariadbUser.ts
|
|
init_encrypt();
|
|
init_LOCAL_DB_HANDLER();
|
|
async function addMariadbUser({
|
|
userId,
|
|
useLocal
|
|
}) {
|
|
try {
|
|
const defaultMariadbUserHost = process.env.DSQL_DB_HOST || "127.0.0.1";
|
|
const username = `dsql_user_${userId}`;
|
|
const password = import_generate_password.default.generate({
|
|
length: 16,
|
|
numbers: true,
|
|
symbols: true,
|
|
uppercase: true,
|
|
exclude: "*#.'`\""
|
|
});
|
|
const encryptedPassword = encrypt({ data: password });
|
|
const createMariadbUsersQuery = `CREATE USER IF NOT EXISTS '${username}'@'127.0.0.1' IDENTIFIED BY '${password}'`;
|
|
if (useLocal) {
|
|
await LOCAL_DB_HANDLER(createMariadbUsersQuery);
|
|
} else {
|
|
await NO_DB_HANDLER(createMariadbUsersQuery);
|
|
}
|
|
const updateUserQuery = `UPDATE users SET mariadb_user = ?, mariadb_host = '127.0.0.1', mariadb_pass = ? WHERE id = ?`;
|
|
const updateUserValues = [username, encryptedPassword, userId];
|
|
const updateUser2 = useLocal ? await LOCAL_DB_HANDLER(updateUserQuery, updateUserValues) : await DB_HANDLER(updateUserQuery, updateUserValues);
|
|
const addMariadbUser2 = await addDbEntry({
|
|
tableName: "mariadb_users",
|
|
data: {
|
|
user_id: userId,
|
|
username,
|
|
host: defaultMariadbUserHost,
|
|
password: encryptedPassword,
|
|
primary: "1",
|
|
grants: '[{"database":"*","table":"*","privileges":["ALL"]}]'
|
|
},
|
|
dbContext: "Master",
|
|
useLocal
|
|
});
|
|
console.log(`User ${userId} SQL credentials successfully added.`);
|
|
} catch (error) {
|
|
console.log(`Error in adding SQL user in 'addMariadbUser' function =>`, error.message);
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/api/social-login/handleSocialDb.ts
|
|
init_varDatabaseDbHandler();
|
|
init_encrypt();
|
|
|
|
// package-shared/functions/backend/addAdminUserOnLogin.ts
|
|
init_serverError();
|
|
init_DB_HANDLER();
|
|
init_LOCAL_DB_HANDLER();
|
|
async function addAdminUserOnLogin({
|
|
query,
|
|
user,
|
|
useLocal
|
|
}) {
|
|
try {
|
|
const finalDbHandler = useLocal ? LOCAL_DB_HANDLER : DB_HANDLER;
|
|
const { invite, database_access, priviledge, email } = query;
|
|
const lastInviteTimeQuery = `SELECT date_created_code FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`;
|
|
const lastInviteTimeValues = [invite, email];
|
|
const lastInviteTimeArray = await finalDbHandler(lastInviteTimeQuery, lastInviteTimeValues);
|
|
if (!lastInviteTimeArray || !lastInviteTimeArray[0]) {
|
|
throw new Error("No Invitation Found");
|
|
}
|
|
const invitingUserDbQuery = `SELECT first_name,last_name,email FROM users WHERE id=?`;
|
|
const invitingUserDbValues = [invite];
|
|
const invitingUserDb = await finalDbHandler(invitingUserDbQuery, invitingUserDbValues);
|
|
if (invitingUserDb?.[0]) {
|
|
const existingUserUser = await finalDbHandler(`SELECT email FROM user_users WHERE user_id=? AND invited_user_id=? AND user_type='admin' AND email=?`, [invite, user.id, email]);
|
|
if (existingUserUser?.[0]) {
|
|
console.log("User already added");
|
|
} else {
|
|
addDbEntry({
|
|
dbFullName: "datasquirel",
|
|
tableName: "user_users",
|
|
data: {
|
|
user_id: invite,
|
|
invited_user_id: user.id,
|
|
database_access,
|
|
first_name: user.first_name,
|
|
last_name: user.last_name,
|
|
phone: user.phone,
|
|
email: user.email,
|
|
username: user.username,
|
|
user_type: "admin",
|
|
user_priviledge: priviledge,
|
|
image: user.image,
|
|
image_thumbnail: user.image_thumbnail
|
|
},
|
|
useLocal
|
|
});
|
|
const dbTableData = await finalDbHandler(`SELECT db_tables_data FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
|
|
const clearEntries = await finalDbHandler(`DELETE FROM delegated_user_tables WHERE root_user_id=? AND delegated_user_id=?`, [invite, user.id]);
|
|
if (dbTableData && dbTableData[0]) {
|
|
const dbTableEntries = dbTableData[0].db_tables_data.split("|");
|
|
for (let i = 0;i < dbTableEntries.length; i++) {
|
|
const dbTableEntry = dbTableEntries[i];
|
|
const dbTableEntryArray = dbTableEntry.split("-");
|
|
const [db_slug, table_slug] = dbTableEntryArray;
|
|
const newEntry = await addDbEntry({
|
|
dbFullName: "datasquirel",
|
|
tableName: "delegated_user_tables",
|
|
data: {
|
|
delegated_user_id: user.id,
|
|
root_user_id: invite,
|
|
database: db_slug,
|
|
table: table_slug,
|
|
priviledge
|
|
},
|
|
useLocal
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const inviteAccepted = await finalDbHandler(`UPDATE invitations SET invitation_status='Accepted' WHERE inviting_user_id=? AND invited_user_email=?`, [invite, email]);
|
|
}
|
|
} catch (error) {
|
|
serverError({
|
|
component: "addAdminUserOnLogin",
|
|
message: error.message,
|
|
user
|
|
});
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/api/social-login/loginSocialUser.ts
|
|
init_varDatabaseDbHandler();
|
|
async function loginSocialUser({
|
|
user,
|
|
social_platform,
|
|
invitation,
|
|
database,
|
|
additionalFields,
|
|
useLocal
|
|
}) {
|
|
const foundUserQuery = `SELECT * FROM users WHERE email=? AND social_id=? AND social_platform=?`;
|
|
const foundUserValues = [user.email, user.social_id, social_platform];
|
|
const foundUser = await varDatabaseDbHandler2({
|
|
database: database ? database : "datasquirel",
|
|
queryString: foundUserQuery,
|
|
queryValuesArray: foundUserValues,
|
|
useLocal
|
|
});
|
|
if (!foundUser?.[0])
|
|
return {
|
|
success: false,
|
|
payload: null
|
|
};
|
|
let csrfKey = Math.random().toString(36).substring(2) + "-" + Math.random().toString(36).substring(2);
|
|
let userPayload = {
|
|
id: foundUser[0].id,
|
|
first_name: foundUser[0].first_name,
|
|
last_name: foundUser[0].last_name,
|
|
username: foundUser[0].username,
|
|
user_type: foundUser[0].user_type,
|
|
email: foundUser[0].email,
|
|
social_id: foundUser[0].social_id,
|
|
image: foundUser[0].image,
|
|
image_thumbnail: foundUser[0].image_thumbnail,
|
|
verification_status: foundUser[0].verification_status,
|
|
social_login: foundUser[0].social_login,
|
|
social_platform: foundUser[0].social_platform,
|
|
csrf_k: csrfKey,
|
|
logged_in_status: true,
|
|
date: Date.now()
|
|
};
|
|
if (additionalFields?.[0]) {
|
|
additionalFields.forEach((key) => {
|
|
userPayload[key] = foundUser[0][key];
|
|
});
|
|
}
|
|
if (invitation && (!database || database?.match(/^datasquirel$/))) {
|
|
addAdminUserOnLogin({
|
|
query: invitation,
|
|
user: userPayload,
|
|
useLocal
|
|
});
|
|
}
|
|
let result = {
|
|
success: true,
|
|
payload: userPayload,
|
|
csrf: csrfKey
|
|
};
|
|
return result;
|
|
}
|
|
|
|
// package-shared/functions/api/social-login/handleSocialDb.ts
|
|
async function handleSocialDb({
|
|
database,
|
|
social_id,
|
|
email,
|
|
social_platform,
|
|
payload,
|
|
invitation,
|
|
supEmail,
|
|
additionalFields,
|
|
useLocal
|
|
}) {
|
|
try {
|
|
const existingSocialIdUserQuery = `SELECT * FROM users WHERE social_id = ? AND social_login='1' AND social_platform = ? `;
|
|
const existingSocialIdUserValues = [
|
|
social_id.toString(),
|
|
social_platform
|
|
];
|
|
let existingSocialIdUser = await varDatabaseDbHandler2({
|
|
database: database ? database : "datasquirel",
|
|
queryString: existingSocialIdUserQuery,
|
|
queryValuesArray: existingSocialIdUserValues,
|
|
useLocal
|
|
});
|
|
if (existingSocialIdUser && existingSocialIdUser[0]) {
|
|
return await loginSocialUser({
|
|
user: existingSocialIdUser[0],
|
|
social_platform,
|
|
invitation,
|
|
database,
|
|
additionalFields,
|
|
useLocal
|
|
});
|
|
}
|
|
const finalEmail = email ? email : supEmail ? supEmail : null;
|
|
if (!finalEmail) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "No Email Present"
|
|
};
|
|
}
|
|
const existingEmailOnlyQuery = `SELECT * FROM users WHERE email='${finalEmail}'`;
|
|
let existingEmailOnly = await varDatabaseDbHandler2({
|
|
database: database ? database : "datasquirel",
|
|
queryString: existingEmailOnlyQuery,
|
|
useLocal
|
|
});
|
|
if (existingEmailOnly && existingEmailOnly[0]) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "This Email is already taken"
|
|
};
|
|
}
|
|
const foundUserQuery = `SELECT * FROM users WHERE email=? AND social_login='1' AND social_platform=? AND social_id=?`;
|
|
const foundUserQueryValues = [finalEmail, social_platform, social_id];
|
|
const foundUser = await varDatabaseDbHandler2({
|
|
database: database ? database : "datasquirel",
|
|
queryString: foundUserQuery,
|
|
queryValuesArray: foundUserQueryValues,
|
|
useLocal
|
|
});
|
|
if (foundUser && foundUser[0]) {
|
|
return await loginSocialUser({
|
|
user: payload,
|
|
social_platform,
|
|
invitation,
|
|
database,
|
|
additionalFields,
|
|
useLocal
|
|
});
|
|
}
|
|
const socialHashedPassword = encrypt({
|
|
data: social_id.toString()
|
|
});
|
|
const data = {
|
|
social_login: "1",
|
|
verification_status: supEmail ? "0" : "1",
|
|
password: socialHashedPassword
|
|
};
|
|
Object.keys(payload).forEach((key) => {
|
|
data[key] = payload[key];
|
|
});
|
|
const newUser = await addDbEntry({
|
|
dbContext: database ? "Dsql User" : undefined,
|
|
paradigm: database ? "Full Access" : undefined,
|
|
dbFullName: database ? database : "datasquirel",
|
|
tableName: "users",
|
|
duplicateColumnName: "email",
|
|
duplicateColumnValue: finalEmail,
|
|
data: {
|
|
...data,
|
|
email: finalEmail
|
|
},
|
|
useLocal
|
|
});
|
|
if (newUser?.insertId) {
|
|
if (!database) {
|
|
await addMariadbUser({ userId: newUser.insertId, useLocal });
|
|
}
|
|
const newUserQueriedQuery = `SELECT * FROM users WHERE id='${newUser.insertId}'`;
|
|
const newUserQueried = await varDatabaseDbHandler2({
|
|
database: database ? database : "datasquirel",
|
|
queryString: newUserQueriedQuery,
|
|
useLocal
|
|
});
|
|
if (!newUserQueried || !newUserQueried[0])
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "User Insertion Failed!"
|
|
};
|
|
if (supEmail && database?.match(/^datasquirel$/)) {
|
|
let generatedToken = encrypt({
|
|
data: JSON.stringify({
|
|
id: newUser.insertId,
|
|
email: supEmail,
|
|
dateCode: Date.now()
|
|
})
|
|
});
|
|
handleNodemailer({
|
|
to: supEmail,
|
|
subject: "Verify Email Address",
|
|
text: "Please click the link to verify your email address",
|
|
html: fs19.readFileSync("./email/send-email-verification-link.html", "utf8").replace(/{{host}}/, process.env.DSQL_HOST || "").replace(/{{token}}/, generatedToken || "")
|
|
}).then(() => {
|
|
});
|
|
}
|
|
const STATIC_ROOT = process.env.DSQL_STATIC_SERVER_DIR;
|
|
if (!STATIC_ROOT) {
|
|
console.log("Static File ENV not Found!");
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Static File ENV not Found!"
|
|
};
|
|
}
|
|
if (!database || database?.match(/^datasquirel$/)) {
|
|
let newUserSchemaFolderPath = `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${newUser.insertId}`;
|
|
let newUserMediaFolderPath = path14.join(STATIC_ROOT, `images/user-images/user-${newUser.insertId}`);
|
|
fs19.mkdirSync(newUserSchemaFolderPath);
|
|
fs19.mkdirSync(newUserMediaFolderPath);
|
|
fs19.writeFileSync(`${newUserSchemaFolderPath}/main.json`, JSON.stringify([]), "utf8");
|
|
}
|
|
return await loginSocialUser({
|
|
user: newUserQueried[0],
|
|
social_platform,
|
|
invitation,
|
|
database,
|
|
additionalFields,
|
|
useLocal
|
|
});
|
|
} else {
|
|
console.log("Social User Failed to insert in 'handleSocialDb.js' backend function =>", newUser);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Social User Failed to insert in 'handleSocialDb.js' backend function"
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.log("ERROR in 'handleSocialDb.js' backend function =>", error.message);
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/api/users/social/api-google-login.ts
|
|
init_ejson();
|
|
async function apiGoogleLogin({
|
|
token,
|
|
database,
|
|
additionalFields,
|
|
additionalData
|
|
}) {
|
|
try {
|
|
const gUser = await new Promise((resolve, reject) => {
|
|
https2.request({
|
|
method: "GET",
|
|
hostname: "www.googleapis.com",
|
|
path: "/oauth2/v3/userinfo",
|
|
headers: {
|
|
Authorization: `Bearer ${token}`
|
|
}
|
|
}, (res) => {
|
|
let data = "";
|
|
res.on("data", (chunk) => {
|
|
data += chunk;
|
|
});
|
|
res.on("end", () => {
|
|
resolve(ejson_default.parse(data));
|
|
});
|
|
}).end();
|
|
});
|
|
if (!gUser?.email_verified)
|
|
throw new Error("No Google User.");
|
|
if (!database || typeof database != "string" || database?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
payload: undefined,
|
|
msg: "Please provide a database slug(database name in lowercase with no spaces)"
|
|
};
|
|
}
|
|
const { given_name, family_name, email, sub, picture } = gUser;
|
|
let payloadObject = {
|
|
email,
|
|
first_name: given_name,
|
|
last_name: family_name,
|
|
social_id: sub,
|
|
social_platform: "google",
|
|
image: picture,
|
|
image_thumbnail: picture,
|
|
username: `google-user-${sub}`
|
|
};
|
|
if (additionalData) {
|
|
payloadObject = { ...payloadObject, ...additionalData };
|
|
}
|
|
const loggedInGoogleUser = await handleSocialDb({
|
|
database,
|
|
email: email || "",
|
|
payload: payloadObject,
|
|
social_platform: "google",
|
|
social_id: sub,
|
|
additionalFields
|
|
});
|
|
return { ...loggedInGoogleUser };
|
|
} catch (error) {
|
|
console.log(`apo-google-login.js ERROR: ${error.message}`);
|
|
return {
|
|
success: false,
|
|
payload: undefined,
|
|
msg: error.message
|
|
};
|
|
}
|
|
}
|
|
// users/social/google-auth.ts
|
|
async function googleAuth({
|
|
key,
|
|
token,
|
|
database,
|
|
response,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
additionalFields,
|
|
additionalData,
|
|
apiUserID,
|
|
useLocal
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
|
|
const finalEncryptionSalt = encryptionSalt || process.env.DSQL_ENCRYPTION_SALT;
|
|
if (!finalEncryptionKey?.match(/.{8,}/)) {
|
|
console.log("Encryption key is invalid");
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Encryption key is invalid"
|
|
};
|
|
}
|
|
if (!finalEncryptionSalt?.match(/.{8,}/)) {
|
|
console.log("Encryption salt is invalid");
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Encryption salt is invalid"
|
|
};
|
|
}
|
|
if (!token || token?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
payload: null,
|
|
msg: "Please enter Google Access Token"
|
|
};
|
|
}
|
|
let httpResponse = {
|
|
success: false
|
|
};
|
|
const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./) && useLocal) {
|
|
httpResponse = await apiGoogleLogin({
|
|
token,
|
|
additionalFields,
|
|
database: DSQL_DB_NAME,
|
|
additionalData
|
|
});
|
|
} else {
|
|
httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
token,
|
|
database,
|
|
additionalFields,
|
|
additionalData
|
|
});
|
|
const httpsRequest = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${apiUserID || grabedHostNames.user_id}/google-login`
|
|
}, (response2) => {
|
|
var str = "";
|
|
response2.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response2.on("end", function() {
|
|
resolve(JSON.parse(str));
|
|
});
|
|
response2.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest.write(reqPayload);
|
|
httpsRequest.end();
|
|
});
|
|
}
|
|
if (httpResponse?.success && httpResponse?.payload) {
|
|
let encryptedPayload = encrypt({
|
|
data: JSON.stringify(httpResponse.payload),
|
|
encryptionKey: finalEncryptionKey,
|
|
encryptionSalt: finalEncryptionSalt
|
|
});
|
|
const cookieNames = getAuthCookieNames({
|
|
database,
|
|
userId: apiUserID || process.env.DSQL_API_USER_ID
|
|
});
|
|
if (httpResponse.csrf) {
|
|
writeAuthFile(httpResponse.csrf, JSON.stringify(httpResponse.payload));
|
|
}
|
|
httpResponse["cookieNames"] = cookieNames;
|
|
httpResponse["key"] = String(encryptedPayload);
|
|
const authKeyName = cookieNames.keyCookieName;
|
|
const csrfName = cookieNames.csrfCookieName;
|
|
response?.setHeader("Set-Cookie", [
|
|
`${authKeyName}=${encryptedPayload};samesite=strict;path=/;HttpOnly=true;Secure=true`,
|
|
`${csrfName}=${httpResponse.payload?.csrf_k};samesite=strict;path=/;HttpOnly=true`
|
|
]);
|
|
}
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/social/github-auth.ts
|
|
init_encrypt();
|
|
init_grab_host_names();
|
|
import fs20 from "fs";
|
|
import path15 from "path";
|
|
|
|
// package-shared/functions/api/social-login/githubLogin.ts
|
|
init_DB_HANDLER();
|
|
|
|
// package-shared/functions/backend/httpsRequest.ts
|
|
import https3 from "https";
|
|
import http2 from "http";
|
|
import { URL as URL2 } from "url";
|
|
function httpsRequest({
|
|
url,
|
|
method,
|
|
hostname,
|
|
path: path15,
|
|
headers,
|
|
body,
|
|
port,
|
|
scheme
|
|
}) {
|
|
const reqPayloadString = body ? JSON.stringify(body) : null;
|
|
const PARSED_URL = url ? new URL2(url) : null;
|
|
let requestOptions = {
|
|
method: method || "GET",
|
|
hostname: PARSED_URL ? PARSED_URL.hostname : hostname,
|
|
port: scheme?.match(/https/i) ? 443 : PARSED_URL ? PARSED_URL.protocol?.match(/https/i) ? 443 : PARSED_URL.port : port ? Number(port) : 80,
|
|
headers: {}
|
|
};
|
|
if (path15)
|
|
requestOptions.path = path15;
|
|
if (headers)
|
|
requestOptions.headers = headers;
|
|
if (body) {
|
|
requestOptions.headers["Content-Type"] = "application/json";
|
|
requestOptions.headers["Content-Length"] = reqPayloadString ? Buffer.from(reqPayloadString).length : undefined;
|
|
}
|
|
return new Promise((res, rej) => {
|
|
const httpsRequest2 = ((scheme?.match(/https/i)) ? https3 : (PARSED_URL?.protocol?.match(/https/i)) ? https3 : http2).request(requestOptions, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
res(str);
|
|
});
|
|
response.on("error", (error) => {
|
|
console.log("HTTP response error =>", error.message);
|
|
rej(`HTTP response error =>, ${error.message}`);
|
|
});
|
|
response.on("close", () => {
|
|
console.log("HTTP(S) Response Closed Successfully");
|
|
});
|
|
});
|
|
if (body)
|
|
httpsRequest2.write(reqPayloadString);
|
|
httpsRequest2.on("error", (error) => {
|
|
console.log("HTTPS request ERROR =>", error.message);
|
|
rej(`HTTP request error =>, ${error.message}`);
|
|
});
|
|
httpsRequest2.end();
|
|
});
|
|
}
|
|
|
|
// package-shared/functions/api/social-login/githubLogin.ts
|
|
async function githubLogin({
|
|
code,
|
|
clientId,
|
|
clientSecret
|
|
}) {
|
|
let gitHubUser;
|
|
try {
|
|
const response = await httpsRequest({
|
|
method: "POST",
|
|
hostname: "github.com",
|
|
path: `/login/oauth/access_token?client_id=${clientId}&client_secret=${clientSecret}&code=${code}`,
|
|
headers: {
|
|
Accept: "application/json",
|
|
"User-Agent": "*"
|
|
},
|
|
scheme: "https"
|
|
});
|
|
const accessTokenObject = JSON.parse(response);
|
|
if (!accessTokenObject?.access_token) {
|
|
return gitHubUser;
|
|
}
|
|
const userDataResponse = await httpsRequest({
|
|
method: "GET",
|
|
hostname: "api.github.com",
|
|
path: "/user",
|
|
headers: {
|
|
Authorization: `Bearer ${accessTokenObject.access_token}`,
|
|
"User-Agent": "*"
|
|
},
|
|
scheme: "https"
|
|
});
|
|
gitHubUser = JSON.parse(userDataResponse);
|
|
if (!gitHubUser?.email && gitHubUser) {
|
|
const existingGithubUser = await DB_HANDLER(`SELECT email FROM users WHERE social_login='1' AND social_platform='github' AND social_id='${gitHubUser.id}'`);
|
|
if (existingGithubUser && existingGithubUser[0]) {
|
|
gitHubUser.email = existingGithubUser[0].email;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.log("ERROR in githubLogin.js backend function =>", error.message);
|
|
}
|
|
return gitHubUser;
|
|
}
|
|
|
|
// package-shared/utils/camelJoinedtoCamelSpace.ts
|
|
function camelJoinedtoCamelSpace(text) {
|
|
if (!text?.match(/./)) {
|
|
return "";
|
|
}
|
|
if (text?.match(/ /)) {
|
|
return text;
|
|
}
|
|
if (text) {
|
|
let textArray = text.split("");
|
|
let capIndexes = [];
|
|
for (let i = 0;i < textArray.length; i++) {
|
|
const char = textArray[i];
|
|
if (i === 0)
|
|
continue;
|
|
if (char.match(/[A-Z]/)) {
|
|
capIndexes.push(i);
|
|
}
|
|
}
|
|
let textChunks = [
|
|
`${textArray[0].toUpperCase()}${text.substring(1, capIndexes[0])}`
|
|
];
|
|
for (let j = 0;j < capIndexes.length; j++) {
|
|
const capIndex = capIndexes[j];
|
|
if (capIndex === 0)
|
|
continue;
|
|
const startIndex = capIndex + 1;
|
|
const endIndex = capIndexes[j + 1];
|
|
textChunks.push(`${textArray[capIndex].toUpperCase()}${text.substring(startIndex, endIndex)}`);
|
|
}
|
|
return textChunks.join(" ");
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/api/users/social/api-github-login.ts
|
|
async function apiGithubLogin({
|
|
code,
|
|
clientId,
|
|
clientSecret,
|
|
database,
|
|
additionalFields,
|
|
email,
|
|
additionalData
|
|
}) {
|
|
if (!code || !clientId || !clientSecret || !database) {
|
|
return {
|
|
success: false,
|
|
msg: "Missing query params"
|
|
};
|
|
}
|
|
if (typeof code !== "string" || typeof clientId !== "string" || typeof clientSecret !== "string" || typeof database !== "string") {
|
|
return {
|
|
success: false,
|
|
msg: "Wrong Parameters"
|
|
};
|
|
}
|
|
const gitHubUser = await githubLogin({
|
|
code,
|
|
clientId,
|
|
clientSecret
|
|
});
|
|
if (!gitHubUser) {
|
|
return {
|
|
success: false,
|
|
msg: "No github user returned"
|
|
};
|
|
}
|
|
const socialId = gitHubUser.name || gitHubUser.id || gitHubUser.login;
|
|
const targetName = gitHubUser.name || gitHubUser.login;
|
|
const nameArray = targetName?.match(/ /) ? targetName?.split(" ") : targetName?.match(/\-/) ? targetName?.split("-") : [targetName];
|
|
let payload = {
|
|
email: gitHubUser.email,
|
|
first_name: camelJoinedtoCamelSpace(nameArray[0]),
|
|
last_name: camelJoinedtoCamelSpace(nameArray[1]),
|
|
social_id: socialId,
|
|
social_platform: "github",
|
|
image: gitHubUser.avatar_url,
|
|
image_thumbnail: gitHubUser.avatar_url,
|
|
username: "github-user-" + socialId
|
|
};
|
|
if (additionalData) {
|
|
payload = { ...payload, ...additionalData };
|
|
}
|
|
const loggedInGithubUser = await handleSocialDb({
|
|
database,
|
|
email: gitHubUser.email,
|
|
payload,
|
|
social_platform: "github",
|
|
social_id: socialId,
|
|
supEmail: email,
|
|
additionalFields
|
|
});
|
|
return { ...loggedInGithubUser };
|
|
}
|
|
|
|
// users/social/github-auth.ts
|
|
async function githubAuth({
|
|
key,
|
|
code,
|
|
email,
|
|
database,
|
|
clientId,
|
|
clientSecret,
|
|
response,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
additionalFields,
|
|
user_id,
|
|
additionalData
|
|
}) {
|
|
const grabedHostNames = grabHostNames();
|
|
const { host, port, scheme } = grabedHostNames;
|
|
if (!code || code?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
user: null,
|
|
msg: "Please enter Github Access Token"
|
|
};
|
|
}
|
|
if (!database || database?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
user: null,
|
|
msg: "Please provide database slug name you want to access"
|
|
};
|
|
}
|
|
if (!clientId || clientId?.match(/ /)) {
|
|
return {
|
|
success: false,
|
|
user: null,
|
|
msg: "Please enter Github OAUTH client ID"
|
|
};
|
|
}
|
|
let httpResponse;
|
|
const {
|
|
DSQL_DB_HOST,
|
|
DSQL_DB_USERNAME,
|
|
DSQL_DB_PASSWORD,
|
|
DSQL_DB_NAME,
|
|
DSQL_KEY,
|
|
DSQL_REF_DB_NAME,
|
|
DSQL_FULL_SYNC
|
|
} = process.env;
|
|
if (DSQL_DB_HOST?.match(/./) && DSQL_DB_USERNAME?.match(/./) && DSQL_DB_PASSWORD?.match(/./) && DSQL_DB_NAME?.match(/./)) {
|
|
let dbSchema;
|
|
try {
|
|
const localDbSchemaPath = path15.resolve(process.cwd(), "dsql.schema.json");
|
|
dbSchema = JSON.parse(fs20.readFileSync(localDbSchemaPath, "utf8"));
|
|
} catch (error) {
|
|
}
|
|
httpResponse = await apiGithubLogin({
|
|
code,
|
|
email: email || undefined,
|
|
clientId,
|
|
clientSecret,
|
|
additionalFields,
|
|
database: DSQL_DB_NAME,
|
|
additionalData
|
|
});
|
|
} else {
|
|
httpResponse = await new Promise((resolve, reject) => {
|
|
const reqPayload = JSON.stringify({
|
|
code,
|
|
email,
|
|
clientId,
|
|
clientSecret,
|
|
database,
|
|
additionalFields,
|
|
additionalData
|
|
});
|
|
const httpsRequest2 = scheme.request({
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.from(reqPayload).length,
|
|
Authorization: key || process.env.DSQL_FULL_ACCESS_API_KEY || process.env.DSQL_API_KEY
|
|
},
|
|
port,
|
|
hostname: host,
|
|
path: `/api/user/${user_id || grabedHostNames.user_id}/github-login`
|
|
}, (response2) => {
|
|
var str = "";
|
|
response2.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response2.on("end", function() {
|
|
try {
|
|
resolve(JSON.parse(str));
|
|
} catch (error) {
|
|
console.log(error);
|
|
resolve({
|
|
success: false,
|
|
user: null,
|
|
msg: "Something went wrong"
|
|
});
|
|
}
|
|
});
|
|
response2.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
httpsRequest2.write(reqPayload);
|
|
httpsRequest2.end();
|
|
});
|
|
}
|
|
if (httpResponse?.success && httpResponse?.user) {
|
|
let encryptedPayload = encrypt({
|
|
data: JSON.stringify(httpResponse.user),
|
|
encryptionKey,
|
|
encryptionSalt
|
|
});
|
|
const { user, dsqlUserId } = httpResponse;
|
|
const authKeyName = `datasquirel_${dsqlUserId}_${database}_auth_key`;
|
|
const csrfName = `datasquirel_${dsqlUserId}_${database}_csrf`;
|
|
response.setHeader("Set-Cookie", [
|
|
`${authKeyName}=${encryptedPayload};samesite=strict;path=/;HttpOnly=true;Secure=true`,
|
|
`${csrfName}=${user.csrf_k};samesite=strict;path=/;HttpOnly=true`,
|
|
`dsqluid=${dsqlUserId};samesite=strict;path=/;HttpOnly=true`,
|
|
`datasquirel_social_id=${user.social_id};samesite=strict;path=/`
|
|
]);
|
|
}
|
|
return httpResponse;
|
|
}
|
|
|
|
// users/get-token.ts
|
|
init_decrypt();
|
|
function getToken({
|
|
request,
|
|
encryptionKey,
|
|
encryptionSalt,
|
|
database,
|
|
useLocal,
|
|
cookieString
|
|
}) {
|
|
try {
|
|
const cookies = parseCookies({ request, cookieString });
|
|
const keynames = getAuthCookieNames();
|
|
const authKeyName = keynames.keyCookieName;
|
|
const csrfName = keynames.csrfCookieName;
|
|
const key = cookies[authKeyName];
|
|
const csrf = cookies[csrfName];
|
|
let userPayload = decrypt({
|
|
encryptedString: key,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
});
|
|
if (!userPayload) {
|
|
return { key: undefined, csrf: undefined };
|
|
}
|
|
let userObject = JSON.parse(userPayload);
|
|
if (!userObject.csrf_k) {
|
|
return { key: undefined, csrf: undefined };
|
|
}
|
|
return { key, csrf };
|
|
} catch (error) {
|
|
return {
|
|
key: undefined,
|
|
csrf: undefined
|
|
};
|
|
}
|
|
}
|
|
|
|
// users/validate-token.ts
|
|
init_decrypt();
|
|
function validateToken({
|
|
token,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
}) {
|
|
try {
|
|
const key = token;
|
|
let userPayload = decrypt({
|
|
encryptedString: key,
|
|
encryptionKey,
|
|
encryptionSalt
|
|
});
|
|
if (!userPayload) {
|
|
return null;
|
|
}
|
|
let userObject = JSON.parse(userPayload);
|
|
if (!userObject.csrf_k) {
|
|
return null;
|
|
}
|
|
return userObject;
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// client/media/imageInputFileToBase64.ts
|
|
async function imageInputFileToBase64({
|
|
imageInputFile,
|
|
maxWidth,
|
|
imagePreviewNode
|
|
}) {
|
|
try {
|
|
let imageName = imageInputFile.name.replace(/\..*/, "");
|
|
let imageDataBase64;
|
|
let imageSize;
|
|
let canvas = document.createElement("canvas");
|
|
const MIME_TYPE = imageInputFile.type;
|
|
const QUALITY = 0.95;
|
|
const MAX_WIDTH = maxWidth ? maxWidth : null;
|
|
const file = imageInputFile;
|
|
const blobURL = URL.createObjectURL(file);
|
|
const img = new Image;
|
|
img.src = blobURL;
|
|
imageDataBase64 = await new Promise((res, rej) => {
|
|
img.onerror = function() {
|
|
URL.revokeObjectURL(this.src);
|
|
console.log("Cannot load image");
|
|
};
|
|
img.onload = function(e) {
|
|
const imgEl = e.target;
|
|
URL.revokeObjectURL(imgEl.src);
|
|
if (MAX_WIDTH) {
|
|
const scaleSize = MAX_WIDTH / img.naturalWidth;
|
|
canvas.width = img.naturalWidth < MAX_WIDTH ? img.naturalWidth : MAX_WIDTH;
|
|
canvas.height = img.naturalWidth < MAX_WIDTH ? img.naturalHeight : img.naturalHeight * scaleSize;
|
|
} else {
|
|
canvas.width = img.naturalWidth;
|
|
canvas.height = img.naturalHeight;
|
|
}
|
|
const ctx = canvas.getContext("2d");
|
|
ctx?.drawImage(img, 0, 0, canvas.width, canvas.height);
|
|
const srcEncoded = canvas.toDataURL(MIME_TYPE, QUALITY);
|
|
if (imagePreviewNode) {
|
|
imagePreviewNode.src = srcEncoded;
|
|
}
|
|
res(srcEncoded);
|
|
};
|
|
});
|
|
imageSize = await new Promise((res, rej) => {
|
|
canvas.toBlob((blob) => {
|
|
res(blob?.size);
|
|
}, MIME_TYPE, QUALITY);
|
|
});
|
|
return {
|
|
imageBase64: imageDataBase64?.replace(/.*?base64,/, ""),
|
|
imageBase64Full: imageDataBase64,
|
|
imageName,
|
|
imageSize
|
|
};
|
|
} catch (error) {
|
|
console.log("Image Processing Error! =>", error.message);
|
|
return {
|
|
imageBase64: undefined,
|
|
imageBase64Full: undefined,
|
|
imageName: undefined,
|
|
imageSize: undefined
|
|
};
|
|
}
|
|
}
|
|
|
|
// client/media/imageInputToBase64.ts
|
|
async function imageInputToBase64({
|
|
imageInput,
|
|
maxWidth,
|
|
mimeType
|
|
}) {
|
|
try {
|
|
let imagePreviewNode = document.querySelector(`[data-imagepreview='image']`);
|
|
let imageName = imageInput.files?.[0].name.replace(/\..*/, "");
|
|
let imageDataBase64;
|
|
const MIME_TYPE = mimeType ? mimeType : "image/jpeg";
|
|
const QUALITY = 0.95;
|
|
const MAX_WIDTH = maxWidth ? maxWidth : null;
|
|
const file = imageInput.files?.[0];
|
|
const blobURL = file ? URL.createObjectURL(file) : undefined;
|
|
const img = new Image;
|
|
if (blobURL) {
|
|
img.src = blobURL;
|
|
imageDataBase64 = await new Promise((res, rej) => {
|
|
img.onerror = function() {
|
|
URL.revokeObjectURL(this.src);
|
|
window.alert("Cannot load image!");
|
|
};
|
|
img.onload = function(e) {
|
|
const imgEl = e.target;
|
|
URL.revokeObjectURL(imgEl.src);
|
|
const canvas = document.createElement("canvas");
|
|
if (MAX_WIDTH) {
|
|
const scaleSize = MAX_WIDTH / img.naturalWidth;
|
|
canvas.width = img.naturalWidth < MAX_WIDTH ? img.naturalWidth : MAX_WIDTH;
|
|
canvas.height = img.naturalWidth < MAX_WIDTH ? img.naturalHeight : img.naturalHeight * scaleSize;
|
|
} else {
|
|
canvas.width = img.naturalWidth;
|
|
canvas.height = img.naturalHeight;
|
|
}
|
|
const ctx = canvas.getContext("2d");
|
|
ctx?.drawImage(img, 0, 0, canvas.width, canvas.height);
|
|
const srcEncoded = canvas.toDataURL(MIME_TYPE, QUALITY);
|
|
if (imagePreviewNode) {
|
|
document.querySelectorAll(`[data-imagepreview='image']`).forEach((_img) => {
|
|
const _imgEl = _img;
|
|
_imgEl.src = srcEncoded;
|
|
});
|
|
}
|
|
res(srcEncoded);
|
|
};
|
|
});
|
|
return {
|
|
imageBase64: imageDataBase64?.replace(/.*?base64,/, ""),
|
|
imageBase64Full: imageDataBase64,
|
|
imageName
|
|
};
|
|
} else {
|
|
return {};
|
|
}
|
|
} catch (error) {
|
|
console.log("Image Processing Error! =>", error.message);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// client/media/inputFileToBase64.ts
|
|
async function inputFileToBase64({
|
|
inputFile,
|
|
allowedRegex
|
|
}) {
|
|
const allowedTypesRegex = allowedRegex ? allowedRegex : /image\/*|\/pdf/;
|
|
if (!inputFile?.type?.match(allowedTypesRegex)) {
|
|
window.alert(`We currently don't support ${inputFile.type} file types. Support is coming soon. For now we support only images and PDFs.`);
|
|
return {
|
|
fileName: inputFile.name
|
|
};
|
|
}
|
|
try {
|
|
let fileName = inputFile.name.replace(/\..*/, "");
|
|
const fileData = await new Promise((resolve, reject) => {
|
|
var reader = new FileReader;
|
|
reader.readAsDataURL(inputFile);
|
|
reader.onload = function() {
|
|
resolve(reader.result?.toString());
|
|
};
|
|
reader.onerror = function(error) {
|
|
console.log("Error: ", error.message);
|
|
};
|
|
});
|
|
return {
|
|
fileBase64: fileData?.replace(/.*?base64,/, ""),
|
|
fileBase64Full: fileData,
|
|
fileName,
|
|
fileSize: inputFile.size,
|
|
fileType: inputFile.type
|
|
};
|
|
} catch (error) {
|
|
console.log("File Processing Error! =>", error.message);
|
|
return {
|
|
fileName: inputFile.name
|
|
};
|
|
}
|
|
}
|
|
|
|
// client/auth/google/getAccessToken.ts
|
|
var interval;
|
|
async function getAccessToken(params) {
|
|
params.setLoading?.(true);
|
|
const response = await new Promise((resolve, reject) => {
|
|
interval = setInterval(() => {
|
|
let google = window.google;
|
|
if (google) {
|
|
window.clearInterval(interval);
|
|
resolve(googleLogin({ ...params, google }));
|
|
}
|
|
}, 500);
|
|
});
|
|
params.setLoading?.(false);
|
|
return response;
|
|
}
|
|
function googleLogin({
|
|
google,
|
|
clientId,
|
|
setLoading,
|
|
triggerPrompt
|
|
}) {
|
|
setTimeout(() => {
|
|
setLoading?.(false);
|
|
}, 3000);
|
|
return new Promise((resolve, reject) => {
|
|
function handleCredentialResponse(response) {
|
|
resolve(response.access_token);
|
|
}
|
|
const googleAuth2 = google.accounts.oauth2.initTokenClient({
|
|
client_id: clientId,
|
|
scope: "email profile",
|
|
callback: handleCredentialResponse
|
|
});
|
|
googleAuth2.requestAccessToken();
|
|
if (triggerPrompt) {
|
|
google.accounts.id.prompt(triggerGooglePromptCallback);
|
|
}
|
|
function triggerGooglePromptCallback(notification) {
|
|
console.log(notification);
|
|
}
|
|
});
|
|
}
|
|
|
|
// client/auth/github/getAccessToken.ts
|
|
function getAccessToken2({
|
|
clientId,
|
|
redirectUrl,
|
|
setLoading,
|
|
scopes
|
|
}) {
|
|
if (setLoading)
|
|
setLoading(true);
|
|
const scopeString = scopes ? scopes.join("%20") : "read:user";
|
|
const fetchUrl = `https://github.com/login/oauth/authorize?client_id=${clientId}&scope=${scopeString}&redirect_uri=${redirectUrl}`;
|
|
window.location.assign(fetchUrl);
|
|
}
|
|
|
|
// client/utils/parseClientCookies.ts
|
|
function parseClientCookies_default() {
|
|
const cookieString = document.cookie;
|
|
if (!cookieString || typeof cookieString !== "string") {
|
|
return null;
|
|
}
|
|
const cookieSplitArray = cookieString.split(";");
|
|
let cookieObject = {};
|
|
cookieSplitArray.forEach((keyValueString) => {
|
|
const [key, value] = keyValueString.split("=");
|
|
if (key && typeof key == "string") {
|
|
cookieObject[key.replace(/^ +| +$/, "")] = value && typeof value == "string" ? value.replace(/^ +| +$/, "") : null;
|
|
}
|
|
});
|
|
return cookieObject;
|
|
}
|
|
|
|
// client/auth/logout.ts
|
|
async function logout(params) {
|
|
try {
|
|
const localUser = localStorage.getItem("user");
|
|
let targetUser;
|
|
try {
|
|
targetUser = JSON.parse(localUser || "");
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
if (!targetUser) {
|
|
return false;
|
|
}
|
|
const cookies = parseClientCookies_default();
|
|
const socialId = cookies?.datasquirel_social_id && typeof cookies.datasquirel_social_id == "string" && !cookies.datasquirel_social_id.match(/^null$/i) ? cookies.datasquirel_social_id : null;
|
|
localStorage.setItem("user", "{}");
|
|
localStorage.removeItem("csrf");
|
|
document.cookie = `datasquirel_social_id=null;samesite=strict;path=/`;
|
|
const response = await new Promise((resolve, reject) => {
|
|
if (socialId && !socialId?.match(/^null$/i)) {
|
|
const googleClientId = params?.googleClientId;
|
|
if (googleClientId) {
|
|
const googleScript = document.createElement("script");
|
|
googleScript.src = "https://accounts.google.com/gsi/client";
|
|
googleScript.className = "social-script-tag";
|
|
document.body.appendChild(googleScript);
|
|
googleScript.onload = function(e) {
|
|
const google = window.google;
|
|
if (google) {
|
|
google.accounts.id.initialize({
|
|
client_id: googleClientId
|
|
});
|
|
google.accounts.id.revoke(socialId, (done) => {
|
|
console.log(done.error);
|
|
resolve(true);
|
|
});
|
|
}
|
|
};
|
|
} else {
|
|
resolve(true);
|
|
}
|
|
} else {
|
|
resolve(true);
|
|
}
|
|
});
|
|
return response;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// client/fetch/index.ts
|
|
var import_lodash3 = __toESM(require_lodash(), 1);
|
|
async function fetchApi(url, options, csrf, localStorageCSRFKey) {
|
|
let data;
|
|
const csrfValue = localStorage.getItem(localStorageCSRFKey || "csrf");
|
|
let finalHeaders = {
|
|
"Content-Type": "application/json"
|
|
};
|
|
if (csrf && csrfValue) {
|
|
finalHeaders[`'${csrfValue.replace(/\"/g, "")}'`] = "true";
|
|
}
|
|
if (typeof options === "string") {
|
|
try {
|
|
let fetchData;
|
|
switch (options) {
|
|
case "post":
|
|
fetchData = await fetch(url, {
|
|
method: options,
|
|
headers: finalHeaders
|
|
});
|
|
data = fetchData.json();
|
|
break;
|
|
default:
|
|
fetchData = await fetch(url);
|
|
data = fetchData.json();
|
|
break;
|
|
}
|
|
} catch (error) {
|
|
console.log("FetchAPI error #1:", error.message);
|
|
data = null;
|
|
}
|
|
} else if (typeof options === "object") {
|
|
try {
|
|
let fetchData;
|
|
if (options.body && typeof options.body === "object") {
|
|
let oldOptionsBody = import_lodash3.default.cloneDeep(options.body);
|
|
options.body = JSON.stringify(oldOptionsBody);
|
|
}
|
|
if (options.headers) {
|
|
options.headers = import_lodash3.default.merge(options.headers, finalHeaders);
|
|
const finalOptions = { ...options };
|
|
fetchData = await fetch(url, finalOptions);
|
|
} else {
|
|
const finalOptions = {
|
|
...options,
|
|
headers: finalHeaders
|
|
};
|
|
fetchData = await fetch(url, finalOptions);
|
|
}
|
|
data = fetchData.json();
|
|
} catch (error) {
|
|
console.log("FetchAPI error #2:", error.message);
|
|
data = null;
|
|
}
|
|
} else {
|
|
try {
|
|
let fetchData = await fetch(url);
|
|
data = await fetchData.json();
|
|
} catch (error) {
|
|
console.log("FetchAPI error #3:", error.message);
|
|
data = null;
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
// client/index.ts
|
|
init_ejson();
|
|
|
|
// package-shared/utils/numberfy.ts
|
|
function numberfy(num, decimals) {
|
|
try {
|
|
const numberfiedNum = Number(num);
|
|
if (typeof numberfiedNum !== "number")
|
|
return 0;
|
|
if (isNaN(numberfiedNum))
|
|
return 0;
|
|
if (decimals)
|
|
return Number(numberfiedNum.toFixed(decimals));
|
|
return Math.round(numberfiedNum);
|
|
} catch (error) {
|
|
console.log(`Numberfy ERROR: ${error.message}`);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// package-shared/utils/slugify.ts
|
|
function slugify(str) {
|
|
try {
|
|
return String(str).trim().toLowerCase().replace(/ {2,}/g, " ").replace(/ /g, "-").replace(/[^a-z0-9]/g, "-").replace(/-{2,}/g, "-").replace(/^-/, "").replace(/-$/, "");
|
|
} catch (error) {
|
|
console.log(`Slugify ERROR: ${error.message}`);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// client/index.ts
|
|
var media = {
|
|
imageInputToBase64,
|
|
imageInputFileToBase64,
|
|
inputFileToBase64
|
|
};
|
|
var auth = {
|
|
google: {
|
|
getAccessToken
|
|
},
|
|
github: {
|
|
getAccessToken: getAccessToken2
|
|
},
|
|
logout
|
|
};
|
|
var utils = {
|
|
serializeQuery,
|
|
serializeCookies,
|
|
EJSON: ejson_default,
|
|
numberfy,
|
|
slugify
|
|
};
|
|
var fetch2 = {
|
|
fetchApi,
|
|
clientFetch: fetchApi
|
|
};
|
|
var datasquirelClient = { media, auth, fetch: fetch2, utils };
|
|
var client_default = datasquirelClient;
|
|
|
|
// package-shared/functions/dsql/sql/sql-generator.ts
|
|
function sqlGenerator({ tableName, genObject }) {
|
|
if (!genObject)
|
|
return;
|
|
const finalQuery = genObject.query ? genObject.query : undefined;
|
|
const queryKeys = finalQuery ? Object.keys(finalQuery) : undefined;
|
|
const sqlSearhValues = [];
|
|
function genSqlSrchStr({
|
|
queryObj,
|
|
join,
|
|
field
|
|
}) {
|
|
const finalFieldName = (() => {
|
|
if (queryObj?.tableName) {
|
|
return `${queryObj.tableName}.${field}`;
|
|
}
|
|
if (join) {
|
|
return `${tableName}.${field}`;
|
|
}
|
|
return field;
|
|
})();
|
|
let str = `${finalFieldName}=?`;
|
|
if (typeof queryObj.value == "string" || typeof queryObj.value == "number") {
|
|
const valueParsed = String(queryObj.value);
|
|
if (queryObj.equality == "LIKE") {
|
|
str = `LOWER(${finalFieldName}) LIKE LOWER('%${valueParsed}%')`;
|
|
} else if (queryObj.equality == "NOT EQUAL") {
|
|
str = `${finalFieldName} != ?`;
|
|
sqlSearhValues.push(valueParsed);
|
|
} else {
|
|
sqlSearhValues.push(valueParsed);
|
|
}
|
|
} else if (Array.isArray(queryObj.value)) {
|
|
const strArray = [];
|
|
queryObj.value.forEach((val) => {
|
|
const valueParsed = val;
|
|
if (queryObj.equality == "LIKE") {
|
|
strArray.push(`LOWER(${finalFieldName}) LIKE LOWER('%${valueParsed}%')`);
|
|
} else if (queryObj.equality == "NOT EQUAL") {
|
|
strArray.push(`${finalFieldName} != ?`);
|
|
sqlSearhValues.push(valueParsed);
|
|
} else {
|
|
strArray.push(`${finalFieldName} = ?`);
|
|
sqlSearhValues.push(valueParsed);
|
|
}
|
|
});
|
|
str = "(" + strArray.join(` ${queryObj.operator || "AND"} `) + ")";
|
|
}
|
|
return str;
|
|
}
|
|
const sqlSearhString = queryKeys?.map((field) => {
|
|
const queryObj = finalQuery?.[field];
|
|
if (!queryObj)
|
|
return;
|
|
if (queryObj.__query) {
|
|
const subQueryGroup = queryObj.__query;
|
|
const subSearchKeys = Object.keys(subQueryGroup);
|
|
const subSearchString = subSearchKeys.map((_field) => {
|
|
const newSubQueryObj = subQueryGroup?.[_field];
|
|
return genSqlSrchStr({
|
|
queryObj: newSubQueryObj,
|
|
field: _field,
|
|
join: genObject.join
|
|
});
|
|
});
|
|
console.log("queryObj.operator", queryObj.operator);
|
|
return "(" + subSearchString.join(` ${queryObj.operator || "AND"} `) + ")";
|
|
}
|
|
return genSqlSrchStr({ queryObj, field, join: genObject.join });
|
|
});
|
|
function generateJoinStr(mtch, join) {
|
|
return `${typeof mtch.source == "object" ? mtch.source.tableName : tableName}.${typeof mtch.source == "object" ? mtch.source.fieldName : mtch.source}=${(() => {
|
|
if (mtch.targetLiteral) {
|
|
return `'${mtch.targetLiteral}'`;
|
|
}
|
|
if (join.alias) {
|
|
return `${typeof mtch.target == "object" ? mtch.target.tableName : join.alias}.${typeof mtch.target == "object" ? mtch.target.fieldName : mtch.target}`;
|
|
}
|
|
return `${typeof mtch.target == "object" ? mtch.target.tableName : join.tableName}.${typeof mtch.target == "object" ? mtch.target.fieldName : mtch.target}`;
|
|
})()}`;
|
|
}
|
|
let queryString = (() => {
|
|
let str = "SELECT";
|
|
if (genObject.selectFields?.[0]) {
|
|
if (genObject.join) {
|
|
str += ` ${genObject.selectFields?.map((fld) => `${tableName}.${fld}`).join(",")}`;
|
|
} else {
|
|
str += ` ${genObject.selectFields?.join(",")}`;
|
|
}
|
|
} else {
|
|
if (genObject.join) {
|
|
str += ` ${tableName}.*`;
|
|
} else {
|
|
str += " *";
|
|
}
|
|
}
|
|
if (genObject.join) {
|
|
const existingJoinTableNames = [tableName];
|
|
str += "," + genObject.join.map((joinObj) => {
|
|
const joinTableName = joinObj.alias ? joinObj.alias : joinObj.tableName;
|
|
if (existingJoinTableNames.includes(joinTableName))
|
|
return null;
|
|
existingJoinTableNames.push(joinTableName);
|
|
if (joinObj.selectFields) {
|
|
return joinObj.selectFields.map((selectField) => {
|
|
if (typeof selectField == "string") {
|
|
return `${joinTableName}.${selectField}`;
|
|
} else if (typeof selectField == "object") {
|
|
let aliasSelectField = selectField.count ? `COUNT(${joinTableName}.${selectField.field})` : `${joinTableName}.${selectField.field}`;
|
|
if (selectField.alias)
|
|
aliasSelectField += ` AS ${selectField.alias}`;
|
|
return aliasSelectField;
|
|
}
|
|
}).join(",");
|
|
} else {
|
|
return `${joinTableName}.*`;
|
|
}
|
|
}).filter((_4) => Boolean(_4)).join(",");
|
|
}
|
|
str += ` FROM ${tableName}`;
|
|
if (genObject.join) {
|
|
str += " " + genObject.join.map((join) => {
|
|
return join.joinType + " " + (join.alias ? join.tableName + " " + join.alias : join.tableName) + " ON " + (() => {
|
|
if (Array.isArray(join.match)) {
|
|
return "(" + join.match.map((mtch) => generateJoinStr(mtch, join)).join(join.operator ? ` ${join.operator} ` : " AND ") + ")";
|
|
} else if (typeof join.match == "object") {
|
|
return generateJoinStr(join.match, join);
|
|
}
|
|
})();
|
|
}).join(" ");
|
|
}
|
|
return str;
|
|
})();
|
|
if (sqlSearhString?.[0] && sqlSearhString.find((str) => str)) {
|
|
const stringOperator = genObject?.searchOperator || "AND";
|
|
queryString += ` WHERE ${sqlSearhString.join(` ${stringOperator} `)} `;
|
|
}
|
|
if (genObject.order)
|
|
queryString += ` ORDER BY ${genObject.join ? `${tableName}.${genObject.order.field}` : genObject.order.field} ${genObject.order.strategy}`;
|
|
if (genObject.limit)
|
|
queryString += ` LIMIT ${genObject.limit}`;
|
|
if (genObject.offset)
|
|
queryString += ` OFFSET ${genObject.offset}`;
|
|
return {
|
|
string: queryString,
|
|
values: sqlSearhValues
|
|
};
|
|
}
|
|
|
|
// package-shared/functions/dsql/sql/sql-insert-generator.ts
|
|
function sqlInsertGenerator({
|
|
tableName,
|
|
data
|
|
}) {
|
|
try {
|
|
if (Array.isArray(data) && data?.[0]) {
|
|
let insertKeys = [];
|
|
data.forEach((dt) => {
|
|
const kys = Object.keys(dt);
|
|
kys.forEach((ky) => {
|
|
if (!insertKeys.includes(ky)) {
|
|
insertKeys.push(ky);
|
|
}
|
|
});
|
|
});
|
|
let queryBatches = [];
|
|
let queryValues = [];
|
|
data.forEach((item) => {
|
|
queryBatches.push(`(${insertKeys.map((ky) => {
|
|
queryValues.push(item[ky]?.toString()?.match(/./) ? item[ky] : null);
|
|
return "?";
|
|
}).join(",")})`);
|
|
});
|
|
let query = `INSERT INTO ${tableName} (${insertKeys.join(",")}) VALUES ${queryBatches.join(",")}`;
|
|
return {
|
|
query,
|
|
values: queryValues
|
|
};
|
|
} else {
|
|
return;
|
|
}
|
|
} catch (error) {
|
|
console.log(`SQL insert gen ERROR: ${error.message}`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// package-shared/functions/dsql/sql/sql-delete-generator.ts
|
|
function sqlDeleteGenerator({
|
|
tableName,
|
|
data
|
|
}) {
|
|
try {
|
|
let queryStr = `DELETE FROM ${tableName}`;
|
|
let deleteBatch = [];
|
|
let queryArr = [];
|
|
Object.keys(data).forEach((ky) => {
|
|
deleteBatch.push(`${ky}=?`);
|
|
queryArr.push(data[ky]);
|
|
});
|
|
queryStr += ` WHERE ${deleteBatch.join(" AND ")}`;
|
|
return {
|
|
query: queryStr,
|
|
values: queryArr
|
|
};
|
|
} catch (error) {
|
|
console.log(`SQL delete gen ERROR: ${error.message}`);
|
|
return;
|
|
}
|
|
}
|
|
// package-shared/functions/backend/httpRequest.ts
|
|
import http3 from "node:http";
|
|
import https4 from "node:https";
|
|
import querystring from "querystring";
|
|
function httpRequest(params) {
|
|
return new Promise((resolve, reject) => {
|
|
const isUrlEncodedFormBody = params.urlEncodedFormBody;
|
|
const reqPayloadString = params.body ? isUrlEncodedFormBody ? querystring.stringify(params.body) : JSON.stringify(params.body).replace(/\n|\r|\n\r/gm, "") : undefined;
|
|
const reqQueryString = params.query ? serializeQuery(params.query) : undefined;
|
|
const paramScheme = params.scheme;
|
|
const finalScheme = paramScheme == "http" ? http3 : https4;
|
|
const finalPath = params.path ? params.path + (reqQueryString ? reqQueryString : "") : undefined;
|
|
delete params.body;
|
|
delete params.scheme;
|
|
delete params.query;
|
|
delete params.urlEncodedFormBody;
|
|
const requestOptions = {
|
|
...params,
|
|
headers: {
|
|
"Content-Type": isUrlEncodedFormBody ? "application/x-www-form-urlencoded" : "application/json",
|
|
"Content-Length": reqPayloadString ? Buffer.from(reqPayloadString).length : undefined,
|
|
...params.headers
|
|
},
|
|
port: paramScheme == "https" ? 443 : params.port,
|
|
path: finalPath
|
|
};
|
|
const httpsRequest2 = finalScheme.request(requestOptions, (response) => {
|
|
var str = "";
|
|
response.on("data", function(chunk) {
|
|
str += chunk;
|
|
});
|
|
response.on("end", function() {
|
|
const data = (() => {
|
|
try {
|
|
const jsonObj = JSON.parse(str);
|
|
return jsonObj;
|
|
} catch (error) {
|
|
return;
|
|
}
|
|
})();
|
|
resolve({
|
|
status: response.statusCode || 404,
|
|
data,
|
|
str,
|
|
requestedPath: finalPath
|
|
});
|
|
});
|
|
response.on("error", (err) => {
|
|
resolve({
|
|
status: response.statusCode || 404,
|
|
str,
|
|
error: err.message,
|
|
requestedPath: finalPath
|
|
});
|
|
});
|
|
});
|
|
if (reqPayloadString) {
|
|
httpsRequest2.write(reqPayloadString);
|
|
}
|
|
httpsRequest2.on("error", (error) => {
|
|
console.log("HTTPS request ERROR =>", error);
|
|
});
|
|
httpsRequest2.end();
|
|
});
|
|
}
|
|
|
|
// index.ts
|
|
var user = {
|
|
createUser: addUser,
|
|
deleteUser: (init_delete_user(), __toCommonJS(exports_delete_user)),
|
|
loginUser,
|
|
sendEmailCode,
|
|
logoutUser,
|
|
userAuth,
|
|
reAuthUser: reauthUser,
|
|
updateUser,
|
|
getUser,
|
|
getToken,
|
|
validateToken,
|
|
validateTempEmailCode: (init_validate_temp_email_code(), __toCommonJS(exports_validate_temp_email_code)),
|
|
social: {
|
|
loginWithGoogle: googleAuth,
|
|
loginWithGithub: githubAuth
|
|
}
|
|
};
|
|
var media2 = {
|
|
uploadImage,
|
|
uploadFile: uploadImage2,
|
|
deleteFile
|
|
};
|
|
var sql = {
|
|
sqlGenerator,
|
|
sqlInsertGenerator,
|
|
sqlDeleteGenerator,
|
|
trim: trimSql
|
|
};
|
|
var datasquirel = {
|
|
get,
|
|
post,
|
|
media: media2,
|
|
user,
|
|
getSchema,
|
|
client: client_default,
|
|
sql,
|
|
utils: {
|
|
crypto: {
|
|
encrypt: (init_encrypt(), __toCommonJS(exports_encrypt)),
|
|
decrypt: (init_decrypt(), __toCommonJS(exports_decrypt)),
|
|
hash: (init_hashPassword(), __toCommonJS(exports_hashPassword))
|
|
},
|
|
parseCookies,
|
|
httpRequest
|
|
}
|
|
};
|
|
var datasquirel_default = datasquirel;
|
|
export {
|
|
datasquirel_default as default
|
|
};
|