diff --git a/build/editor.bundle.js b/build/editor.bundle.js
index 7cb938b1..41ddc0ab 100644
--- a/build/editor.bundle.js
+++ b/build/editor.bundle.js
@@ -1,5 +1,4 @@
 /******/ (() => { // webpackBootstrap
-var __webpack_exports__ = {};
 (function () {
 // Create an element
   const test = document.createElement('p');
diff --git a/build/format.bundle.js b/build/format.bundle.js
index 3a87ad7c..61c8cf65 100644
--- a/build/format.bundle.js
+++ b/build/format.bundle.js
@@ -1,7 +1,7 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 7083:
+/***/ 4155:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -52,13 +52,13 @@
  */
 
 
-var fs = __webpack_require__(7790);
-var path = __webpack_require__(5272);
-var utils = __webpack_require__(1176);
+var fs = __webpack_require__(7280);
+var path = __webpack_require__(7024);
+var utils = __webpack_require__(3182);
 
 var scopeOptionWarned = false;
 /** @type {string} */
-var _VERSION_STRING = (__webpack_require__(3558)/* .version */ .i8);
+var _VERSION_STRING = (__webpack_require__(3840)/* .version */ .rE);
 var _DEFAULT_OPEN_DELIMITER = '<';
 var _DEFAULT_CLOSE_DELIMITER = '>';
 var _DEFAULT_DELIMITER = '%';
@@ -513,8 +513,8 @@ exports.clearCache = function () {
   exports.cache.reset();
 };
 
-function Template(text, opts) {
-  opts = opts || utils.createNullProtoObjWherePossible();
+function Template(text, optsParam) {
+  var opts = utils.hasOwnOnlyObject(optsParam);
   var options = utils.createNullProtoObjWherePossible();
   this.templateText = text;
   /** @type {string | null} */
@@ -958,9 +958,10 @@ if (typeof window != 'undefined') {
 }
 
 
+
 /***/ }),
 
-/***/ 1176:
+/***/ 3182:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -1204,114 +1205,1146 @@ exports.createNullProtoObjWherePossible = (function () {
   };
 })();
 
+exports.hasOwnOnlyObject = function (obj) {
+  var o = exports.createNullProtoObjWherePossible();
+  for (var p in obj) {
+    if (hasOwn(obj, p)) {
+      o[p] = obj[p];
+    }
+  }
+  return o;
+};
 
 
 
 /***/ }),
 
-/***/ 7187:
-/***/ ((module) => {
+/***/ 9878:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-
-var R = typeof Reflect === 'object' ? Reflect : null
-var ReflectApply = R && typeof R.apply === 'function'
-  ? R.apply
-  : function ReflectApply(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  }
 
-var ReflectOwnKeys
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
-} else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
-      .concat(Object.getOwnPropertySymbols(target));
-  };
-} else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target);
-  };
+var __createBinding = (this && this.__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 = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__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 = (this && this.__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 = void 0;
+var decode_data_html_js_1 = __importDefault(__webpack_require__(3603));
+exports.htmlDecodeTree = decode_data_html_js_1.default;
+var decode_data_xml_js_1 = __importDefault(__webpack_require__(2517));
+exports.xmlDecodeTree = decode_data_xml_js_1.default;
+var decode_codepoint_js_1 = __importStar(__webpack_require__(5096));
+exports.decodeCodePoint = decode_codepoint_js_1.default;
+var decode_codepoint_js_2 = __webpack_require__(5096);
+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 (CharCodes) {
+    CharCodes[CharCodes["NUM"] = 35] = "NUM";
+    CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+    CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
+    CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
+    CharCodes[CharCodes["NINE"] = 57] = "NINE";
+    CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
+    CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
+    CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
+    CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+    CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+    CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+    CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes || (CharCodes = {}));
+/** Bit that needs to be set to convert an upper case ASCII character to lower case */
+var TO_LOWER_BIT = 32;
+var BinTrieFlags;
+(function (BinTrieFlags) {
+    BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+    BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
+    BinTrieFlags[BinTrieFlags["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));
+}
+/**
+ * Checks if the given character is a valid end character for an entity in an attribute.
+ *
+ * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+ * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+ */
+function isEntityInAttributeInvalidEnd(code) {
+    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
+}
+var EntityDecoderState;
+(function (EntityDecoderState) {
+    EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+    EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+    EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+    EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+    EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function (DecodingMode) {
+    /** Entities in text nodes that can end with any character. */
+    DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+    /** Only allow entities terminated with a semicolon. */
+    DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+    /** Entities in attributes have limitations on ending characters. */
+    DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode = exports.DecodingMode || (exports.DecodingMode = {}));
+/**
+ * Token decoder with support of writing partial entities.
+ */
+var EntityDecoder = /** @class */ (function () {
+    function EntityDecoder(
+    /** The tree used to decode entities. */
+    decodeTree, 
+    /**
+     * The function that is called when a codepoint is decoded.
+     *
+     * For multi-byte named entities, this will be called multiple times,
+     * with the second codepoint, and the same `consumed` value.
+     *
+     * @param codepoint The decoded codepoint.
+     * @param consumed The number of bytes consumed by the decoder.
+     */
+    emitCodePoint, 
+    /** An object that is used to produce errors. */
+    errors) {
+        this.decodeTree = decodeTree;
+        this.emitCodePoint = emitCodePoint;
+        this.errors = errors;
+        /** The current state of the decoder. */
+        this.state = EntityDecoderState.EntityStart;
+        /** Characters that were consumed while parsing an entity. */
+        this.consumed = 1;
+        /**
+         * The result of the entity.
+         *
+         * Either the result index of a numeric entity, or the codepoint of a
+         * numeric entity.
+         */
+        this.result = 0;
+        /** The current index in the decode tree. */
+        this.treeIndex = 0;
+        /** The number of characters that were consumed in excess. */
+        this.excess = 1;
+        /** The mode in which the decoder is operating. */
+        this.decodeMode = DecodingMode.Strict;
+    }
+    /** Resets the instance to make it reusable. */
+    EntityDecoder.prototype.startEntity = function (decodeMode) {
+        this.decodeMode = decodeMode;
+        this.state = EntityDecoderState.EntityStart;
+        this.result = 0;
+        this.treeIndex = 0;
+        this.excess = 1;
+        this.consumed = 1;
+    };
+    /**
+     * Write an entity to the decoder. This can be called multiple times with partial entities.
+     * If the entity is incomplete, the decoder will return -1.
+     *
+     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+     * entity is incomplete, and resume when the next string is written.
+     *
+     * @param string The string containing the entity (or a continuation of the entity).
+     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    EntityDecoder.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);
+            }
+        }
+    };
+    /**
+     * Switches between the numeric decimal and hexadecimal states.
+     *
+     * Equivalent to the `Numeric character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    EntityDecoder.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);
+    };
+    EntityDecoder.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;
+        }
+    };
+    /**
+     * Parses a hexadecimal numeric entity.
+     *
+     * Equivalent to the `Hexademical character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    EntityDecoder.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;
+    };
+    /**
+     * Parses a decimal numeric entity.
+     *
+     * Equivalent to the `Decimal character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    EntityDecoder.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;
+    };
+    /**
+     * Validate and emit a numeric entity.
+     *
+     * Implements the logic from the `Hexademical character reference start
+     * state` and `Numeric character reference end state` in the HTML spec.
+     *
+     * @param lastCp The last code point of the entity. Used to see if the
+     *               entity was terminated with a semicolon.
+     * @param expectedLength The minimum number of characters that should be
+     *                       consumed. Used to validate that at least one digit
+     *                       was consumed.
+     * @returns The number of characters that were consumed.
+     */
+    EntityDecoder.prototype.emitNumericEntity = function (lastCp, expectedLength) {
+        var _a;
+        // Ensure we consumed at least one digit.
+        if (this.consumed <= expectedLength) {
+            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+            return 0;
+        }
+        // Figure out if this is a legit end of the entity
+        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;
+    };
+    /**
+     * Parses a named entity.
+     *
+     * Equivalent to the `Named character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    EntityDecoder.prototype.stateNamedEntity = function (str, offset) {
+        var decodeTree = this.decodeTree;
+        var current = decodeTree[this.treeIndex];
+        // The mask is the number of bytes of the value, including the current byte.
+        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 ||
+                    // If we are parsing an attribute
+                    (this.decodeMode === DecodingMode.Attribute &&
+                        // We shouldn't have consumed any characters after the entity,
+                        (valueLength === 0 ||
+                            // And there should be no invalid characters.
+                            isEntityInAttributeInvalidEnd(char)))
+                    ? 0
+                    : this.emitNotTerminatedNamedEntity();
+            }
+            current = decodeTree[this.treeIndex];
+            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+            // If the branch is a value, store it and continue
+            if (valueLength !== 0) {
+                // If the entity is terminated by a semicolon, we are done.
+                if (char === CharCodes.SEMI) {
+                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+                }
+                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.
+                if (this.decodeMode !== DecodingMode.Strict) {
+                    this.result = this.treeIndex;
+                    this.consumed += this.excess;
+                    this.excess = 0;
+                }
+            }
+        }
+        return -1;
+    };
+    /**
+     * Emit a named entity that was not terminated with a semicolon.
+     *
+     * @returns The number of characters consumed.
+     */
+    EntityDecoder.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 === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();
+        return this.consumed;
+    };
+    /**
+     * Emit a named entity.
+     *
+     * @param result The index of the entity in the decode tree.
+     * @param valueLength The number of bytes in the entity.
+     * @param consumed The number of characters consumed.
+     *
+     * @returns The number of characters consumed.
+     */
+    EntityDecoder.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) {
+            // For multi-byte values, we need to emit the second byte.
+            this.emitCodePoint(decodeTree[result + 2], consumed);
+        }
+        return consumed;
+    };
+    /**
+     * Signal to the parser that the end of the input was reached.
+     *
+     * Remaining data will be emitted and relevant errors will be produced.
+     *
+     * @returns The number of characters consumed.
+     */
+    EntityDecoder.prototype.end = function () {
+        var _a;
+        switch (this.state) {
+            case EntityDecoderState.NamedEntity: {
+                // Emit a named entity if we have one.
+                return this.result !== 0 &&
+                    (this.decodeMode !== DecodingMode.Attribute ||
+                        this.result === this.treeIndex)
+                    ? this.emitNotTerminatedNamedEntity()
+                    : 0;
+            }
+            // Otherwise, emit a numeric entity if we have one.
+            case EntityDecoderState.NumericDecimal: {
+                return this.emitNumericEntity(0, 2);
+            }
+            case EntityDecoderState.NumericHex: {
+                return this.emitNumericEntity(0, 3);
+            }
+            case EntityDecoderState.NumericStart: {
+                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+                return 0;
+            }
+            case EntityDecoderState.EntityStart: {
+                // Return 0 if we have no entity.
+                return 0;
+            }
+        }
+    };
+    return EntityDecoder;
+}());
+exports.EntityDecoder = EntityDecoder;
+/**
+ * Creates a function that decodes entities in a string.
+ *
+ * @param decodeTree The decode tree.
+ * @returns A function that decodes entities in a string.
+ */
+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, 
+            // Skip the "&"
+            offset + 1);
+            if (len < 0) {
+                lastIndex = offset + decoder.end();
+                break;
+            }
+            lastIndex = offset + len;
+            // If `len` is 0, skip the current `&` and continue.
+            offset = len === 0 ? lastIndex + 1 : lastIndex;
+        }
+        var result = ret + str.slice(lastIndex);
+        // Make sure we don't keep a reference to the final string.
+        ret = "";
+        return result;
+    };
 }
-
-function ProcessEmitWarning(warning) {
-  if (console && console.warn) console.warn(warning);
+/**
+ * Determines the branch of the current node that is taken given the current
+ * character. This function is used to traverse the trie.
+ *
+ * @param decodeTree The trie.
+ * @param current The current node.
+ * @param nodeIdx The index right after the current node and its value.
+ * @param char The current character.
+ * @returns The index of the next node, or -1 if no branch is taken.
+ */
+function determineBranch(decodeTree, current, nodeIdx, char) {
+    var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+    var jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+    // Case 1: Single branch encoded in jump offset
+    if (branchCount === 0) {
+        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
+    }
+    // Case 2: Multiple branches encoded in jump table
+    if (jumpOffset) {
+        var value = char - jumpOffset;
+        return value < 0 || value >= branchCount
+            ? -1
+            : decodeTree[nodeIdx + value] - 1;
+    }
+    // Case 3: Multiple branches encoded in dictionary
+    // Binary search for the character.
+    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;
 }
-
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-  return value !== value;
+exports.determineBranch = determineBranch;
+var htmlDecoder = getDecoder(decode_data_html_js_1.default);
+var xmlDecoder = getDecoder(decode_data_xml_js_1.default);
+/**
+ * Decodes an HTML string.
+ *
+ * @param str The string to decode.
+ * @param mode The decoding mode.
+ * @returns The decoded string.
+ */
+function decodeHTML(str, mode) {
+    if (mode === void 0) { mode = DecodingMode.Legacy; }
+    return htmlDecoder(str, mode);
 }
-
-function EventEmitter() {
-  EventEmitter.init.call(this);
+exports.decodeHTML = decodeHTML;
+/**
+ * Decodes an HTML string in an attribute.
+ *
+ * @param str The string to decode.
+ * @returns The decoded string.
+ */
+function decodeHTMLAttribute(str) {
+    return htmlDecoder(str, DecodingMode.Attribute);
 }
-module.exports = EventEmitter;
-module.exports.once = once;
+exports.decodeHTMLAttribute = decodeHTMLAttribute;
+/**
+ * Decodes an HTML string, requiring all entities to be terminated by a semicolon.
+ *
+ * @param str The string to decode.
+ * @returns The decoded string.
+ */
+function decodeHTMLStrict(str) {
+    return htmlDecoder(str, DecodingMode.Strict);
+}
+exports.decodeHTMLStrict = decodeHTMLStrict;
+/**
+ * Decodes an XML string, requiring all entities to be terminated by a semicolon.
+ *
+ * @param str The string to decode.
+ * @returns The decoded string.
+ */
+function decodeXML(str) {
+    return xmlDecoder(str, DecodingMode.Strict);
+}
+exports.decodeXML = decodeXML;
+//# sourceMappingURL=decode.js.map
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+/***/ }),
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+/***/ 5096:
+/***/ ((__unused_webpack_module, exports) => {
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+"use strict";
 
-function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-  }
+// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
+var _a;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.replaceCodePoint = exports.fromCodePoint = void 0;
+var decodeMap = new Map([
+    [0, 65533],
+    // C1 Unicode control character reference replacements
+    [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],
+]);
+/**
+ * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+ */
+exports.fromCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
+(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {
+    var output = "";
+    if (codePoint > 0xffff) {
+        codePoint -= 0x10000;
+        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
+        codePoint = 0xdc00 | (codePoint & 0x3ff);
+    }
+    output += String.fromCharCode(codePoint);
+    return output;
+};
+/**
+ * Replace the given code point with a replacement character if it is a
+ * surrogate or is outside the valid range. Otherwise return the code
+ * point unchanged.
+ */
+function replaceCodePoint(codePoint) {
+    var _a;
+    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+        return 0xfffd;
+    }
+    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
+}
+exports.replaceCodePoint = replaceCodePoint;
+/**
+ * Replace the code point if relevant, then convert it to a string.
+ *
+ * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.
+ * @param codePoint The code point to decode.
+ * @returns The decoded code point.
+ */
+function decodeCodePoint(codePoint) {
+    return (0, exports.fromCodePoint)(replaceCodePoint(codePoint));
 }
+exports["default"] = decodeCodePoint;
+//# sourceMappingURL=decode_codepoint.js.map
 
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-  enumerable: true,
-  get: function() {
-    return defaultMaxListeners;
-  },
-  set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
-    }
-    defaultMaxListeners = arg;
-  }
-});
+/***/ }),
 
-EventEmitter.init = function() {
+/***/ 1818:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
-    this._events = Object.create(null);
-    this._eventsCount = 0;
-  }
+"use strict";
 
-  this._maxListeners = this._maxListeners || undefined;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.encodeNonAsciiHTML = exports.encodeHTML = void 0;
+var encode_html_js_1 = __importDefault(__webpack_require__(5504));
+var escape_js_1 = __webpack_require__(5987);
+var htmlReplacer = /[\t\n!-,./:-@[-`\f{-}$\x80-\uFFFF]/g;
+/**
+ * Encodes all characters in the input using HTML entities. This includes
+ * characters that are valid ASCII characters in HTML documents, such as `#`.
+ *
+ * To get a more compact output, consider using the `encodeNonAsciiHTML`
+ * function, which will only encode characters that are not valid in HTML
+ * documents, as well as non-ASCII characters.
+ *
+ * If a character has no equivalent entity, a numeric hexadecimal reference
+ * (eg. `&#xfc;`) will be used.
+ */
+function encodeHTML(data) {
+    return encodeHTMLTrieRe(htmlReplacer, data);
+}
+exports.encodeHTML = encodeHTML;
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in HTML
+ * documents using HTML entities. This function will not encode characters that
+ * are valid in HTML documents, such as `#`.
+ *
+ * If a character has no equivalent entity, a numeric hexadecimal reference
+ * (eg. `&#xfc;`) will be used.
+ */
+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") {
+            // We are in a branch. Try to match the next char.
+            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;
+        }
+        // We might have a tree node without a value; skip and use a numeric entity.
+        if (next !== undefined) {
+            ret += next;
+            lastIdx = i + 1;
+        }
+        else {
+            var cp = (0, escape_js_1.getCodePoint)(str, i);
+            ret += "&#x".concat(cp.toString(16), ";");
+            // Increase by 1 if we have a surrogate pair
+            lastIdx = regExp.lastIndex += Number(cp !== char);
+        }
+    }
+    return ret + str.substr(lastIdx);
+}
+//# sourceMappingURL=encode.js.map
+
+/***/ }),
+
+/***/ 5987:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.escapeText = exports.escapeAttribute = exports.escapeUTF8 = exports.escape = exports.encodeXML = exports.getCodePoint = exports.xmlReplacer = void 0;
+exports.xmlReplacer = /["&'<>$\x80-\uFFFF]/g;
+var xmlCodeMap = new Map([
+    [34, "&quot;"],
+    [38, "&amp;"],
+    [39, "&apos;"],
+    [60, "&lt;"],
+    [62, "&gt;"],
+]);
+// For compatibility with node < 4, we wrap `codePointAt`
+exports.getCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+String.prototype.codePointAt != null
+    ? function (str, index) { return str.codePointAt(index); }
+    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+        function (c, index) {
+            return (c.charCodeAt(index) & 0xfc00) === 0xd800
+                ? (c.charCodeAt(index) - 0xd800) * 0x400 +
+                    c.charCodeAt(index + 1) -
+                    0xdc00 +
+                    0x10000
+                : c.charCodeAt(index);
+        };
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using XML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `&#xfc;`) will be used.
+ */
+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), ";");
+            // Increase by 1 if we have a surrogate pair
+            lastIdx = exports.xmlReplacer.lastIndex += Number((char & 0xfc00) === 0xd800);
+        }
+    }
+    return ret + str.substr(lastIdx);
+}
+exports.encodeXML = encodeXML;
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using numeric hexadecimal reference (eg. `&#xfc;`).
+ *
+ * Have a look at `escapeUTF8` if you want a more concise output at the expense
+ * of reduced transportability.
+ *
+ * @param data String to escape.
+ */
+exports.escape = encodeXML;
+/**
+ * Creates a function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ *
+ * @param regex Regular expression to match characters to escape.
+ * @param map Map of characters to escape to their entities.
+ *
+ * @returns Function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ */
+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);
+            }
+            // We know that this character will be in the map.
+            result += map.get(match[0].charCodeAt(0));
+            // Every match will be of length 1
+            lastIdx = match.index + 1;
+        }
+        return result + data.substring(lastIdx);
+    };
+}
+/**
+ * Encodes all characters not valid in XML documents using XML entities.
+ *
+ * Note that the output will be character-set dependent.
+ *
+ * @param data String to escape.
+ */
+exports.escapeUTF8 = getEscaper(/[&<>'"]/g, xmlCodeMap);
+/**
+ * Encodes all characters that have to be escaped in HTML attributes,
+ * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+ *
+ * @param data String to escape.
+ */
+exports.escapeAttribute = getEscaper(/["&\u00A0]/g, new Map([
+    [34, "&quot;"],
+    [38, "&amp;"],
+    [160, "&nbsp;"],
+]));
+/**
+ * Encodes all characters that have to be escaped in HTML text,
+ * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+ *
+ * @param data String to escape.
+ */
+exports.escapeText = getEscaper(/[&<>\u00A0]/g, new Map([
+    [38, "&amp;"],
+    [60, "&lt;"],
+    [62, "&gt;"],
+    [160, "&nbsp;"],
+]));
+//# sourceMappingURL=escape.js.map
+
+/***/ }),
+
+/***/ 3603:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+// Generated using scripts/write-decode-map.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = new Uint16Array(
+// prettier-ignore
+"\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); }));
+//# sourceMappingURL=decode-data-html.js.map
+
+/***/ }),
+
+/***/ 2517:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+// Generated using scripts/write-decode-map.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = new Uint16Array(
+// prettier-ignore
+"\u0200aglq\t\x15\x18\x1b\u026d\x0f\0\0\x12p;\u4026os;\u4027t;\u403et;\u403cuot;\u4022"
+    .split("")
+    .map(function (c) { return c.charCodeAt(0); }));
+//# sourceMappingURL=decode-data-xml.js.map
+
+/***/ }),
+
+/***/ 5504:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+// Generated using scripts/write-encode-map.ts
+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;
+}
+// prettier-ignore
+exports["default"] = new Map(/* #__PURE__ */ restoreDiff([[9, "&Tab;"], [0, "&NewLine;"], [22, "&excl;"], [0, "&quot;"], [0, "&num;"], [0, "&dollar;"], [0, "&percnt;"], [0, "&amp;"], [0, "&apos;"], [0, "&lpar;"], [0, "&rpar;"], [0, "&ast;"], [0, "&plus;"], [0, "&comma;"], [1, "&period;"], [0, "&sol;"], [10, "&colon;"], [0, "&semi;"], [0, { v: "&lt;", n: 8402, o: "&nvlt;" }], [0, { v: "&equals;", n: 8421, o: "&bne;" }], [0, { v: "&gt;", n: 8402, o: "&nvgt;" }], [0, "&quest;"], [0, "&commat;"], [26, "&lbrack;"], [0, "&bsol;"], [0, "&rbrack;"], [0, "&Hat;"], [0, "&lowbar;"], [0, "&DiacriticalGrave;"], [5, { n: 106, o: "&fjlig;" }], [20, "&lbrace;"], [0, "&verbar;"], [0, "&rbrace;"], [34, "&nbsp;"], [0, "&iexcl;"], [0, "&cent;"], [0, "&pound;"], [0, "&curren;"], [0, "&yen;"], [0, "&brvbar;"], [0, "&sect;"], [0, "&die;"], [0, "&copy;"], [0, "&ordf;"], [0, "&laquo;"], [0, "&not;"], [0, "&shy;"], [0, "&circledR;"], [0, "&macr;"], [0, "&deg;"], [0, "&PlusMinus;"], [0, "&sup2;"], [0, "&sup3;"], [0, "&acute;"], [0, "&micro;"], [0, "&para;"], [0, "&centerdot;"], [0, "&cedil;"], [0, "&sup1;"], [0, "&ordm;"], [0, "&raquo;"], [0, "&frac14;"], [0, "&frac12;"], [0, "&frac34;"], [0, "&iquest;"], [0, "&Agrave;"], [0, "&Aacute;"], [0, "&Acirc;"], [0, "&Atilde;"], [0, "&Auml;"], [0, "&angst;"], [0, "&AElig;"], [0, "&Ccedil;"], [0, "&Egrave;"], [0, "&Eacute;"], [0, "&Ecirc;"], [0, "&Euml;"], [0, "&Igrave;"], [0, "&Iacute;"], [0, "&Icirc;"], [0, "&Iuml;"], [0, "&ETH;"], [0, "&Ntilde;"], [0, "&Ograve;"], [0, "&Oacute;"], [0, "&Ocirc;"], [0, "&Otilde;"], [0, "&Ouml;"], [0, "&times;"], [0, "&Oslash;"], [0, "&Ugrave;"], [0, "&Uacute;"], [0, "&Ucirc;"], [0, "&Uuml;"], [0, "&Yacute;"], [0, "&THORN;"], [0, "&szlig;"], [0, "&agrave;"], [0, "&aacute;"], [0, "&acirc;"], [0, "&atilde;"], [0, "&auml;"], [0, "&aring;"], [0, "&aelig;"], [0, "&ccedil;"], [0, "&egrave;"], [0, "&eacute;"], [0, "&ecirc;"], [0, "&euml;"], [0, "&igrave;"], [0, "&iacute;"], [0, "&icirc;"], [0, "&iuml;"], [0, "&eth;"], [0, "&ntilde;"], [0, "&ograve;"], [0, "&oacute;"], [0, "&ocirc;"], [0, "&otilde;"], [0, "&ouml;"], [0, "&div;"], [0, "&oslash;"], [0, "&ugrave;"], [0, "&uacute;"], [0, "&ucirc;"], [0, "&uuml;"], [0, "&yacute;"], [0, "&thorn;"], [0, "&yuml;"], [0, "&Amacr;"], [0, "&amacr;"], [0, "&Abreve;"], [0, "&abreve;"], [0, "&Aogon;"], [0, "&aogon;"], [0, "&Cacute;"], [0, "&cacute;"], [0, "&Ccirc;"], [0, "&ccirc;"], [0, "&Cdot;"], [0, "&cdot;"], [0, "&Ccaron;"], [0, "&ccaron;"], [0, "&Dcaron;"], [0, "&dcaron;"], [0, "&Dstrok;"], [0, "&dstrok;"], [0, "&Emacr;"], [0, "&emacr;"], [2, "&Edot;"], [0, "&edot;"], [0, "&Eogon;"], [0, "&eogon;"], [0, "&Ecaron;"], [0, "&ecaron;"], [0, "&Gcirc;"], [0, "&gcirc;"], [0, "&Gbreve;"], [0, "&gbreve;"], [0, "&Gdot;"], [0, "&gdot;"], [0, "&Gcedil;"], [1, "&Hcirc;"], [0, "&hcirc;"], [0, "&Hstrok;"], [0, "&hstrok;"], [0, "&Itilde;"], [0, "&itilde;"], [0, "&Imacr;"], [0, "&imacr;"], [2, "&Iogon;"], [0, "&iogon;"], [0, "&Idot;"], [0, "&imath;"], [0, "&IJlig;"], [0, "&ijlig;"], [0, "&Jcirc;"], [0, "&jcirc;"], [0, "&Kcedil;"], [0, "&kcedil;"], [0, "&kgreen;"], [0, "&Lacute;"], [0, "&lacute;"], [0, "&Lcedil;"], [0, "&lcedil;"], [0, "&Lcaron;"], [0, "&lcaron;"], [0, "&Lmidot;"], [0, "&lmidot;"], [0, "&Lstrok;"], [0, "&lstrok;"], [0, "&Nacute;"], [0, "&nacute;"], [0, "&Ncedil;"], [0, "&ncedil;"], [0, "&Ncaron;"], [0, "&ncaron;"], [0, "&napos;"], [0, "&ENG;"], [0, "&eng;"], [0, "&Omacr;"], [0, "&omacr;"], [2, "&Odblac;"], [0, "&odblac;"], [0, "&OElig;"], [0, "&oelig;"], [0, "&Racute;"], [0, "&racute;"], [0, "&Rcedil;"], [0, "&rcedil;"], [0, "&Rcaron;"], [0, "&rcaron;"], [0, "&Sacute;"], [0, "&sacute;"], [0, "&Scirc;"], [0, "&scirc;"], [0, "&Scedil;"], [0, "&scedil;"], [0, "&Scaron;"], [0, "&scaron;"], [0, "&Tcedil;"], [0, "&tcedil;"], [0, "&Tcaron;"], [0, "&tcaron;"], [0, "&Tstrok;"], [0, "&tstrok;"], [0, "&Utilde;"], [0, "&utilde;"], [0, "&Umacr;"], [0, "&umacr;"], [0, "&Ubreve;"], [0, "&ubreve;"], [0, "&Uring;"], [0, "&uring;"], [0, "&Udblac;"], [0, "&udblac;"], [0, "&Uogon;"], [0, "&uogon;"], [0, "&Wcirc;"], [0, "&wcirc;"], [0, "&Ycirc;"], [0, "&ycirc;"], [0, "&Yuml;"], [0, "&Zacute;"], [0, "&zacute;"], [0, "&Zdot;"], [0, "&zdot;"], [0, "&Zcaron;"], [0, "&zcaron;"], [19, "&fnof;"], [34, "&imped;"], [63, "&gacute;"], [65, "&jmath;"], [142, "&circ;"], [0, "&caron;"], [16, "&breve;"], [0, "&DiacriticalDot;"], [0, "&ring;"], [0, "&ogon;"], [0, "&DiacriticalTilde;"], [0, "&dblac;"], [51, "&DownBreve;"], [127, "&Alpha;"], [0, "&Beta;"], [0, "&Gamma;"], [0, "&Delta;"], [0, "&Epsilon;"], [0, "&Zeta;"], [0, "&Eta;"], [0, "&Theta;"], [0, "&Iota;"], [0, "&Kappa;"], [0, "&Lambda;"], [0, "&Mu;"], [0, "&Nu;"], [0, "&Xi;"], [0, "&Omicron;"], [0, "&Pi;"], [0, "&Rho;"], [1, "&Sigma;"], [0, "&Tau;"], [0, "&Upsilon;"], [0, "&Phi;"], [0, "&Chi;"], [0, "&Psi;"], [0, "&ohm;"], [7, "&alpha;"], [0, "&beta;"], [0, "&gamma;"], [0, "&delta;"], [0, "&epsi;"], [0, "&zeta;"], [0, "&eta;"], [0, "&theta;"], [0, "&iota;"], [0, "&kappa;"], [0, "&lambda;"], [0, "&mu;"], [0, "&nu;"], [0, "&xi;"], [0, "&omicron;"], [0, "&pi;"], [0, "&rho;"], [0, "&sigmaf;"], [0, "&sigma;"], [0, "&tau;"], [0, "&upsi;"], [0, "&phi;"], [0, "&chi;"], [0, "&psi;"], [0, "&omega;"], [7, "&thetasym;"], [0, "&Upsi;"], [2, "&phiv;"], [0, "&piv;"], [5, "&Gammad;"], [0, "&digamma;"], [18, "&kappav;"], [0, "&rhov;"], [3, "&epsiv;"], [0, "&backepsilon;"], [10, "&IOcy;"], [0, "&DJcy;"], [0, "&GJcy;"], [0, "&Jukcy;"], [0, "&DScy;"], [0, "&Iukcy;"], [0, "&YIcy;"], [0, "&Jsercy;"], [0, "&LJcy;"], [0, "&NJcy;"], [0, "&TSHcy;"], [0, "&KJcy;"], [1, "&Ubrcy;"], [0, "&DZcy;"], [0, "&Acy;"], [0, "&Bcy;"], [0, "&Vcy;"], [0, "&Gcy;"], [0, "&Dcy;"], [0, "&IEcy;"], [0, "&ZHcy;"], [0, "&Zcy;"], [0, "&Icy;"], [0, "&Jcy;"], [0, "&Kcy;"], [0, "&Lcy;"], [0, "&Mcy;"], [0, "&Ncy;"], [0, "&Ocy;"], [0, "&Pcy;"], [0, "&Rcy;"], [0, "&Scy;"], [0, "&Tcy;"], [0, "&Ucy;"], [0, "&Fcy;"], [0, "&KHcy;"], [0, "&TScy;"], [0, "&CHcy;"], [0, "&SHcy;"], [0, "&SHCHcy;"], [0, "&HARDcy;"], [0, "&Ycy;"], [0, "&SOFTcy;"], [0, "&Ecy;"], [0, "&YUcy;"], [0, "&YAcy;"], [0, "&acy;"], [0, "&bcy;"], [0, "&vcy;"], [0, "&gcy;"], [0, "&dcy;"], [0, "&iecy;"], [0, "&zhcy;"], [0, "&zcy;"], [0, "&icy;"], [0, "&jcy;"], [0, "&kcy;"], [0, "&lcy;"], [0, "&mcy;"], [0, "&ncy;"], [0, "&ocy;"], [0, "&pcy;"], [0, "&rcy;"], [0, "&scy;"], [0, "&tcy;"], [0, "&ucy;"], [0, "&fcy;"], [0, "&khcy;"], [0, "&tscy;"], [0, "&chcy;"], [0, "&shcy;"], [0, "&shchcy;"], [0, "&hardcy;"], [0, "&ycy;"], [0, "&softcy;"], [0, "&ecy;"], [0, "&yucy;"], [0, "&yacy;"], [1, "&iocy;"], [0, "&djcy;"], [0, "&gjcy;"], [0, "&jukcy;"], [0, "&dscy;"], [0, "&iukcy;"], [0, "&yicy;"], [0, "&jsercy;"], [0, "&ljcy;"], [0, "&njcy;"], [0, "&tshcy;"], [0, "&kjcy;"], [1, "&ubrcy;"], [0, "&dzcy;"], [7074, "&ensp;"], [0, "&emsp;"], [0, "&emsp13;"], [0, "&emsp14;"], [1, "&numsp;"], [0, "&puncsp;"], [0, "&ThinSpace;"], [0, "&hairsp;"], [0, "&NegativeMediumSpace;"], [0, "&zwnj;"], [0, "&zwj;"], [0, "&lrm;"], [0, "&rlm;"], [0, "&dash;"], [2, "&ndash;"], [0, "&mdash;"], [0, "&horbar;"], [0, "&Verbar;"], [1, "&lsquo;"], [0, "&CloseCurlyQuote;"], [0, "&lsquor;"], [1, "&ldquo;"], [0, "&CloseCurlyDoubleQuote;"], [0, "&bdquo;"], [1, "&dagger;"], [0, "&Dagger;"], [0, "&bull;"], [2, "&nldr;"], [0, "&hellip;"], [9, "&permil;"], [0, "&pertenk;"], [0, "&prime;"], [0, "&Prime;"], [0, "&tprime;"], [0, "&backprime;"], [3, "&lsaquo;"], [0, "&rsaquo;"], [3, "&oline;"], [2, "&caret;"], [1, "&hybull;"], [0, "&frasl;"], [10, "&bsemi;"], [7, "&qprime;"], [7, { v: "&MediumSpace;", n: 8202, o: "&ThickSpace;" }], [0, "&NoBreak;"], [0, "&af;"], [0, "&InvisibleTimes;"], [0, "&ic;"], [72, "&euro;"], [46, "&tdot;"], [0, "&DotDot;"], [37, "&complexes;"], [2, "&incare;"], [4, "&gscr;"], [0, "&hamilt;"], [0, "&Hfr;"], [0, "&Hopf;"], [0, "&planckh;"], [0, "&hbar;"], [0, "&imagline;"], [0, "&Ifr;"], [0, "&lagran;"], [0, "&ell;"], [1, "&naturals;"], [0, "&numero;"], [0, "&copysr;"], [0, "&weierp;"], [0, "&Popf;"], [0, "&Qopf;"], [0, "&realine;"], [0, "&real;"], [0, "&reals;"], [0, "&rx;"], [3, "&trade;"], [1, "&integers;"], [2, "&mho;"], [0, "&zeetrf;"], [0, "&iiota;"], [2, "&bernou;"], [0, "&Cayleys;"], [1, "&escr;"], [0, "&Escr;"], [0, "&Fouriertrf;"], [1, "&Mellintrf;"], [0, "&order;"], [0, "&alefsym;"], [0, "&beth;"], [0, "&gimel;"], [0, "&daleth;"], [12, "&CapitalDifferentialD;"], [0, "&dd;"], [0, "&ee;"], [0, "&ii;"], [10, "&frac13;"], [0, "&frac23;"], [0, "&frac15;"], [0, "&frac25;"], [0, "&frac35;"], [0, "&frac45;"], [0, "&frac16;"], [0, "&frac56;"], [0, "&frac18;"], [0, "&frac38;"], [0, "&frac58;"], [0, "&frac78;"], [49, "&larr;"], [0, "&ShortUpArrow;"], [0, "&rarr;"], [0, "&darr;"], [0, "&harr;"], [0, "&updownarrow;"], [0, "&nwarr;"], [0, "&nearr;"], [0, "&LowerRightArrow;"], [0, "&LowerLeftArrow;"], [0, "&nlarr;"], [0, "&nrarr;"], [1, { v: "&rarrw;", n: 824, o: "&nrarrw;" }], [0, "&Larr;"], [0, "&Uarr;"], [0, "&Rarr;"], [0, "&Darr;"], [0, "&larrtl;"], [0, "&rarrtl;"], [0, "&LeftTeeArrow;"], [0, "&mapstoup;"], [0, "&map;"], [0, "&DownTeeArrow;"], [1, "&hookleftarrow;"], [0, "&hookrightarrow;"], [0, "&larrlp;"], [0, "&looparrowright;"], [0, "&harrw;"], [0, "&nharr;"], [1, "&lsh;"], [0, "&rsh;"], [0, "&ldsh;"], [0, "&rdsh;"], [1, "&crarr;"], [0, "&cularr;"], [0, "&curarr;"], [2, "&circlearrowleft;"], [0, "&circlearrowright;"], [0, "&leftharpoonup;"], [0, "&DownLeftVector;"], [0, "&RightUpVector;"], [0, "&LeftUpVector;"], [0, "&rharu;"], [0, "&DownRightVector;"], [0, "&dharr;"], [0, "&dharl;"], [0, "&RightArrowLeftArrow;"], [0, "&udarr;"], [0, "&LeftArrowRightArrow;"], [0, "&leftleftarrows;"], [0, "&upuparrows;"], [0, "&rightrightarrows;"], [0, "&ddarr;"], [0, "&leftrightharpoons;"], [0, "&Equilibrium;"], [0, "&nlArr;"], [0, "&nhArr;"], [0, "&nrArr;"], [0, "&DoubleLeftArrow;"], [0, "&DoubleUpArrow;"], [0, "&DoubleRightArrow;"], [0, "&dArr;"], [0, "&DoubleLeftRightArrow;"], [0, "&DoubleUpDownArrow;"], [0, "&nwArr;"], [0, "&neArr;"], [0, "&seArr;"], [0, "&swArr;"], [0, "&lAarr;"], [0, "&rAarr;"], [1, "&zigrarr;"], [6, "&larrb;"], [0, "&rarrb;"], [15, "&DownArrowUpArrow;"], [7, "&loarr;"], [0, "&roarr;"], [0, "&hoarr;"], [0, "&forall;"], [0, "&comp;"], [0, { v: "&part;", n: 824, o: "&npart;" }], [0, "&exist;"], [0, "&nexist;"], [0, "&empty;"], [1, "&Del;"], [0, "&Element;"], [0, "&NotElement;"], [1, "&ni;"], [0, "&notni;"], [2, "&prod;"], [0, "&coprod;"], [0, "&sum;"], [0, "&minus;"], [0, "&MinusPlus;"], [0, "&dotplus;"], [1, "&Backslash;"], [0, "&lowast;"], [0, "&compfn;"], [1, "&radic;"], [2, "&prop;"], [0, "&infin;"], [0, "&angrt;"], [0, { v: "&ang;", n: 8402, o: "&nang;" }], [0, "&angmsd;"], [0, "&angsph;"], [0, "&mid;"], [0, "&nmid;"], [0, "&DoubleVerticalBar;"], [0, "&NotDoubleVerticalBar;"], [0, "&and;"], [0, "&or;"], [0, { v: "&cap;", n: 65024, o: "&caps;" }], [0, { v: "&cup;", n: 65024, o: "&cups;" }], [0, "&int;"], [0, "&Int;"], [0, "&iiint;"], [0, "&conint;"], [0, "&Conint;"], [0, "&Cconint;"], [0, "&cwint;"], [0, "&ClockwiseContourIntegral;"], [0, "&awconint;"], [0, "&there4;"], [0, "&becaus;"], [0, "&ratio;"], [0, "&Colon;"], [0, "&dotminus;"], [1, "&mDDot;"], [0, "&homtht;"], [0, { v: "&sim;", n: 8402, o: "&nvsim;" }], [0, { v: "&backsim;", n: 817, o: "&race;" }], [0, { v: "&ac;", n: 819, o: "&acE;" }], [0, "&acd;"], [0, "&VerticalTilde;"], [0, "&NotTilde;"], [0, { v: "&eqsim;", n: 824, o: "&nesim;" }], [0, "&sime;"], [0, "&NotTildeEqual;"], [0, "&cong;"], [0, "&simne;"], [0, "&ncong;"], [0, "&ap;"], [0, "&nap;"], [0, "&ape;"], [0, { v: "&apid;", n: 824, o: "&napid;" }], [0, "&backcong;"], [0, { v: "&asympeq;", n: 8402, o: "&nvap;" }], [0, { v: "&bump;", n: 824, o: "&nbump;" }], [0, { v: "&bumpe;", n: 824, o: "&nbumpe;" }], [0, { v: "&doteq;", n: 824, o: "&nedot;" }], [0, "&doteqdot;"], [0, "&efDot;"], [0, "&erDot;"], [0, "&Assign;"], [0, "&ecolon;"], [0, "&ecir;"], [0, "&circeq;"], [1, "&wedgeq;"], [0, "&veeeq;"], [1, "&triangleq;"], [2, "&equest;"], [0, "&ne;"], [0, { v: "&Congruent;", n: 8421, o: "&bnequiv;" }], [0, "&nequiv;"], [1, { v: "&le;", n: 8402, o: "&nvle;" }], [0, { v: "&ge;", n: 8402, o: "&nvge;" }], [0, { v: "&lE;", n: 824, o: "&nlE;" }], [0, { v: "&gE;", n: 824, o: "&ngE;" }], [0, { v: "&lnE;", n: 65024, o: "&lvertneqq;" }], [0, { v: "&gnE;", n: 65024, o: "&gvertneqq;" }], [0, { v: "&ll;", n: new Map(/* #__PURE__ */ restoreDiff([[824, "&nLtv;"], [7577, "&nLt;"]])) }], [0, { v: "&gg;", n: new Map(/* #__PURE__ */ restoreDiff([[824, "&nGtv;"], [7577, "&nGt;"]])) }], [0, "&between;"], [0, "&NotCupCap;"], [0, "&nless;"], [0, "&ngt;"], [0, "&nle;"], [0, "&nge;"], [0, "&lesssim;"], [0, "&GreaterTilde;"], [0, "&nlsim;"], [0, "&ngsim;"], [0, "&LessGreater;"], [0, "&gl;"], [0, "&NotLessGreater;"], [0, "&NotGreaterLess;"], [0, "&pr;"], [0, "&sc;"], [0, "&prcue;"], [0, "&sccue;"], [0, "&PrecedesTilde;"], [0, { v: "&scsim;", n: 824, o: "&NotSucceedsTilde;" }], [0, "&NotPrecedes;"], [0, "&NotSucceeds;"], [0, { v: "&sub;", n: 8402, o: "&NotSubset;" }], [0, { v: "&sup;", n: 8402, o: "&NotSuperset;" }], [0, "&nsub;"], [0, "&nsup;"], [0, "&sube;"], [0, "&supe;"], [0, "&NotSubsetEqual;"], [0, "&NotSupersetEqual;"], [0, { v: "&subne;", n: 65024, o: "&varsubsetneq;" }], [0, { v: "&supne;", n: 65024, o: "&varsupsetneq;" }], [1, "&cupdot;"], [0, "&UnionPlus;"], [0, { v: "&sqsub;", n: 824, o: "&NotSquareSubset;" }], [0, { v: "&sqsup;", n: 824, o: "&NotSquareSuperset;" }], [0, "&sqsube;"], [0, "&sqsupe;"], [0, { v: "&sqcap;", n: 65024, o: "&sqcaps;" }], [0, { v: "&sqcup;", n: 65024, o: "&sqcups;" }], [0, "&CirclePlus;"], [0, "&CircleMinus;"], [0, "&CircleTimes;"], [0, "&osol;"], [0, "&CircleDot;"], [0, "&circledcirc;"], [0, "&circledast;"], [1, "&circleddash;"], [0, "&boxplus;"], [0, "&boxminus;"], [0, "&boxtimes;"], [0, "&dotsquare;"], [0, "&RightTee;"], [0, "&dashv;"], [0, "&DownTee;"], [0, "&bot;"], [1, "&models;"], [0, "&DoubleRightTee;"], [0, "&Vdash;"], [0, "&Vvdash;"], [0, "&VDash;"], [0, "&nvdash;"], [0, "&nvDash;"], [0, "&nVdash;"], [0, "&nVDash;"], [0, "&prurel;"], [1, "&LeftTriangle;"], [0, "&RightTriangle;"], [0, { v: "&LeftTriangleEqual;", n: 8402, o: "&nvltrie;" }], [0, { v: "&RightTriangleEqual;", n: 8402, o: "&nvrtrie;" }], [0, "&origof;"], [0, "&imof;"], [0, "&multimap;"], [0, "&hercon;"], [0, "&intcal;"], [0, "&veebar;"], [1, "&barvee;"], [0, "&angrtvb;"], [0, "&lrtri;"], [0, "&bigwedge;"], [0, "&bigvee;"], [0, "&bigcap;"], [0, "&bigcup;"], [0, "&diam;"], [0, "&sdot;"], [0, "&sstarf;"], [0, "&divideontimes;"], [0, "&bowtie;"], [0, "&ltimes;"], [0, "&rtimes;"], [0, "&leftthreetimes;"], [0, "&rightthreetimes;"], [0, "&backsimeq;"], [0, "&curlyvee;"], [0, "&curlywedge;"], [0, "&Sub;"], [0, "&Sup;"], [0, "&Cap;"], [0, "&Cup;"], [0, "&fork;"], [0, "&epar;"], [0, "&lessdot;"], [0, "&gtdot;"], [0, { v: "&Ll;", n: 824, o: "&nLl;" }], [0, { v: "&Gg;", n: 824, o: "&nGg;" }], [0, { v: "&leg;", n: 65024, o: "&lesg;" }], [0, { v: "&gel;", n: 65024, o: "&gesl;" }], [2, "&cuepr;"], [0, "&cuesc;"], [0, "&NotPrecedesSlantEqual;"], [0, "&NotSucceedsSlantEqual;"], [0, "&NotSquareSubsetEqual;"], [0, "&NotSquareSupersetEqual;"], [2, "&lnsim;"], [0, "&gnsim;"], [0, "&precnsim;"], [0, "&scnsim;"], [0, "&nltri;"], [0, "&NotRightTriangle;"], [0, "&nltrie;"], [0, "&NotRightTriangleEqual;"], [0, "&vellip;"], [0, "&ctdot;"], [0, "&utdot;"], [0, "&dtdot;"], [0, "&disin;"], [0, "&isinsv;"], [0, "&isins;"], [0, { v: "&isindot;", n: 824, o: "&notindot;" }], [0, "&notinvc;"], [0, "&notinvb;"], [1, { v: "&isinE;", n: 824, o: "&notinE;" }], [0, "&nisd;"], [0, "&xnis;"], [0, "&nis;"], [0, "&notnivc;"], [0, "&notnivb;"], [6, "&barwed;"], [0, "&Barwed;"], [1, "&lceil;"], [0, "&rceil;"], [0, "&LeftFloor;"], [0, "&rfloor;"], [0, "&drcrop;"], [0, "&dlcrop;"], [0, "&urcrop;"], [0, "&ulcrop;"], [0, "&bnot;"], [1, "&profline;"], [0, "&profsurf;"], [1, "&telrec;"], [0, "&target;"], [5, "&ulcorn;"], [0, "&urcorn;"], [0, "&dlcorn;"], [0, "&drcorn;"], [2, "&frown;"], [0, "&smile;"], [9, "&cylcty;"], [0, "&profalar;"], [7, "&topbot;"], [6, "&ovbar;"], [1, "&solbar;"], [60, "&angzarr;"], [51, "&lmoustache;"], [0, "&rmoustache;"], [2, "&OverBracket;"], [0, "&bbrk;"], [0, "&bbrktbrk;"], [37, "&OverParenthesis;"], [0, "&UnderParenthesis;"], [0, "&OverBrace;"], [0, "&UnderBrace;"], [2, "&trpezium;"], [4, "&elinters;"], [59, "&blank;"], [164, "&circledS;"], [55, "&boxh;"], [1, "&boxv;"], [9, "&boxdr;"], [3, "&boxdl;"], [3, "&boxur;"], [3, "&boxul;"], [3, "&boxvr;"], [7, "&boxvl;"], [7, "&boxhd;"], [7, "&boxhu;"], [7, "&boxvh;"], [19, "&boxH;"], [0, "&boxV;"], [0, "&boxdR;"], [0, "&boxDr;"], [0, "&boxDR;"], [0, "&boxdL;"], [0, "&boxDl;"], [0, "&boxDL;"], [0, "&boxuR;"], [0, "&boxUr;"], [0, "&boxUR;"], [0, "&boxuL;"], [0, "&boxUl;"], [0, "&boxUL;"], [0, "&boxvR;"], [0, "&boxVr;"], [0, "&boxVR;"], [0, "&boxvL;"], [0, "&boxVl;"], [0, "&boxVL;"], [0, "&boxHd;"], [0, "&boxhD;"], [0, "&boxHD;"], [0, "&boxHu;"], [0, "&boxhU;"], [0, "&boxHU;"], [0, "&boxvH;"], [0, "&boxVh;"], [0, "&boxVH;"], [19, "&uhblk;"], [3, "&lhblk;"], [3, "&block;"], [8, "&blk14;"], [0, "&blk12;"], [0, "&blk34;"], [13, "&square;"], [8, "&blacksquare;"], [0, "&EmptyVerySmallSquare;"], [1, "&rect;"], [0, "&marker;"], [2, "&fltns;"], [1, "&bigtriangleup;"], [0, "&blacktriangle;"], [0, "&triangle;"], [2, "&blacktriangleright;"], [0, "&rtri;"], [3, "&bigtriangledown;"], [0, "&blacktriangledown;"], [0, "&dtri;"], [2, "&blacktriangleleft;"], [0, "&ltri;"], [6, "&loz;"], [0, "&cir;"], [32, "&tridot;"], [2, "&bigcirc;"], [8, "&ultri;"], [0, "&urtri;"], [0, "&lltri;"], [0, "&EmptySmallSquare;"], [0, "&FilledSmallSquare;"], [8, "&bigstar;"], [0, "&star;"], [7, "&phone;"], [49, "&female;"], [1, "&male;"], [29, "&spades;"], [2, "&clubs;"], [1, "&hearts;"], [0, "&diamondsuit;"], [3, "&sung;"], [2, "&flat;"], [0, "&natural;"], [0, "&sharp;"], [163, "&check;"], [3, "&cross;"], [8, "&malt;"], [21, "&sext;"], [33, "&VerticalSeparator;"], [25, "&lbbrk;"], [0, "&rbbrk;"], [84, "&bsolhsub;"], [0, "&suphsol;"], [28, "&LeftDoubleBracket;"], [0, "&RightDoubleBracket;"], [0, "&lang;"], [0, "&rang;"], [0, "&Lang;"], [0, "&Rang;"], [0, "&loang;"], [0, "&roang;"], [7, "&longleftarrow;"], [0, "&longrightarrow;"], [0, "&longleftrightarrow;"], [0, "&DoubleLongLeftArrow;"], [0, "&DoubleLongRightArrow;"], [0, "&DoubleLongLeftRightArrow;"], [1, "&longmapsto;"], [2, "&dzigrarr;"], [258, "&nvlArr;"], [0, "&nvrArr;"], [0, "&nvHarr;"], [0, "&Map;"], [6, "&lbarr;"], [0, "&bkarow;"], [0, "&lBarr;"], [0, "&dbkarow;"], [0, "&drbkarow;"], [0, "&DDotrahd;"], [0, "&UpArrowBar;"], [0, "&DownArrowBar;"], [2, "&Rarrtl;"], [2, "&latail;"], [0, "&ratail;"], [0, "&lAtail;"], [0, "&rAtail;"], [0, "&larrfs;"], [0, "&rarrfs;"], [0, "&larrbfs;"], [0, "&rarrbfs;"], [2, "&nwarhk;"], [0, "&nearhk;"], [0, "&hksearow;"], [0, "&hkswarow;"], [0, "&nwnear;"], [0, "&nesear;"], [0, "&seswar;"], [0, "&swnwar;"], [8, { v: "&rarrc;", n: 824, o: "&nrarrc;" }], [1, "&cudarrr;"], [0, "&ldca;"], [0, "&rdca;"], [0, "&cudarrl;"], [0, "&larrpl;"], [2, "&curarrm;"], [0, "&cularrp;"], [7, "&rarrpl;"], [2, "&harrcir;"], [0, "&Uarrocir;"], [0, "&lurdshar;"], [0, "&ldrushar;"], [2, "&LeftRightVector;"], [0, "&RightUpDownVector;"], [0, "&DownLeftRightVector;"], [0, "&LeftUpDownVector;"], [0, "&LeftVectorBar;"], [0, "&RightVectorBar;"], [0, "&RightUpVectorBar;"], [0, "&RightDownVectorBar;"], [0, "&DownLeftVectorBar;"], [0, "&DownRightVectorBar;"], [0, "&LeftUpVectorBar;"], [0, "&LeftDownVectorBar;"], [0, "&LeftTeeVector;"], [0, "&RightTeeVector;"], [0, "&RightUpTeeVector;"], [0, "&RightDownTeeVector;"], [0, "&DownLeftTeeVector;"], [0, "&DownRightTeeVector;"], [0, "&LeftUpTeeVector;"], [0, "&LeftDownTeeVector;"], [0, "&lHar;"], [0, "&uHar;"], [0, "&rHar;"], [0, "&dHar;"], [0, "&luruhar;"], [0, "&ldrdhar;"], [0, "&ruluhar;"], [0, "&rdldhar;"], [0, "&lharul;"], [0, "&llhard;"], [0, "&rharul;"], [0, "&lrhard;"], [0, "&udhar;"], [0, "&duhar;"], [0, "&RoundImplies;"], [0, "&erarr;"], [0, "&simrarr;"], [0, "&larrsim;"], [0, "&rarrsim;"], [0, "&rarrap;"], [0, "&ltlarr;"], [1, "&gtrarr;"], [0, "&subrarr;"], [1, "&suplarr;"], [0, "&lfisht;"], [0, "&rfisht;"], [0, "&ufisht;"], [0, "&dfisht;"], [5, "&lopar;"], [0, "&ropar;"], [4, "&lbrke;"], [0, "&rbrke;"], [0, "&lbrkslu;"], [0, "&rbrksld;"], [0, "&lbrksld;"], [0, "&rbrkslu;"], [0, "&langd;"], [0, "&rangd;"], [0, "&lparlt;"], [0, "&rpargt;"], [0, "&gtlPar;"], [0, "&ltrPar;"], [3, "&vzigzag;"], [1, "&vangrt;"], [0, "&angrtvbd;"], [6, "&ange;"], [0, "&range;"], [0, "&dwangle;"], [0, "&uwangle;"], [0, "&angmsdaa;"], [0, "&angmsdab;"], [0, "&angmsdac;"], [0, "&angmsdad;"], [0, "&angmsdae;"], [0, "&angmsdaf;"], [0, "&angmsdag;"], [0, "&angmsdah;"], [0, "&bemptyv;"], [0, "&demptyv;"], [0, "&cemptyv;"], [0, "&raemptyv;"], [0, "&laemptyv;"], [0, "&ohbar;"], [0, "&omid;"], [0, "&opar;"], [1, "&operp;"], [1, "&olcross;"], [0, "&odsold;"], [1, "&olcir;"], [0, "&ofcir;"], [0, "&olt;"], [0, "&ogt;"], [0, "&cirscir;"], [0, "&cirE;"], [0, "&solb;"], [0, "&bsolb;"], [3, "&boxbox;"], [3, "&trisb;"], [0, "&rtriltri;"], [0, { v: "&LeftTriangleBar;", n: 824, o: "&NotLeftTriangleBar;" }], [0, { v: "&RightTriangleBar;", n: 824, o: "&NotRightTriangleBar;" }], [11, "&iinfin;"], [0, "&infintie;"], [0, "&nvinfin;"], [4, "&eparsl;"], [0, "&smeparsl;"], [0, "&eqvparsl;"], [5, "&blacklozenge;"], [8, "&RuleDelayed;"], [1, "&dsol;"], [9, "&bigodot;"], [0, "&bigoplus;"], [0, "&bigotimes;"], [1, "&biguplus;"], [1, "&bigsqcup;"], [5, "&iiiint;"], [0, "&fpartint;"], [2, "&cirfnint;"], [0, "&awint;"], [0, "&rppolint;"], [0, "&scpolint;"], [0, "&npolint;"], [0, "&pointint;"], [0, "&quatint;"], [0, "&intlarhk;"], [10, "&pluscir;"], [0, "&plusacir;"], [0, "&simplus;"], [0, "&plusdu;"], [0, "&plussim;"], [0, "&plustwo;"], [1, "&mcomma;"], [0, "&minusdu;"], [2, "&loplus;"], [0, "&roplus;"], [0, "&Cross;"], [0, "&timesd;"], [0, "&timesbar;"], [1, "&smashp;"], [0, "&lotimes;"], [0, "&rotimes;"], [0, "&otimesas;"], [0, "&Otimes;"], [0, "&odiv;"], [0, "&triplus;"], [0, "&triminus;"], [0, "&tritime;"], [0, "&intprod;"], [2, "&amalg;"], [0, "&capdot;"], [1, "&ncup;"], [0, "&ncap;"], [0, "&capand;"], [0, "&cupor;"], [0, "&cupcap;"], [0, "&capcup;"], [0, "&cupbrcap;"], [0, "&capbrcup;"], [0, "&cupcup;"], [0, "&capcap;"], [0, "&ccups;"], [0, "&ccaps;"], [2, "&ccupssm;"], [2, "&And;"], [0, "&Or;"], [0, "&andand;"], [0, "&oror;"], [0, "&orslope;"], [0, "&andslope;"], [1, "&andv;"], [0, "&orv;"], [0, "&andd;"], [0, "&ord;"], [1, "&wedbar;"], [6, "&sdote;"], [3, "&simdot;"], [2, { v: "&congdot;", n: 824, o: "&ncongdot;" }], [0, "&easter;"], [0, "&apacir;"], [0, { v: "&apE;", n: 824, o: "&napE;" }], [0, "&eplus;"], [0, "&pluse;"], [0, "&Esim;"], [0, "&Colone;"], [0, "&Equal;"], [1, "&ddotseq;"], [0, "&equivDD;"], [0, "&ltcir;"], [0, "&gtcir;"], [0, "&ltquest;"], [0, "&gtquest;"], [0, { v: "&leqslant;", n: 824, o: "&nleqslant;" }], [0, { v: "&geqslant;", n: 824, o: "&ngeqslant;" }], [0, "&lesdot;"], [0, "&gesdot;"], [0, "&lesdoto;"], [0, "&gesdoto;"], [0, "&lesdotor;"], [0, "&gesdotol;"], [0, "&lap;"], [0, "&gap;"], [0, "&lne;"], [0, "&gne;"], [0, "&lnap;"], [0, "&gnap;"], [0, "&lEg;"], [0, "&gEl;"], [0, "&lsime;"], [0, "&gsime;"], [0, "&lsimg;"], [0, "&gsiml;"], [0, "&lgE;"], [0, "&glE;"], [0, "&lesges;"], [0, "&gesles;"], [0, "&els;"], [0, "&egs;"], [0, "&elsdot;"], [0, "&egsdot;"], [0, "&el;"], [0, "&eg;"], [2, "&siml;"], [0, "&simg;"], [0, "&simlE;"], [0, "&simgE;"], [0, { v: "&LessLess;", n: 824, o: "&NotNestedLessLess;" }], [0, { v: "&GreaterGreater;", n: 824, o: "&NotNestedGreaterGreater;" }], [1, "&glj;"], [0, "&gla;"], [0, "&ltcc;"], [0, "&gtcc;"], [0, "&lescc;"], [0, "&gescc;"], [0, "&smt;"], [0, "&lat;"], [0, { v: "&smte;", n: 65024, o: "&smtes;" }], [0, { v: "&late;", n: 65024, o: "&lates;" }], [0, "&bumpE;"], [0, { v: "&PrecedesEqual;", n: 824, o: "&NotPrecedesEqual;" }], [0, { v: "&sce;", n: 824, o: "&NotSucceedsEqual;" }], [2, "&prE;"], [0, "&scE;"], [0, "&precneqq;"], [0, "&scnE;"], [0, "&prap;"], [0, "&scap;"], [0, "&precnapprox;"], [0, "&scnap;"], [0, "&Pr;"], [0, "&Sc;"], [0, "&subdot;"], [0, "&supdot;"], [0, "&subplus;"], [0, "&supplus;"], [0, "&submult;"], [0, "&supmult;"], [0, "&subedot;"], [0, "&supedot;"], [0, { v: "&subE;", n: 824, o: "&nsubE;" }], [0, { v: "&supE;", n: 824, o: "&nsupE;" }], [0, "&subsim;"], [0, "&supsim;"], [2, { v: "&subnE;", n: 65024, o: "&varsubsetneqq;" }], [0, { v: "&supnE;", n: 65024, o: "&varsupsetneqq;" }], [2, "&csub;"], [0, "&csup;"], [0, "&csube;"], [0, "&csupe;"], [0, "&subsup;"], [0, "&supsub;"], [0, "&subsub;"], [0, "&supsup;"], [0, "&suphsub;"], [0, "&supdsub;"], [0, "&forkv;"], [0, "&topfork;"], [0, "&mlcp;"], [8, "&Dashv;"], [1, "&Vdashl;"], [0, "&Barv;"], [0, "&vBar;"], [0, "&vBarv;"], [1, "&Vbar;"], [0, "&Not;"], [0, "&bNot;"], [0, "&rnmid;"], [0, "&cirmid;"], [0, "&midcir;"], [0, "&topcir;"], [0, "&nhpar;"], [0, "&parsim;"], [9, { v: "&parsl;", n: 8421, o: "&nparsl;" }], [44343, { n: new Map(/* #__PURE__ */ restoreDiff([[56476, "&Ascr;"], [1, "&Cscr;"], [0, "&Dscr;"], [2, "&Gscr;"], [2, "&Jscr;"], [0, "&Kscr;"], [2, "&Nscr;"], [0, "&Oscr;"], [0, "&Pscr;"], [0, "&Qscr;"], [1, "&Sscr;"], [0, "&Tscr;"], [0, "&Uscr;"], [0, "&Vscr;"], [0, "&Wscr;"], [0, "&Xscr;"], [0, "&Yscr;"], [0, "&Zscr;"], [0, "&ascr;"], [0, "&bscr;"], [0, "&cscr;"], [0, "&dscr;"], [1, "&fscr;"], [1, "&hscr;"], [0, "&iscr;"], [0, "&jscr;"], [0, "&kscr;"], [0, "&lscr;"], [0, "&mscr;"], [0, "&nscr;"], [1, "&pscr;"], [0, "&qscr;"], [0, "&rscr;"], [0, "&sscr;"], [0, "&tscr;"], [0, "&uscr;"], [0, "&vscr;"], [0, "&wscr;"], [0, "&xscr;"], [0, "&yscr;"], [0, "&zscr;"], [52, "&Afr;"], [0, "&Bfr;"], [1, "&Dfr;"], [0, "&Efr;"], [0, "&Ffr;"], [0, "&Gfr;"], [2, "&Jfr;"], [0, "&Kfr;"], [0, "&Lfr;"], [0, "&Mfr;"], [0, "&Nfr;"], [0, "&Ofr;"], [0, "&Pfr;"], [0, "&Qfr;"], [1, "&Sfr;"], [0, "&Tfr;"], [0, "&Ufr;"], [0, "&Vfr;"], [0, "&Wfr;"], [0, "&Xfr;"], [0, "&Yfr;"], [1, "&afr;"], [0, "&bfr;"], [0, "&cfr;"], [0, "&dfr;"], [0, "&efr;"], [0, "&ffr;"], [0, "&gfr;"], [0, "&hfr;"], [0, "&ifr;"], [0, "&jfr;"], [0, "&kfr;"], [0, "&lfr;"], [0, "&mfr;"], [0, "&nfr;"], [0, "&ofr;"], [0, "&pfr;"], [0, "&qfr;"], [0, "&rfr;"], [0, "&sfr;"], [0, "&tfr;"], [0, "&ufr;"], [0, "&vfr;"], [0, "&wfr;"], [0, "&xfr;"], [0, "&yfr;"], [0, "&zfr;"], [0, "&Aopf;"], [0, "&Bopf;"], [1, "&Dopf;"], [0, "&Eopf;"], [0, "&Fopf;"], [0, "&Gopf;"], [1, "&Iopf;"], [0, "&Jopf;"], [0, "&Kopf;"], [0, "&Lopf;"], [0, "&Mopf;"], [1, "&Oopf;"], [3, "&Sopf;"], [0, "&Topf;"], [0, "&Uopf;"], [0, "&Vopf;"], [0, "&Wopf;"], [0, "&Xopf;"], [0, "&Yopf;"], [1, "&aopf;"], [0, "&bopf;"], [0, "&copf;"], [0, "&dopf;"], [0, "&eopf;"], [0, "&fopf;"], [0, "&gopf;"], [0, "&hopf;"], [0, "&iopf;"], [0, "&jopf;"], [0, "&kopf;"], [0, "&lopf;"], [0, "&mopf;"], [0, "&nopf;"], [0, "&oopf;"], [0, "&popf;"], [0, "&qopf;"], [0, "&ropf;"], [0, "&sopf;"], [0, "&topf;"], [0, "&uopf;"], [0, "&vopf;"], [0, "&wopf;"], [0, "&xopf;"], [0, "&yopf;"], [0, "&zopf;"]])) }], [8906, "&fflig;"], [0, "&filig;"], [0, "&fllig;"], [0, "&ffilig;"], [0, "&ffllig;"]]));
+//# sourceMappingURL=encode-html.js.map
+
+/***/ }),
+
+/***/ 2730:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+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 = void 0;
+var decode_js_1 = __webpack_require__(9878);
+var encode_js_1 = __webpack_require__(1818);
+var escape_js_1 = __webpack_require__(5987);
+/** The level of entities to support. */
+var EntityLevel;
+(function (EntityLevel) {
+    /** Support only XML entities. */
+    EntityLevel[EntityLevel["XML"] = 0] = "XML";
+    /** Support HTML entities, which are a superset of XML entities. */
+    EntityLevel[EntityLevel["HTML"] = 1] = "HTML";
+})(EntityLevel = exports.EntityLevel || (exports.EntityLevel = {}));
+var EncodingMode;
+(function (EncodingMode) {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * XML will be escaped.
+     */
+    EncodingMode[EncodingMode["UTF8"] = 0] = "UTF8";
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    EncodingMode[EncodingMode["ASCII"] = 1] = "ASCII";
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    EncodingMode[EncodingMode["Extensive"] = 2] = "Extensive";
+    /**
+     * Encode all characters that have to be escaped in HTML attributes,
+     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+     */
+    EncodingMode[EncodingMode["Attribute"] = 3] = "Attribute";
+    /**
+     * Encode all characters that have to be escaped in HTML text,
+     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+     */
+    EncodingMode[EncodingMode["Text"] = 4] = "Text";
+})(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));
+/**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ */
+function decode(data, options) {
+    if (options === void 0) { 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;
+/**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ * @deprecated Use `decode` with the `mode` set to `Strict`.
+ */
+function decodeStrict(data, options) {
+    var _a;
+    if (options === void 0) { options = EntityLevel.XML; }
+    var opts = typeof options === "number" ? { level: options } : options;
+    (_a = opts.mode) !== null && _a !== void 0 ? _a : (opts.mode = decode_js_1.DecodingMode.Strict);
+    return decode(data, opts);
+}
+exports.decodeStrict = decodeStrict;
+/**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param options Encoding options.
+ */
+function encode(data, options) {
+    if (options === void 0) { options = EntityLevel.XML; }
+    var opts = typeof options === "number" ? { level: options } : options;
+    // Mode `UTF8` just escapes XML entities
+    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);
+    }
+    // ASCII and Extensive are equivalent
+    return (0, escape_js_1.encodeXML)(data);
+}
+exports.encode = encode;
+var escape_js_2 = __webpack_require__(5987);
+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 = __webpack_require__(1818);
+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; } }));
+// Legacy aliases (deprecated)
+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 = __webpack_require__(9878);
+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; } }));
+// Legacy aliases (deprecated)
+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; } }));
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 7007:
+/***/ ((module) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  }
+
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+}
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+    }
+    defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function() {
+
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+};
+
 // Obviously not all Emitters should be limited to 10. This function allows
 // that to be increased. Set to zero for unlimited.
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
@@ -1714,18 +2747,18 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 
 /***/ }),
 
-/***/ 9755:
+/***/ 4692:
 /***/ (function(module, exports) {
 
 var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
- * jQuery JavaScript Library v3.7.0
+ * jQuery JavaScript Library v3.7.1
  * https://jquery.com/
  *
  * Copyright OpenJS Foundation and other contributors
  * Released under the MIT license
  * https://jquery.org/license
  *
- * Date: 2023-05-11T18:29Z
+ * Date: 2023-08-28T13:37Z
  */
 ( function( global, factory ) {
 
@@ -1866,7 +2899,7 @@ function toType( obj ) {
 
 
 
-var version = "3.7.0",
+var version = "3.7.1",
 
 	rhtmlSuffix = /HTML$/i,
 
@@ -2130,9 +3163,14 @@ jQuery.extend( {
 				// Do not traverse comment nodes
 				ret += jQuery.text( node );
 			}
-		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+		}
+		if ( nodeType === 1 || nodeType === 11 ) {
 			return elem.textContent;
-		} else if ( nodeType === 3 || nodeType === 4 ) {
+		}
+		if ( nodeType === 9 ) {
+			return elem.documentElement.textContent;
+		}
+		if ( nodeType === 3 || nodeType === 4 ) {
 			return elem.nodeValue;
 		}
 
@@ -2845,12 +3883,17 @@ function setDocument( node ) {
 		documentElement.msMatchesSelector;
 
 	// Support: IE 9 - 11+, Edge 12 - 18+
-	// Accessing iframe documents after unload throws "permission denied" errors (see trac-13936)
-	// Support: IE 11+, Edge 17 - 18+
-	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
-	// two documents; shallow comparisons work.
-	// eslint-disable-next-line eqeqeq
-	if ( preferredDoc != document &&
+	// Accessing iframe documents after unload throws "permission denied" errors
+	// (see trac-13936).
+	// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,
+	// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.
+	if ( documentElement.msMatchesSelector &&
+
+		// Support: IE 11+, Edge 17 - 18+
+		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+		// two documents; shallow comparisons work.
+		// eslint-disable-next-line eqeqeq
+		preferredDoc != document &&
 		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
 
 		// Support: IE 9 - 11+, Edge 12 - 18+
@@ -4413,12 +5456,12 @@ jQuery.find = find;
 jQuery.expr[ ":" ] = jQuery.expr.pseudos;
 jQuery.unique = jQuery.uniqueSort;
 
-// These have always been private, but they used to be documented
-// as part of Sizzle so let's maintain them in the 3.x line
-// for backwards compatibility purposes.
+// These have always been private, but they used to be documented as part of
+// Sizzle so let's maintain them for now for backwards compatibility purposes.
 find.compile = compile;
 find.select = select;
 find.setDocument = setDocument;
+find.tokenize = tokenize;
 
 find.escape = jQuery.escapeSelector;
 find.getText = jQuery.text;
@@ -7632,7 +8675,7 @@ function domManip( collection, args, callback, ignored ) {
 			if ( hasScripts ) {
 				doc = scripts[ scripts.length - 1 ].ownerDocument;
 
-				// Reenable scripts
+				// Re-enable scripts
 				jQuery.map( scripts, restoreScript );
 
 				// Evaluate executable scripts on first document insertion
@@ -8089,7 +9132,7 @@ var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
 				trChild = document.createElement( "div" );
 
 				table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
-				tr.style.cssText = "border:1px solid";
+				tr.style.cssText = "box-sizing:content-box;border:1px solid";
 
 				// Support: Chrome 86+
 				// Height set through cssText does not get applied.
@@ -8101,7 +9144,7 @@ var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
 				// In our bodyBackground.html iframe,
 				// display for all div elements is set to "inline",
 				// which causes a problem only in Android 8 Chrome 86.
-				// Ensuring the div is display: block
+				// Ensuring the div is `display: block`
 				// gets around this issue.
 				trChild.style.display = "block";
 
@@ -12269,7 +13312,9 @@ jQuery.fn.extend( {
 	},
 
 	hover: function( fnOver, fnOut ) {
-		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+		return this
+			.on( "mouseenter", fnOver )
+			.on( "mouseleave", fnOut || fnOver );
 	}
 } );
 
@@ -12426,84 +13471,271 @@ return jQuery;
 
 /***/ }),
 
-/***/ 8337:
+/***/ 2814:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
 
+var uc_micro = __webpack_require__(3492);
 
-////////////////////////////////////////////////////////////////////////////////
-// Helpers
-
-// Merge objects
-//
-function assign(obj /*from1, from2, from3, ...*/) {
-  var sources = Array.prototype.slice.call(arguments, 1);
+function reFactory (opts) {
+  const re = {};
+  opts = opts || {};
 
-  sources.forEach(function (source) {
-    if (!source) { return; }
+  re.src_Any = uc_micro.Any.source;
+  re.src_Cc = uc_micro.Cc.source;
+  re.src_Z = uc_micro.Z.source;
+  re.src_P = uc_micro.P.source;
 
-    Object.keys(source).forEach(function (key) {
-      obj[key] = source[key];
-    });
-  });
+  // \p{\Z\P\Cc\CF} (white spaces + control + format + punctuation)
+  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join('|');
 
-  return obj;
-}
+  // \p{\Z\Cc} (white spaces + control)
+  re.src_ZCc = [re.src_Z, re.src_Cc].join('|');
 
-function _class(obj) { return Object.prototype.toString.call(obj); }
-function isString(obj) { return _class(obj) === '[object String]'; }
-function isObject(obj) { return _class(obj) === '[object Object]'; }
-function isRegExp(obj) { return _class(obj) === '[object RegExp]'; }
-function isFunction(obj) { return _class(obj) === '[object Function]'; }
+  // Experimental. List of chars, completely prohibited in links
+  // because can separate it from other part of text
+  const text_separators = '[><\uff5c]';
 
+  // All possible word characters (everything without punctuation, spaces & controls)
+  // Defined via punctuation & spaces to save space
+  // Should be something like \p{\L\N\S\M} (\w but without `_`)
+  re.src_pseudo_letter = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';
+  // The same as abothe but without [0-9]
+  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';
 
-function escapeRE(str) { return str.replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&'); }
+  re.src_ip4 =
 
-////////////////////////////////////////////////////////////////////////////////
+    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';
 
+  // Prohibit any of "@/[]()" in user/pass to avoid wrong domain fetch.
+  re.src_auth = '(?:(?:(?!' + re.src_ZCc + '|[@/\\[\\]()]).)+@)?';
 
-var defaultOptions = {
-  fuzzyLink: true,
-  fuzzyEmail: true,
-  fuzzyIP: false
-};
+  re.src_port =
 
+    '(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?';
 
-function isOptionsObj(obj) {
-  return Object.keys(obj || {}).reduce(function (acc, k) {
-    return acc || defaultOptions.hasOwnProperty(k);
-  }, false);
-}
+  re.src_host_terminator =
 
+    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')' +
+    '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\d|\\.-|\\.(?!$|' + re.src_ZPCc + '))';
 
-var defaultSchemas = {
-  'http:': {
-    validate: function (text, pos, self) {
-      var tail = text.slice(pos);
+  re.src_path =
 
-      if (!self.re.http) {
-        // compile lazily, because "host"-containing variables can change on tlds update.
-        self.re.http =  new RegExp(
+    '(?:' +
+      '[/?#]' +
+        '(?:' +
+          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\]{}.,"\'?!\\-;]).|' +
+          '\\[(?:(?!' + re.src_ZCc + '|\\]).)*\\]|' +
+          '\\((?:(?!' + re.src_ZCc + '|[)]).)*\\)|' +
+          '\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\}|' +
+          '\\"(?:(?!' + re.src_ZCc + '|["]).)+\\"|' +
+          "\\'(?:(?!" + re.src_ZCc + "|[']).)+\\'|" +
+
+          // allow `I'm_king` if no pair found
+          "\\'(?=" + re.src_pseudo_letter + '|[-])|' +
+
+          // google has many dots in "google search" links (#66, #81).
+          // github has ... in commit range links,
+          // Restrict to
+          // - english
+          // - percent-encoded
+          // - parts of file path
+          // - params separator
+          // until more examples found.
+          '\\.{2,}[a-zA-Z0-9%/&]|' +
+
+          '\\.(?!' + re.src_ZCc + '|[.]|$)|' +
+          (opts['---']
+            ? '\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate
+            : '\\-+|'
+          ) +
+          // allow `,,,` in paths
+          ',(?!' + re.src_ZCc + '|$)|' +
+
+          // allow `;` if not followed by space-like char
+          ';(?!' + re.src_ZCc + '|$)|' +
+
+          // allow `!!!` in paths, but not at the end
+          '\\!+(?!' + re.src_ZCc + '|[!]|$)|' +
+
+          '\\?(?!' + re.src_ZCc + '|[?]|$)' +
+        ')+' +
+      '|\\/' +
+    ')?';
+
+  // Allow anything in markdown spec, forbid quote (") at the first position
+  // because emails enclosed in quotes are far more common
+  re.src_email_name =
+
+    '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
+
+  re.src_xn =
+
+    'xn--[a-z0-9\\-]{1,59}';
+
+  // More to read about domain names
+  // http://serverfault.com/questions/638260/
+
+  re.src_domain_root =
+
+    // Allow letters & digits (http://test1)
+    '(?:' +
+      re.src_xn +
+      '|' +
+      re.src_pseudo_letter + '{1,63}' +
+    ')';
+
+  re.src_domain =
+
+    '(?:' +
+      re.src_xn +
+      '|' +
+      '(?:' + re.src_pseudo_letter + ')' +
+      '|' +
+      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +
+    ')';
+
+  re.src_host =
+
+    '(?:' +
+    // Don't need IP check, because digits are already allowed in normal domain names
+    //   src_ip4 +
+    // '|' +
+      '(?:(?:(?:' + re.src_domain + ')\\.)*' + re.src_domain/* _root */ + ')' +
+    ')';
+
+  re.tpl_host_fuzzy =
+
+    '(?:' +
+      re.src_ip4 +
+    '|' +
+      '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))' +
+    ')';
+
+  re.tpl_host_no_ip_fuzzy =
+
+    '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))';
+
+  re.src_host_strict =
+
+    re.src_host + re.src_host_terminator;
+
+  re.tpl_host_fuzzy_strict =
+
+    re.tpl_host_fuzzy + re.src_host_terminator;
+
+  re.src_host_port_strict =
+
+    re.src_host + re.src_port + re.src_host_terminator;
+
+  re.tpl_host_port_fuzzy_strict =
+
+    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
+
+  re.tpl_host_port_no_ip_fuzzy_strict =
+
+    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
+
+  //
+  // Main rules
+  //
+
+  // Rude test fuzzy links by host, for quick deny
+  re.tpl_host_fuzzy_test =
+
+    'localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';
+
+  re.tpl_email_fuzzy =
+
+      '(^|' + text_separators + '|"|\\(|' + re.src_ZCc + ')' +
+      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';
+
+  re.tpl_link_fuzzy =
+      // Fuzzy link can't be prepended with .:/\- and non punctuation.
+      // but can start with > (markdown blockquote)
+      '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' +
+      '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';
+
+  re.tpl_link_no_ip_fuzzy =
+      // Fuzzy link can't be prepended with .:/\- and non punctuation.
+      // but can start with > (markdown blockquote)
+      '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' +
+      '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';
+
+  return re
+}
+
+//
+// Helpers
+//
+
+// Merge objects
+//
+function assign (obj /* from1, from2, from3, ... */) {
+  const sources = Array.prototype.slice.call(arguments, 1);
+
+  sources.forEach(function (source) {
+    if (!source) { return }
+
+    Object.keys(source).forEach(function (key) {
+      obj[key] = source[key];
+    });
+  });
+
+  return obj
+}
+
+function _class (obj) { return Object.prototype.toString.call(obj) }
+function isString (obj) { return _class(obj) === '[object String]' }
+function isObject (obj) { return _class(obj) === '[object Object]' }
+function isRegExp (obj) { return _class(obj) === '[object RegExp]' }
+function isFunction (obj) { return _class(obj) === '[object Function]' }
+
+function escapeRE (str) { return str.replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&') }
+
+//
+
+const defaultOptions = {
+  fuzzyLink: true,
+  fuzzyEmail: true,
+  fuzzyIP: false
+};
+
+function isOptionsObj (obj) {
+  return Object.keys(obj || {}).reduce(function (acc, k) {
+    /* eslint-disable-next-line no-prototype-builtins */
+    return acc || defaultOptions.hasOwnProperty(k)
+  }, false)
+}
+
+const defaultSchemas = {
+  'http:': {
+    validate: function (text, pos, self) {
+      const tail = text.slice(pos);
+
+      if (!self.re.http) {
+        // compile lazily, because "host"-containing variables can change on tlds update.
+        self.re.http = new RegExp(
           '^\\/\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i'
         );
       }
       if (self.re.http.test(tail)) {
-        return tail.match(self.re.http)[0].length;
+        return tail.match(self.re.http)[0].length
       }
-      return 0;
+      return 0
     }
   },
-  'https:':  'http:',
-  'ftp:':    'http:',
-  '//':      {
+  'https:': 'http:',
+  'ftp:': 'http:',
+  '//': {
     validate: function (text, pos, self) {
-      var tail = text.slice(pos);
+      const tail = text.slice(pos);
 
       if (!self.re.no_http) {
       // compile lazily, because "host"-containing variables can change on tlds update.
-        self.re.no_http =  new RegExp(
+        self.re.no_http = new RegExp(
           '^' +
           self.re.src_auth +
           // Don't allow single-level domains, because of false positives like '//test'
@@ -12519,73 +13751,67 @@ var defaultSchemas = {
 
       if (self.re.no_http.test(tail)) {
         // should not be `://` & `///`, that protects from errors in protocol name
-        if (pos >= 3 && text[pos - 3] === ':') { return 0; }
-        if (pos >= 3 && text[pos - 3] === '/') { return 0; }
-        return tail.match(self.re.no_http)[0].length;
+        if (pos >= 3 && text[pos - 3] === ':') { return 0 }
+        if (pos >= 3 && text[pos - 3] === '/') { return 0 }
+        return tail.match(self.re.no_http)[0].length
       }
-      return 0;
+      return 0
     }
   },
   'mailto:': {
     validate: function (text, pos, self) {
-      var tail = text.slice(pos);
+      const tail = text.slice(pos);
 
       if (!self.re.mailto) {
-        self.re.mailto =  new RegExp(
+        self.re.mailto = new RegExp(
           '^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i'
         );
       }
       if (self.re.mailto.test(tail)) {
-        return tail.match(self.re.mailto)[0].length;
+        return tail.match(self.re.mailto)[0].length
       }
-      return 0;
+      return 0
     }
   }
 };
 
-/*eslint-disable max-len*/
-
 // RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)
-var tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';
+/* eslint-disable-next-line max-len */
+const tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';
 
 // DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead
-var tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');
+const tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');
 
-/*eslint-enable max-len*/
-
-////////////////////////////////////////////////////////////////////////////////
-
-function resetScanCache(self) {
+function resetScanCache (self) {
   self.__index__ = -1;
-  self.__text_cache__   = '';
+  self.__text_cache__ = '';
 }
 
-function createValidator(re) {
+function createValidator (re) {
   return function (text, pos) {
-    var tail = text.slice(pos);
+    const tail = text.slice(pos);
 
     if (re.test(tail)) {
-      return tail.match(re)[0].length;
+      return tail.match(re)[0].length
     }
-    return 0;
-  };
+    return 0
+  }
 }
 
-function createNormalizer() {
+function createNormalizer () {
   return function (match, self) {
     self.normalize(match);
-  };
+  }
 }
 
 // Schemas compiler. Build regexps.
 //
-function compile(self) {
-
+function compile (self) {
   // Load & clone RE patterns.
-  var re = self.re = __webpack_require__(6066)(self.__opts__);
+  const re = self.re = reFactory(self.__opts__);
 
   // Define dynamic patterns
-  var tlds = self.__tlds__.slice();
+  const tlds = self.__tlds__.slice();
 
   self.onCompile();
 
@@ -12596,32 +13822,32 @@ function compile(self) {
 
   re.src_tlds = tlds.join('|');
 
-  function untpl(tpl) { return tpl.replace('%TLDS%', re.src_tlds); }
+  function untpl (tpl) { return tpl.replace('%TLDS%', re.src_tlds) }
 
-  re.email_fuzzy      = RegExp(untpl(re.tpl_email_fuzzy), 'i');
-  re.link_fuzzy       = RegExp(untpl(re.tpl_link_fuzzy), 'i');
+  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), 'i');
+  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), 'i');
   re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');
-  re.host_fuzzy_test  = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');
+  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');
 
   //
   // Compile each schema
   //
 
-  var aliases = [];
+  const aliases = [];
 
   self.__compiled__ = {}; // Reset compiled data
 
-  function schemaError(name, val) {
-    throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
+  function schemaError (name, val) {
+    throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val)
   }
 
   Object.keys(self.__schemas__).forEach(function (name) {
-    var val = self.__schemas__[name];
+    const val = self.__schemas__[name];
 
     // skip disabled methods
-    if (val === null) { return; }
+    if (val === null) { return }
 
-    var compiled = { validate: null, link: null };
+    const compiled = { validate: null, link: null };
 
     self.__compiled__[name] = compiled;
 
@@ -12642,12 +13868,12 @@ function compile(self) {
         schemaError(name, val);
       }
 
-      return;
+      return
     }
 
     if (isString(val)) {
       aliases.push(name);
-      return;
+      return
     }
 
     schemaError(name, val);
@@ -12661,7 +13887,7 @@ function compile(self) {
     if (!self.__compiled__[self.__schemas__[alias]]) {
       // Silently fail on missed schemas to avoid errons on disable.
       // schemaError(alias, self.__schemas__[alias]);
-      return;
+      return
     }
 
     self.__compiled__[alias].validate =
@@ -12678,16 +13904,16 @@ function compile(self) {
   //
   // Build schema condition
   //
-  var slist = Object.keys(self.__compiled__)
-                      .filter(function (name) {
-                        // Filter disabled & fake schemas
-                        return name.length > 0 && self.__compiled__[name];
-                      })
-                      .map(escapeRE)
-                      .join('|');
+  const slist = Object.keys(self.__compiled__)
+    .filter(function (name) {
+      // Filter disabled & fake schemas
+      return name.length > 0 && self.__compiled__[name]
+    })
+    .map(escapeRE)
+    .join('|');
   // (?!_) cause 1.5x slowdown
-  self.re.schema_test     = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');
-  self.re.schema_search   = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');
+  self.re.schema_test = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');
+  self.re.schema_search = RegExp('(^|(?!_)(?:[><\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');
   self.re.schema_at_start = RegExp('^' + self.re.schema_search.source, 'i');
 
   self.re.pretest = RegExp(
@@ -12707,23 +13933,23 @@ function compile(self) {
  *
  * Match result. Single element of array, returned by [[LinkifyIt#match]]
  **/
-function Match(self, shift) {
-  var start = self.__index__,
-      end   = self.__last_index__,
-      text  = self.__text_cache__.slice(start, end);
+function Match (self, shift) {
+  const start = self.__index__;
+  const end = self.__last_index__;
+  const text = self.__text_cache__.slice(start, end);
 
   /**
    * Match#schema -> String
    *
    * Prefix (protocol) for matched string.
    **/
-  this.schema    = self.__schema__.toLowerCase();
+  this.schema = self.__schema__.toLowerCase();
   /**
    * Match#index -> Number
    *
    * First position of matched string.
    **/
-  this.index     = start + shift;
+  this.index = start + shift;
   /**
    * Match#lastIndex -> Number
    *
@@ -12735,30 +13961,29 @@ function Match(self, shift) {
    *
    * Matched string.
    **/
-  this.raw       = text;
+  this.raw = text;
   /**
    * Match#text -> String
    *
    * Notmalized text of matched string.
    **/
-  this.text      = text;
+  this.text = text;
   /**
    * Match#url -> String
    *
    * Normalized url of matched string.
    **/
-  this.url       = text;
+  this.url = text;
 }
 
-function createMatch(self, shift) {
-  var match = new Match(self, shift);
+function createMatch (self, shift) {
+  const match = new Match(self, shift);
 
   self.__compiled__[match.schema].normalize(match, self);
 
-  return match;
+  return match
 }
 
-
 /**
  * class LinkifyIt
  **/
@@ -12797,9 +14022,9 @@ function createMatch(self, shift) {
  * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.
  *
  **/
-function LinkifyIt(schemas, options) {
+function LinkifyIt (schemas, options) {
   if (!(this instanceof LinkifyIt)) {
-    return new LinkifyIt(schemas, options);
+    return new LinkifyIt(schemas, options)
   }
 
   if (!options) {
@@ -12809,26 +14034,25 @@ function LinkifyIt(schemas, options) {
     }
   }
 
-  this.__opts__           = assign({}, defaultOptions, options);
+  this.__opts__ = assign({}, defaultOptions, options);
 
   // Cache last tested result. Used to skip repeating steps on next `match` call.
-  this.__index__          = -1;
-  this.__last_index__     = -1; // Next scan position
-  this.__schema__         = '';
-  this.__text_cache__     = '';
+  this.__index__ = -1;
+  this.__last_index__ = -1; // Next scan position
+  this.__schema__ = '';
+  this.__text_cache__ = '';
 
-  this.__schemas__        = assign({}, defaultSchemas, schemas);
-  this.__compiled__       = {};
+  this.__schemas__ = assign({}, defaultSchemas, schemas);
+  this.__compiled__ = {};
 
-  this.__tlds__           = tlds_default;
-  this.__tlds_replaced__  = false;
+  this.__tlds__ = tlds_default;
+  this.__tlds_replaced__ = false;
 
   this.re = {};
 
   compile(this);
 }
 
-
 /** chainable
  * LinkifyIt#add(schema, definition)
  * - schema (String): rule name (fixed pattern prefix)
@@ -12836,38 +14060,36 @@ function LinkifyIt(schemas, options) {
  *
  * Add new rule definition. See constructor description for details.
  **/
-LinkifyIt.prototype.add = function add(schema, definition) {
+LinkifyIt.prototype.add = function add (schema, definition) {
   this.__schemas__[schema] = definition;
   compile(this);
-  return this;
+  return this
 };
 
-
 /** chainable
  * LinkifyIt#set(options)
  * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
  *
  * Set recognition options for links without schema.
  **/
-LinkifyIt.prototype.set = function set(options) {
+LinkifyIt.prototype.set = function set (options) {
   this.__opts__ = assign(this.__opts__, options);
-  return this;
+  return this
 };
 
-
 /**
  * LinkifyIt#test(text) -> Boolean
  *
  * Searches linkifiable pattern and returns `true` on success or `false` on fail.
  **/
-LinkifyIt.prototype.test = function test(text) {
+LinkifyIt.prototype.test = function test (text) {
   // Reset scan cache
   this.__text_cache__ = text;
-  this.__index__      = -1;
+  this.__index__ = -1;
 
-  if (!text.length) { return false; }
+  if (!text.length) { return false }
 
-  var m, ml, me, len, shift, next, re, tld_pos, at_pos;
+  let m, ml, me, len, shift, next, re, tld_pos, at_pos;
 
   // try to scan for link with schema - that's the most simple rule
   if (this.re.schema_test.test(text)) {
@@ -12876,10 +14098,10 @@ LinkifyIt.prototype.test = function test(text) {
     while ((m = re.exec(text)) !== null) {
       len = this.testSchemaAt(text, m[2], re.lastIndex);
       if (len) {
-        this.__schema__     = m[2];
-        this.__index__      = m.index + m[1].length;
+        this.__schema__ = m[2];
+        this.__index__ = m.index + m[1].length;
         this.__last_index__ = m.index + m[0].length + len;
-        break;
+        break
       }
     }
   }
@@ -12891,12 +14113,11 @@ LinkifyIt.prototype.test = function test(text) {
       // if tld is located after found link - no need to check fuzzy pattern
       if (this.__index__ < 0 || tld_pos < this.__index__) {
         if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
-
           shift = ml.index + ml[1].length;
 
           if (this.__index__ < 0 || shift < this.__index__) {
-            this.__schema__     = '';
-            this.__index__      = shift;
+            this.__schema__ = '';
+            this.__index__ = shift;
             this.__last_index__ = ml.index + ml[0].length;
           }
         }
@@ -12911,24 +14132,22 @@ LinkifyIt.prototype.test = function test(text) {
       // We can't skip this check, because this cases are possible:
       // 192.168.1.1@gmail.com, my.in@example.com
       if ((me = text.match(this.re.email_fuzzy)) !== null) {
-
         shift = me.index + me[1].length;
-        next  = me.index + me[0].length;
+        next = me.index + me[0].length;
 
         if (this.__index__ < 0 || shift < this.__index__ ||
             (shift === this.__index__ && next > this.__last_index__)) {
-          this.__schema__     = 'mailto:';
-          this.__index__      = shift;
+          this.__schema__ = 'mailto:';
+          this.__index__ = shift;
           this.__last_index__ = next;
         }
       }
     }
   }
 
-  return this.__index__ >= 0;
+  return this.__index__ >= 0
 };
 
-
 /**
  * LinkifyIt#pretest(text) -> Boolean
  *
@@ -12936,11 +14155,10 @@ LinkifyIt.prototype.test = function test(text) {
  * can exists. Can be used for speed optimization, when you need to check that
  * link NOT exists.
  **/
-LinkifyIt.prototype.pretest = function pretest(text) {
-  return this.re.pretest.test(text);
+LinkifyIt.prototype.pretest = function pretest (text) {
+  return this.re.pretest.test(text)
 };
 
-
 /**
  * LinkifyIt#testSchemaAt(text, name, position) -> Number
  * - text (String): text to scan
@@ -12950,15 +14168,14 @@ LinkifyIt.prototype.pretest = function pretest(text) {
  * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly
  * at given position. Returns length of found pattern (0 on fail).
  **/
-LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
+LinkifyIt.prototype.testSchemaAt = function testSchemaAt (text, schema, pos) {
   // If not supported schema check requested - terminate
   if (!this.__compiled__[schema.toLowerCase()]) {
-    return 0;
+    return 0
   }
-  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
+  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this)
 };
 
-
 /**
  * LinkifyIt#match(text) -> Array|null
  *
@@ -12975,8 +14192,9 @@ LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
  * - __text__ - normalized text
  * - __url__ - link, generated from matched text
  **/
-LinkifyIt.prototype.match = function match(text) {
-  var shift = 0, result = [];
+LinkifyIt.prototype.match = function match (text) {
+  const result = [];
+  let shift = 0;
 
   // Try to take previous element from cache, if .test() called before
   if (this.__index__ >= 0 && this.__text_cache__ === text) {
@@ -12985,7 +14203,7 @@ LinkifyIt.prototype.match = function match(text) {
   }
 
   // Cut head if cache was used
-  var tail = shift ? text.slice(shift) : text;
+  let tail = shift ? text.slice(shift) : text;
 
   // Scan string until end reached
   while (this.test(tail)) {
@@ -12996,40 +14214,38 @@ LinkifyIt.prototype.match = function match(text) {
   }
 
   if (result.length) {
-    return result;
+    return result
   }
 
-  return null;
+  return null
 };
 
-
 /**
  * LinkifyIt#matchAtStart(text) -> Match|null
  *
  * Returns fully-formed (not fuzzy) link if it starts at the beginning
  * of the string, and null otherwise.
  **/
-LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
+LinkifyIt.prototype.matchAtStart = function matchAtStart (text) {
   // Reset scan cache
   this.__text_cache__ = text;
-  this.__index__      = -1;
+  this.__index__ = -1;
 
-  if (!text.length) return null;
+  if (!text.length) return null
 
-  var m = this.re.schema_at_start.exec(text);
-  if (!m) return null;
+  const m = this.re.schema_at_start.exec(text);
+  if (!m) return null
 
-  var len = this.testSchemaAt(text, m[2], m[0].length);
-  if (!len) return null;
+  const len = this.testSchemaAt(text, m[2], m[0].length);
+  if (!len) return null
 
-  this.__schema__     = m[2];
-  this.__index__      = m.index + m[1].length;
+  this.__schema__ = m[2];
+  this.__index__ = m.index + m[1].length;
   this.__last_index__ = m.index + m[0].length + len;
 
-  return createMatch(this, 0);
+  return createMatch(this, 0)
 };
 
-
 /** chainable
  * LinkifyIt#tlds(list [, keepOld]) -> this
  * - list (Array): list of tlds
@@ -13045,25 +14261,25 @@ LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
  *
  * If list is replaced, then exact match for 2-chars root zones will be checked.
  **/
-LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
-  list = Array.isArray(list) ? list : [ list ];
+LinkifyIt.prototype.tlds = function tlds (list, keepOld) {
+  list = Array.isArray(list) ? list : [list];
 
   if (!keepOld) {
     this.__tlds__ = list.slice();
     this.__tlds_replaced__ = true;
     compile(this);
-    return this;
+    return this
   }
 
   this.__tlds__ = this.__tlds__.concat(list)
-                                  .sort()
-                                  .filter(function (el, idx, arr) {
-                                    return el !== arr[idx - 1];
-                                  })
-                                  .reverse();
+    .sort()
+    .filter(function (el, idx, arr) {
+      return el !== arr[idx - 1]
+    })
+    .reverse();
 
   compile(this);
-  return this;
+  return this
 };
 
 /**
@@ -13071,8 +14287,7 @@ LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
  *
  * Default normalizer (if schema does not define it's own).
  **/
-LinkifyIt.prototype.normalize = function normalize(match) {
-
+LinkifyIt.prototype.normalize = function normalize (match) {
   // Do minimal possible changes by default. Need to collect feedback prior
   // to move forward https://github.com/markdown-it/linkify-it/issues/1
 
@@ -13083,508 +14298,193 @@ LinkifyIt.prototype.normalize = function normalize(match) {
   }
 };
 
-
 /**
  * LinkifyIt#onCompile()
  *
  * Override to modify basic RegExp-s.
  **/
-LinkifyIt.prototype.onCompile = function onCompile() {
+LinkifyIt.prototype.onCompile = function onCompile () {
 };
 
-
 module.exports = LinkifyIt;
 
 
 /***/ }),
 
-/***/ 6066:
+/***/ 383:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
 
+var mdurl = __webpack_require__(5778);
+var ucmicro = __webpack_require__(3492);
+var entities = __webpack_require__(2730);
+var LinkifyIt = __webpack_require__(2814);
+var punycode = __webpack_require__(7444);
 
-module.exports = function (opts) {
-  var re = {};
-  opts = opts || {};
-
-  // Use direct extract instead of `regenerate` to reduse browserified size
-  re.src_Any = (__webpack_require__(9369).source);
-  re.src_Cc  = (__webpack_require__(9413).source);
-  re.src_Z   = (__webpack_require__(5045).source);
-  re.src_P   = (__webpack_require__(3189).source);
-
-  // \p{\Z\P\Cc\CF} (white spaces + control + format + punctuation)
-  re.src_ZPCc = [ re.src_Z, re.src_P, re.src_Cc ].join('|');
-
-  // \p{\Z\Cc} (white spaces + control)
-  re.src_ZCc = [ re.src_Z, re.src_Cc ].join('|');
-
-  // Experimental. List of chars, completely prohibited in links
-  // because can separate it from other part of text
-  var text_separators = '[><\uff5c]';
-
-  // All possible word characters (everything without punctuation, spaces & controls)
-  // Defined via punctuation & spaces to save space
-  // Should be something like \p{\L\N\S\M} (\w but without `_`)
-  re.src_pseudo_letter       = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';
-  // The same as abothe but without [0-9]
-  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';
-
-  ////////////////////////////////////////////////////////////////////////////////
-
-  re.src_ip4 =
-
-    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';
-
-  // Prohibit any of "@/[]()" in user/pass to avoid wrong domain fetch.
-  re.src_auth    = '(?:(?:(?!' + re.src_ZCc + '|[@/\\[\\]()]).)+@)?';
-
-  re.src_port =
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
 
-    '(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?';
+var mdurl__namespace = /*#__PURE__*/_interopNamespaceDefault(mdurl);
+var ucmicro__namespace = /*#__PURE__*/_interopNamespaceDefault(ucmicro);
 
-  re.src_host_terminator =
+// Utilities
+//
 
-    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')' +
-    '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\d|\\.-|\\.(?!$|' + re.src_ZPCc + '))';
+function _class(obj) {
+  return Object.prototype.toString.call(obj);
+}
+function isString(obj) {
+  return _class(obj) === '[object String]';
+}
+const _hasOwnProperty = Object.prototype.hasOwnProperty;
+function has(object, key) {
+  return _hasOwnProperty.call(object, key);
+}
 
-  re.src_path =
-
-    '(?:' +
-      '[/?#]' +
-        '(?:' +
-          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\]{}.,"\'?!\\-;]).|' +
-          '\\[(?:(?!' + re.src_ZCc + '|\\]).)*\\]|' +
-          '\\((?:(?!' + re.src_ZCc + '|[)]).)*\\)|' +
-          '\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\}|' +
-          '\\"(?:(?!' + re.src_ZCc + '|["]).)+\\"|' +
-          "\\'(?:(?!" + re.src_ZCc + "|[']).)+\\'|" +
-          "\\'(?=" + re.src_pseudo_letter + '|[-])|' +  // allow `I'm_king` if no pair found
-          '\\.{2,}[a-zA-Z0-9%/&]|' + // google has many dots in "google search" links (#66, #81).
-                                     // github has ... in commit range links,
-                                     // Restrict to
-                                     // - english
-                                     // - percent-encoded
-                                     // - parts of file path
-                                     // - params separator
-                                     // until more examples found.
-          '\\.(?!' + re.src_ZCc + '|[.]|$)|' +
-          (opts['---'] ?
-            '\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate
-            :
-            '\\-+|'
-          ) +
-          ',(?!' + re.src_ZCc + '|$)|' +       // allow `,,,` in paths
-          ';(?!' + re.src_ZCc + '|$)|' +       // allow `;` if not followed by space-like char
-          '\\!+(?!' + re.src_ZCc + '|[!]|$)|' +  // allow `!!!` in paths, but not at the end
-          '\\?(?!' + re.src_ZCc + '|[?]|$)' +
-        ')+' +
-      '|\\/' +
-    ')?';
-
-  // Allow anything in markdown spec, forbid quote (") at the first position
-  // because emails enclosed in quotes are far more common
-  re.src_email_name =
-
-    '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
-
-  re.src_xn =
-
-    'xn--[a-z0-9\\-]{1,59}';
-
-  // More to read about domain names
-  // http://serverfault.com/questions/638260/
-
-  re.src_domain_root =
-
-    // Allow letters & digits (http://test1)
-    '(?:' +
-      re.src_xn +
-      '|' +
-      re.src_pseudo_letter + '{1,63}' +
-    ')';
-
-  re.src_domain =
-
-    '(?:' +
-      re.src_xn +
-      '|' +
-      '(?:' + re.src_pseudo_letter + ')' +
-      '|' +
-      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +
-    ')';
-
-  re.src_host =
-
-    '(?:' +
-    // Don't need IP check, because digits are already allowed in normal domain names
-    //   src_ip4 +
-    // '|' +
-      '(?:(?:(?:' + re.src_domain + ')\\.)*' + re.src_domain/*_root*/ + ')' +
-    ')';
-
-  re.tpl_host_fuzzy =
-
-    '(?:' +
-      re.src_ip4 +
-    '|' +
-      '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))' +
-    ')';
-
-  re.tpl_host_no_ip_fuzzy =
-
-    '(?:(?:(?:' + re.src_domain + ')\\.)+(?:%TLDS%))';
-
-  re.src_host_strict =
-
-    re.src_host + re.src_host_terminator;
-
-  re.tpl_host_fuzzy_strict =
-
-    re.tpl_host_fuzzy + re.src_host_terminator;
-
-  re.src_host_port_strict =
-
-    re.src_host + re.src_port + re.src_host_terminator;
-
-  re.tpl_host_port_fuzzy_strict =
-
-    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
-
-  re.tpl_host_port_no_ip_fuzzy_strict =
-
-    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
-
-
-  ////////////////////////////////////////////////////////////////////////////////
-  // Main rules
-
-  // Rude test fuzzy links by host, for quick deny
-  re.tpl_host_fuzzy_test =
-
-    'localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';
-
-  re.tpl_email_fuzzy =
-
-      '(^|' + text_separators + '|"|\\(|' + re.src_ZCc + ')' +
-      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';
-
-  re.tpl_link_fuzzy =
-      // Fuzzy link can't be prepended with .:/\- and non punctuation.
-      // but can start with > (markdown blockquote)
-      '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' +
-      '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';
-
-  re.tpl_link_no_ip_fuzzy =
-      // Fuzzy link can't be prepended with .:/\- and non punctuation.
-      // but can start with > (markdown blockquote)
-      '(^|(?![.:/\\-_@])(?:[$+<=>^`|\uff5c]|' + re.src_ZPCc + '))' +
-      '((?![$+<=>^`|\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';
-
-  return re;
-};
-
-
-/***/ }),
-
-/***/ 9980:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-
-module.exports = __webpack_require__(7024);
-
-
-/***/ }),
-
-/***/ 6233:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// HTML5 entities map: { name -> utf16string }
-//
-
-
-/*eslint quotes:0*/
-module.exports = __webpack_require__(9323);
-
-
-/***/ }),
-
-/***/ 813:
-/***/ ((module) => {
-
-"use strict";
-// List of valid html blocks names, accorting to commonmark spec
-// http://jgm.github.io/CommonMark/spec.html#html-blocks
-
-
-
-
-module.exports = [
-  'address',
-  'article',
-  'aside',
-  'base',
-  'basefont',
-  'blockquote',
-  'body',
-  'caption',
-  'center',
-  'col',
-  'colgroup',
-  'dd',
-  'details',
-  'dialog',
-  'dir',
-  'div',
-  'dl',
-  'dt',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'frame',
-  'frameset',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hr',
-  'html',
-  'iframe',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'menu',
-  'menuitem',
-  'nav',
-  'noframes',
-  'ol',
-  'optgroup',
-  'option',
-  'p',
-  'param',
-  'section',
-  'source',
-  'summary',
-  'table',
-  'tbody',
-  'td',
-  'tfoot',
-  'th',
-  'thead',
-  'title',
-  'tr',
-  'track',
-  'ul'
-];
-
-
-/***/ }),
-
-/***/ 1947:
-/***/ ((module) => {
-
-"use strict";
-// Regexps to match html elements
-
-
-
-var attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
-
-var unquoted      = '[^"\'=<>`\\x00-\\x20]+';
-var single_quoted = "'[^']*'";
-var double_quoted = '"[^"]*"';
-
-var attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';
-
-var attribute   = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)';
-
-var open_tag    = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
-
-var close_tag   = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
-var comment     = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
-var processing  = '<[?][\\s\\S]*?[?]>';
-var declaration = '<![A-Z]+\\s+[^>]*>';
-var cdata       = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
-
-var HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
-                        '|' + processing + '|' + declaration + '|' + cdata + ')');
-var HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');
-
-module.exports.n = HTML_TAG_RE;
-module.exports.q = HTML_OPEN_CLOSE_TAG_RE;
-
-
-/***/ }),
-
-/***/ 7022:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-// Utilities
-//
-
-
-
-function _class(obj) { return Object.prototype.toString.call(obj); }
-
-function isString(obj) { return _class(obj) === '[object String]'; }
-
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-function has(object, key) {
-  return _hasOwnProperty.call(object, key);
-}
-
-// Merge objects
-//
-function assign(obj /*from1, from2, from3, ...*/) {
-  var sources = Array.prototype.slice.call(arguments, 1);
-
-  sources.forEach(function (source) {
-    if (!source) { return; }
-
-    if (typeof source !== 'object') {
-      throw new TypeError(source + 'must be object');
-    }
-
-    Object.keys(source).forEach(function (key) {
-      obj[key] = source[key];
-    });
-  });
-
-  return obj;
-}
+// Merge objects
+//
+function assign(obj /* from1, from2, from3, ... */) {
+  const sources = Array.prototype.slice.call(arguments, 1);
+  sources.forEach(function (source) {
+    if (!source) {
+      return;
+    }
+    if (typeof source !== 'object') {
+      throw new TypeError(source + 'must be object');
+    }
+    Object.keys(source).forEach(function (key) {
+      obj[key] = source[key];
+    });
+  });
+  return obj;
+}
 
 // Remove element from array and put another array at those position.
 // Useful for some operations with tokens
 function arrayReplaceAt(src, pos, newElements) {
   return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
 function isValidEntityCode(c) {
-  /*eslint no-bitwise:0*/
+  /* eslint no-bitwise:0 */
   // broken sequence
-  if (c >= 0xD800 && c <= 0xDFFF) { return false; }
+  if (c >= 0xD800 && c <= 0xDFFF) {
+    return false;
+  }
   // never used
-  if (c >= 0xFDD0 && c <= 0xFDEF) { return false; }
-  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; }
+  if (c >= 0xFDD0 && c <= 0xFDEF) {
+    return false;
+  }
+  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) {
+    return false;
+  }
   // control codes
-  if (c >= 0x00 && c <= 0x08) { return false; }
-  if (c === 0x0B) { return false; }
-  if (c >= 0x0E && c <= 0x1F) { return false; }
-  if (c >= 0x7F && c <= 0x9F) { return false; }
+  if (c >= 0x00 && c <= 0x08) {
+    return false;
+  }
+  if (c === 0x0B) {
+    return false;
+  }
+  if (c >= 0x0E && c <= 0x1F) {
+    return false;
+  }
+  if (c >= 0x7F && c <= 0x9F) {
+    return false;
+  }
   // out of range
-  if (c > 0x10FFFF) { return false; }
+  if (c > 0x10FFFF) {
+    return false;
+  }
   return true;
 }
-
 function fromCodePoint(c) {
-  /*eslint no-bitwise:0*/
+  /* eslint no-bitwise:0 */
   if (c > 0xffff) {
     c -= 0x10000;
-    var surrogate1 = 0xd800 + (c >> 10),
-        surrogate2 = 0xdc00 + (c & 0x3ff);
-
+    const surrogate1 = 0xd800 + (c >> 10);
+    const surrogate2 = 0xdc00 + (c & 0x3ff);
     return String.fromCharCode(surrogate1, surrogate2);
   }
   return String.fromCharCode(c);
 }
-
-
-var UNESCAPE_MD_RE  = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
-var ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi;
-var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');
-
-var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;
-
-var entities = __webpack_require__(6233);
-
+const UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+const ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
+const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');
+const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
 function replaceEntityPattern(match, name) {
-  var code = 0;
-
-  if (has(entities, name)) {
-    return entities[name];
-  }
-
-  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {
-    code = name[1].toLowerCase() === 'x' ?
-      parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
-
+  if (name.charCodeAt(0) === 0x23 /* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {
+    const code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
     if (isValidEntityCode(code)) {
       return fromCodePoint(code);
     }
+    return match;
+  }
+  const decoded = entities.decodeHTML(match);
+  if (decoded !== match) {
+    return decoded;
   }
-
   return match;
 }
 
-/*function replaceEntities(str) {
+/* function replaceEntities(str) {
   if (str.indexOf('&') < 0) { return str; }
 
   return str.replace(ENTITY_RE, replaceEntityPattern);
-}*/
+} */
 
 function unescapeMd(str) {
-  if (str.indexOf('\\') < 0) { return str; }
+  if (str.indexOf('\\') < 0) {
+    return str;
+  }
   return str.replace(UNESCAPE_MD_RE, '$1');
 }
-
 function unescapeAll(str) {
-  if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) { return str; }
-
+  if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) {
+    return str;
+  }
   return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {
-    if (escaped) { return escaped; }
+    if (escaped) {
+      return escaped;
+    }
     return replaceEntityPattern(match, entity);
   });
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-var HTML_ESCAPE_TEST_RE = /[&<>"]/;
-var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
-var HTML_REPLACEMENTS = {
+const HTML_ESCAPE_TEST_RE = /[&<>"]/;
+const HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
+const HTML_REPLACEMENTS = {
   '&': '&amp;',
   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;'
 };
-
 function replaceUnsafeChar(ch) {
   return HTML_REPLACEMENTS[ch];
 }
-
 function escapeHtml(str) {
   if (HTML_ESCAPE_TEST_RE.test(str)) {
     return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
   }
   return str;
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
-
+const REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
 function escapeRE(str) {
   return str.replace(REGEXP_ESCAPE_RE, '\\$&');
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
 function isSpace(code) {
   switch (code) {
     case 0x09:
@@ -13596,7 +14496,9 @@ function isSpace(code) {
 
 // Zs (unicode class) || [\t\f\v\r\n]
 function isWhiteSpace(code) {
-  if (code >= 0x2000 && code <= 0x200A) { return true; }
+  if (code >= 0x2000 && code <= 0x200A) {
+    return true;
+  }
   switch (code) {
     case 0x09: // \t
     case 0x0A: // \n
@@ -13614,17 +14516,13 @@ function isWhiteSpace(code) {
   return false;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-/*eslint-disable max-len*/
-var UNICODE_PUNCT_RE = __webpack_require__(3189);
+/* eslint-disable max-len */
 
 // Currently without astral characters support.
 function isPunctChar(ch) {
-  return UNICODE_PUNCT_RE.test(ch);
+  return ucmicro__namespace.P.test(ch) || ucmicro__namespace.S.test(ch);
 }
 
-
 // Markdown ASCII punctuation characters.
 //
 // !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
@@ -13634,38 +14532,38 @@ function isPunctChar(ch) {
 //
 function isMdAsciiPunct(ch) {
   switch (ch) {
-    case 0x21/* ! */:
-    case 0x22/* " */:
-    case 0x23/* # */:
-    case 0x24/* $ */:
-    case 0x25/* % */:
-    case 0x26/* & */:
-    case 0x27/* ' */:
-    case 0x28/* ( */:
-    case 0x29/* ) */:
-    case 0x2A/* * */:
-    case 0x2B/* + */:
-    case 0x2C/* , */:
-    case 0x2D/* - */:
-    case 0x2E/* . */:
-    case 0x2F/* / */:
-    case 0x3A/* : */:
-    case 0x3B/* ; */:
-    case 0x3C/* < */:
-    case 0x3D/* = */:
-    case 0x3E/* > */:
-    case 0x3F/* ? */:
-    case 0x40/* @ */:
-    case 0x5B/* [ */:
-    case 0x5C/* \ */:
-    case 0x5D/* ] */:
-    case 0x5E/* ^ */:
-    case 0x5F/* _ */:
-    case 0x60/* ` */:
-    case 0x7B/* { */:
-    case 0x7C/* | */:
-    case 0x7D/* } */:
-    case 0x7E/* ~ */:
+    case 0x21 /* ! */:
+    case 0x22 /* " */:
+    case 0x23 /* # */:
+    case 0x24 /* $ */:
+    case 0x25 /* % */:
+    case 0x26 /* & */:
+    case 0x27 /* ' */:
+    case 0x28 /* ( */:
+    case 0x29 /* ) */:
+    case 0x2A /* * */:
+    case 0x2B /* + */:
+    case 0x2C /* , */:
+    case 0x2D /* - */:
+    case 0x2E /* . */:
+    case 0x2F /* / */:
+    case 0x3A /* : */:
+    case 0x3B /* ; */:
+    case 0x3C /* < */:
+    case 0x3D /* = */:
+    case 0x3E /* > */:
+    case 0x3F /* ? */:
+    case 0x40 /* @ */:
+    case 0x5B /* [ */:
+    case 0x5C /* \ */:
+    case 0x5D /* ] */:
+    case 0x5E /* ^ */:
+    case 0x5F /* _ */:
+    case 0x60 /* ` */:
+    case 0x7B /* { */:
+    case 0x7C /* | */:
+    case 0x7D /* } */:
+    case 0x7E /* ~ */:
       return true;
     default:
       return false;
@@ -13724,80 +14622,99 @@ function normalizeReference(str) {
   return str.toLowerCase().toUpperCase();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Re-export libraries commonly used in both markdown-it and its plugins,
 // so plugins won't have to depend on them explicitly, which reduces their
 // bundled size (e.g. a browser build).
 //
-exports.lib                 = {};
-exports.lib.mdurl = __webpack_require__(8765);
-exports.lib.ucmicro = __webpack_require__(4205);
-
-exports.assign              = assign;
-exports.isString            = isString;
-exports.has                 = has;
-exports.unescapeMd          = unescapeMd;
-exports.unescapeAll         = unescapeAll;
-exports.isValidEntityCode   = isValidEntityCode;
-exports.fromCodePoint       = fromCodePoint;
-// exports.replaceEntities     = replaceEntities;
-exports.escapeHtml          = escapeHtml;
-exports.arrayReplaceAt      = arrayReplaceAt;
-exports.isSpace             = isSpace;
-exports.isWhiteSpace        = isWhiteSpace;
-exports.isMdAsciiPunct      = isMdAsciiPunct;
-exports.isPunctChar         = isPunctChar;
-exports.escapeRE            = escapeRE;
-exports.normalizeReference  = normalizeReference;
-
-
-/***/ }),
-
-/***/ 1685:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-// Just a shortcut for bulk export
-
-
-
-exports.parseLinkLabel = __webpack_require__(3595);
-exports.parseLinkDestination = __webpack_require__(2548);
-exports.parseLinkTitle = __webpack_require__(8040);
-
-
-/***/ }),
-
-/***/ 2548:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+const lib = {
+  mdurl: mdurl__namespace,
+  ucmicro: ucmicro__namespace
+};
+
+var utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  arrayReplaceAt: arrayReplaceAt,
+  assign: assign,
+  escapeHtml: escapeHtml,
+  escapeRE: escapeRE,
+  fromCodePoint: fromCodePoint,
+  has: has,
+  isMdAsciiPunct: isMdAsciiPunct,
+  isPunctChar: isPunctChar,
+  isSpace: isSpace,
+  isString: isString,
+  isValidEntityCode: isValidEntityCode,
+  isWhiteSpace: isWhiteSpace,
+  lib: lib,
+  normalizeReference: normalizeReference,
+  unescapeAll: unescapeAll,
+  unescapeMd: unescapeMd
+});
 
-"use strict";
-// Parse link destination
+// Parse link label
+//
+// this function assumes that first character ("[") already matches;
+// returns the end of the label
 //
 
+function parseLinkLabel(state, start, disableNested) {
+  let level, found, marker, prevPos;
+  const max = state.posMax;
+  const oldPos = state.pos;
+  state.pos = start + 1;
+  level = 1;
+  while (state.pos < max) {
+    marker = state.src.charCodeAt(state.pos);
+    if (marker === 0x5D /* ] */) {
+      level--;
+      if (level === 0) {
+        found = true;
+        break;
+      }
+    }
+    prevPos = state.pos;
+    state.md.inline.skipToken(state);
+    if (marker === 0x5B /* [ */) {
+      if (prevPos === state.pos - 1) {
+        // increase level if we find text `[`, which is not a part of any token
+        level++;
+      } else if (disableNested) {
+        state.pos = oldPos;
+        return -1;
+      }
+    }
+  }
+  let labelEnd = -1;
+  if (found) {
+    labelEnd = state.pos;
+  }
 
+  // restore old state
+  state.pos = oldPos;
+  return labelEnd;
+}
 
-var unescapeAll = (__webpack_require__(7022).unescapeAll);
-
-
-module.exports = function parseLinkDestination(str, pos, max) {
-  var code, level,
-      lines = 0,
-      start = pos,
-      result = {
-        ok: false,
-        pos: 0,
-        lines: 0,
-        str: ''
-      };
+// Parse link destination
+//
 
+function parseLinkDestination(str, start, max) {
+  let code;
+  let pos = start;
+  const result = {
+    ok: false,
+    pos: 0,
+    str: ''
+  };
   if (str.charCodeAt(pos) === 0x3C /* < */) {
     pos++;
     while (pos < max) {
       code = str.charCodeAt(pos);
-      if (code === 0x0A /* \n */) { return result; }
-      if (code === 0x3C /* < */) { return result; }
+      if (code === 0x0A /* \n */) {
+        return result;
+      }
+      if (code === 0x3C /* < */) {
+        return result;
+      }
       if (code === 0x3E /* > */) {
         result.pos = pos + 1;
         result.str = unescapeAll(str.slice(start + 1, pos));
@@ -13808,7 +14725,6 @@ module.exports = function parseLinkDestination(str, pos, max) {
         pos += 2;
         continue;
       }
-
       pos++;
     }
 
@@ -13818,890 +14734,1412 @@ module.exports = function parseLinkDestination(str, pos, max) {
 
   // this should be ... } else { ... branch
 
-  level = 0;
+  let level = 0;
   while (pos < max) {
     code = str.charCodeAt(pos);
-
-    if (code === 0x20) { break; }
+    if (code === 0x20) {
+      break;
+    }
 
     // ascii control characters
-    if (code < 0x20 || code === 0x7F) { break; }
-
+    if (code < 0x20 || code === 0x7F) {
+      break;
+    }
     if (code === 0x5C /* \ */ && pos + 1 < max) {
-      if (str.charCodeAt(pos + 1) === 0x20) { break; }
+      if (str.charCodeAt(pos + 1) === 0x20) {
+        break;
+      }
       pos += 2;
       continue;
     }
-
     if (code === 0x28 /* ( */) {
       level++;
-      if (level > 32) { return result; }
+      if (level > 32) {
+        return result;
+      }
     }
-
     if (code === 0x29 /* ) */) {
-      if (level === 0) { break; }
+      if (level === 0) {
+        break;
+      }
       level--;
     }
-
     pos++;
   }
-
-  if (start === pos) { return result; }
-  if (level !== 0) { return result; }
-
+  if (start === pos) {
+    return result;
+  }
+  if (level !== 0) {
+    return result;
+  }
   result.str = unescapeAll(str.slice(start, pos));
-  result.lines = lines;
   result.pos = pos;
   result.ok = true;
   return result;
-};
-
-
-/***/ }),
-
-/***/ 3595:
-/***/ ((module) => {
+}
 
-"use strict";
-// Parse link label
-//
-// this function assumes that first character ("[") already matches;
-// returns the end of the label
+// Parse link title
 //
 
 
-module.exports = function parseLinkLabel(state, start, disableNested) {
-  var level, found, marker, prevPos,
-      labelEnd = -1,
-      max = state.posMax,
-      oldPos = state.pos;
-
-  state.pos = start + 1;
-  level = 1;
-
-  while (state.pos < max) {
-    marker = state.src.charCodeAt(state.pos);
-    if (marker === 0x5D /* ] */) {
-      level--;
-      if (level === 0) {
-        found = true;
-        break;
-      }
+// Parse link title within `str` in [start, max] range,
+// or continue previous parsing if `prev_state` is defined (equal to result of last execution).
+//
+function parseLinkTitle(str, start, max, prev_state) {
+  let code;
+  let pos = start;
+  const state = {
+    // if `true`, this is a valid link title
+    ok: false,
+    // if `true`, this link can be continued on the next line
+    can_continue: false,
+    // if `ok`, it's the position of the first character after the closing marker
+    pos: 0,
+    // if `ok`, it's the unescaped title
+    str: '',
+    // expected closing marker character code
+    marker: 0
+  };
+  if (prev_state) {
+    // this is a continuation of a previous parseLinkTitle call on the next line,
+    // used in reference links only
+    state.str = prev_state.str;
+    state.marker = prev_state.marker;
+  } else {
+    if (pos >= max) {
+      return state;
     }
-
-    prevPos = state.pos;
-    state.md.inline.skipToken(state);
-    if (marker === 0x5B /* [ */) {
-      if (prevPos === state.pos - 1) {
-        // increase level if we find text `[`, which is not a part of any token
-        level++;
-      } else if (disableNested) {
-        state.pos = oldPos;
-        return -1;
-      }
+    let marker = str.charCodeAt(pos);
+    if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) {
+      return state;
     }
-  }
+    start++;
+    pos++;
 
-  if (found) {
-    labelEnd = state.pos;
+    // if opening marker is "(", switch it to closing marker ")"
+    if (marker === 0x28) {
+      marker = 0x29;
+    }
+    state.marker = marker;
   }
-
-  // restore old state
-  state.pos = oldPos;
-
-  return labelEnd;
-};
-
-
-/***/ }),
-
-/***/ 8040:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Parse link title
-//
-
-
-
-var unescapeAll = (__webpack_require__(7022).unescapeAll);
-
-
-module.exports = function parseLinkTitle(str, pos, max) {
-  var code,
-      marker,
-      lines = 0,
-      start = pos,
-      result = {
-        ok: false,
-        pos: 0,
-        lines: 0,
-        str: ''
-      };
-
-  if (pos >= max) { return result; }
-
-  marker = str.charCodeAt(pos);
-
-  if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return result; }
-
-  pos++;
-
-  // if opening marker is "(", switch it to closing marker ")"
-  if (marker === 0x28) { marker = 0x29; }
-
   while (pos < max) {
     code = str.charCodeAt(pos);
-    if (code === marker) {
-      result.pos = pos + 1;
-      result.lines = lines;
-      result.str = unescapeAll(str.slice(start + 1, pos));
-      result.ok = true;
-      return result;
-    } else if (code === 0x28 /* ( */ && marker === 0x29 /* ) */) {
-      return result;
-    } else if (code === 0x0A) {
-      lines++;
+    if (code === state.marker) {
+      state.pos = pos + 1;
+      state.str += unescapeAll(str.slice(start, pos));
+      state.ok = true;
+      return state;
+    } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {
+      return state;
     } else if (code === 0x5C /* \ */ && pos + 1 < max) {
       pos++;
-      if (str.charCodeAt(pos) === 0x0A) {
-        lines++;
-      }
     }
-
     pos++;
   }
 
-  return result;
-};
-
-
-/***/ }),
-
-/***/ 7024:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Main parser class
+  // no closing marker found, but this link title may continue on the next line (for references)
+  state.can_continue = true;
+  state.str += unescapeAll(str.slice(start, pos));
+  return state;
+}
 
+// Just a shortcut for bulk export
 
+var helpers = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  parseLinkDestination: parseLinkDestination,
+  parseLinkLabel: parseLinkLabel,
+  parseLinkTitle: parseLinkTitle
+});
 
+/**
+ * class Renderer
+ *
+ * Generates HTML from parsed token stream. Each instance has independent
+ * copy of rules. Those can be rewritten with ease. Also, you can add new
+ * rules if you create plugin and adds new token types.
+ **/
 
-var utils        = __webpack_require__(7022);
-var helpers      = __webpack_require__(1685);
-var Renderer     = __webpack_require__(7529);
-var ParserCore   = __webpack_require__(7346);
-var ParserBlock  = __webpack_require__(2471);
-var ParserInline = __webpack_require__(4485);
-var LinkifyIt    = __webpack_require__(8337);
-var mdurl        = __webpack_require__(8765);
-var punycode     = __webpack_require__(3689);
+const default_rules = {};
+default_rules.code_inline = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx];
+  return '<code' + slf.renderAttrs(token) + '>' + escapeHtml(token.content) + '</code>';
+};
+default_rules.code_block = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx];
+  return '<pre' + slf.renderAttrs(token) + '><code>' + escapeHtml(tokens[idx].content) + '</code></pre>\n';
+};
+default_rules.fence = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx];
+  const info = token.info ? unescapeAll(token.info).trim() : '';
+  let langName = '';
+  let langAttrs = '';
+  if (info) {
+    const arr = info.split(/(\s+)/g);
+    langName = arr[0];
+    langAttrs = arr.slice(2).join('');
+  }
+  let highlighted;
+  if (options.highlight) {
+    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
+  } else {
+    highlighted = escapeHtml(token.content);
+  }
+  if (highlighted.indexOf('<pre') === 0) {
+    return highlighted + '\n';
+  }
 
+  // If language exists, inject class gently, without modifying original token.
+  // May be, one day we will add .deepClone() for token and simplify this part, but
+  // now we prefer to keep things local.
+  if (info) {
+    const i = token.attrIndex('class');
+    const tmpAttrs = token.attrs ? token.attrs.slice() : [];
+    if (i < 0) {
+      tmpAttrs.push(['class', options.langPrefix + langName]);
+    } else {
+      tmpAttrs[i] = tmpAttrs[i].slice();
+      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;
+    }
 
-var config = {
-  default: __webpack_require__(4218),
-  zero: __webpack_require__(873),
-  commonmark: __webpack_require__(6895)
+    // Fake token just to render attributes
+    const tmpToken = {
+      attrs: tmpAttrs
+    };
+    return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`;
+  }
+  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\n`;
 };
+default_rules.image = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx];
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// This validator can prohibit more than really needed to prevent XSS. It's a
-// tradeoff to keep code simple and to be secure by default.
-//
-// If you need different setup - override validator method as you wish. Or
-// replace it with dummy function and use external sanitizer.
-//
-
-var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
-var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
+  // "alt" attr MUST be set, even if empty. Because it's mandatory and
+  // should be placed on proper position for tests.
+  //
+  // Replace content with actual value
 
-function validateLink(url) {
-  // url should be normalized at this point, and existing entities are decoded
-  var str = url.trim().toLowerCase();
+  token.attrs[token.attrIndex('alt')][1] = slf.renderInlineAsText(token.children, options, env);
+  return slf.renderToken(tokens, idx, options);
+};
+default_rules.hardbreak = function (tokens, idx, options /*, env */) {
+  return options.xhtmlOut ? '<br />\n' : '<br>\n';
+};
+default_rules.softbreak = function (tokens, idx, options /*, env */) {
+  return options.breaks ? options.xhtmlOut ? '<br />\n' : '<br>\n' : '\n';
+};
+default_rules.text = function (tokens, idx /*, options, env */) {
+  return escapeHtml(tokens[idx].content);
+};
+default_rules.html_block = function (tokens, idx /*, options, env */) {
+  return tokens[idx].content;
+};
+default_rules.html_inline = function (tokens, idx /*, options, env */) {
+  return tokens[idx].content;
+};
 
-  return BAD_PROTO_RE.test(str) ? (GOOD_DATA_RE.test(str) ? true : false) : true;
+/**
+ * new Renderer()
+ *
+ * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
+ **/
+function Renderer() {
+  /**
+   * Renderer#rules -> Object
+   *
+   * Contains render rules for tokens. Can be updated and extended.
+   *
+   * ##### Example
+   *
+   * ```javascript
+   * var md = require('markdown-it')();
+   *
+   * md.renderer.rules.strong_open  = function () { return '<b>'; };
+   * md.renderer.rules.strong_close = function () { return '</b>'; };
+   *
+   * var result = md.renderInline(...);
+   * ```
+   *
+   * Each rule is called as independent static function with fixed signature:
+   *
+   * ```javascript
+   * function my_token_render(tokens, idx, options, env, renderer) {
+   *   // ...
+   *   return renderedHTML;
+   * }
+   * ```
+   *
+   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
+   * for more details and examples.
+   **/
+  this.rules = assign({}, default_rules);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-
-var RECODE_HOSTNAME_FOR = [ 'http:', 'https:', 'mailto:' ];
+/**
+ * Renderer.renderAttrs(token) -> String
+ *
+ * Render token attributes to string.
+ **/
+Renderer.prototype.renderAttrs = function renderAttrs(token) {
+  let i, l, result;
+  if (!token.attrs) {
+    return '';
+  }
+  result = '';
+  for (i = 0, l = token.attrs.length; i < l; i++) {
+    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
+  }
+  return result;
+};
 
-function normalizeLink(url) {
-  var parsed = mdurl.parse(url, true);
+/**
+ * Renderer.renderToken(tokens, idx, options) -> String
+ * - tokens (Array): list of tokens
+ * - idx (Numbed): token index to render
+ * - options (Object): params of parser instance
+ *
+ * Default token renderer. Can be overriden by custom function
+ * in [[Renderer#rules]].
+ **/
+Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
+  const token = tokens[idx];
+  let result = '';
 
-  if (parsed.hostname) {
-    // Encode hostnames in urls like:
-    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-    //
-    // We don't encode unknown schemas, because it's likely that we encode
-    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-    //
-    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
-      try {
-        parsed.hostname = punycode.toASCII(parsed.hostname);
-      } catch (er) { /**/ }
+  // Tight list paragraphs
+  if (token.hidden) {
+    return '';
+  }
+
+  // Insert a newline between hidden paragraph and subsequent opening
+  // block-level tag.
+  //
+  // For example, here we should insert a newline before blockquote:
+  //  - a
+  //    >
+  //
+  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
+    result += '\n';
+  }
+
+  // Add token name, e.g. `<img`
+  result += (token.nesting === -1 ? '</' : '<') + token.tag;
+
+  // Encode attributes, e.g. `<img src="foo"`
+  result += this.renderAttrs(token);
+
+  // Add a slash for self-closing tags, e.g. `<img src="foo" /`
+  if (token.nesting === 0 && options.xhtmlOut) {
+    result += ' /';
+  }
+
+  // Check if we need to add a newline after this tag
+  let needLf = false;
+  if (token.block) {
+    needLf = true;
+    if (token.nesting === 1) {
+      if (idx + 1 < tokens.length) {
+        const nextToken = tokens[idx + 1];
+        if (nextToken.type === 'inline' || nextToken.hidden) {
+          // Block-level tag containing an inline tag.
+          //
+          needLf = false;
+        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
+          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
+          //
+          needLf = false;
+        }
+      }
     }
   }
+  result += needLf ? '>\n' : '>';
+  return result;
+};
 
-  return mdurl.encode(mdurl.format(parsed));
-}
+/**
+ * Renderer.renderInline(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * The same as [[Renderer.render]], but for single token of `inline` type.
+ **/
+Renderer.prototype.renderInline = function (tokens, options, env) {
+  let result = '';
+  const rules = this.rules;
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    const type = tokens[i].type;
+    if (typeof rules[type] !== 'undefined') {
+      result += rules[type](tokens, i, options, env, this);
+    } else {
+      result += this.renderToken(tokens, i, options);
+    }
+  }
+  return result;
+};
 
-function normalizeLinkText(url) {
-  var parsed = mdurl.parse(url, true);
+/** internal
+ * Renderer.renderInlineAsText(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * Special kludge for image `alt` attributes to conform CommonMark spec.
+ * Don't try to use it! Spec requires to show `alt` content with stripped markup,
+ * instead of simple escaping.
+ **/
+Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
+  let result = '';
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    switch (tokens[i].type) {
+      case 'text':
+        result += tokens[i].content;
+        break;
+      case 'image':
+        result += this.renderInlineAsText(tokens[i].children, options, env);
+        break;
+      case 'html_inline':
+      case 'html_block':
+        result += tokens[i].content;
+        break;
+      case 'softbreak':
+      case 'hardbreak':
+        result += '\n';
+        break;
+      // all other tokens are skipped
+    }
+  }
+  return result;
+};
 
-  if (parsed.hostname) {
-    // Encode hostnames in urls like:
-    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-    //
-    // We don't encode unknown schemas, because it's likely that we encode
-    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-    //
-    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
-      try {
-        parsed.hostname = punycode.toUnicode(parsed.hostname);
-      } catch (er) { /**/ }
+/**
+ * Renderer.render(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * Takes token stream and generates HTML. Probably, you will never need to call
+ * this method directly.
+ **/
+Renderer.prototype.render = function (tokens, options, env) {
+  let result = '';
+  const rules = this.rules;
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    const type = tokens[i].type;
+    if (type === 'inline') {
+      result += this.renderInline(tokens[i].children, options, env);
+    } else if (typeof rules[type] !== 'undefined') {
+      result += rules[type](tokens, i, options, env, this);
+    } else {
+      result += this.renderToken(tokens, i, options, env);
     }
   }
+  return result;
+};
 
-  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
-  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%');
+/**
+ * class Ruler
+ *
+ * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
+ * [[MarkdownIt#inline]] to manage sequences of functions (rules):
+ *
+ * - keep rules in defined order
+ * - assign the name to each rule
+ * - enable/disable rules
+ * - add/replace rules
+ * - allow assign rules to additional named chains (in the same)
+ * - cacheing lists of active rules
+ *
+ * You will not need use this class directly until write plugins. For simple
+ * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
+ * [[MarkdownIt.use]].
+ **/
+
+/**
+ * new Ruler()
+ **/
+function Ruler() {
+  // List of added rules. Each element is:
+  //
+  // {
+  //   name: XXX,
+  //   enabled: Boolean,
+  //   fn: Function(),
+  //   alt: [ name2, name3 ]
+  // }
+  //
+  this.__rules__ = [];
+
+  // Cached rule chains.
+  //
+  // First level - chain name, '' for default.
+  // Second level - diginal anchor for fast filtering by charcodes.
+  //
+  this.__cache__ = null;
 }
 
+// Helper methods, should not be used directly
+
+// Find rule index by name
+//
+Ruler.prototype.__find__ = function (name) {
+  for (let i = 0; i < this.__rules__.length; i++) {
+    if (this.__rules__[i].name === name) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+// Build rules lookup cache
+//
+Ruler.prototype.__compile__ = function () {
+  const self = this;
+  const chains = [''];
+
+  // collect unique names
+  self.__rules__.forEach(function (rule) {
+    if (!rule.enabled) {
+      return;
+    }
+    rule.alt.forEach(function (altName) {
+      if (chains.indexOf(altName) < 0) {
+        chains.push(altName);
+      }
+    });
+  });
+  self.__cache__ = {};
+  chains.forEach(function (chain) {
+    self.__cache__[chain] = [];
+    self.__rules__.forEach(function (rule) {
+      if (!rule.enabled) {
+        return;
+      }
+      if (chain && rule.alt.indexOf(chain) < 0) {
+        return;
+      }
+      self.__cache__[chain].push(rule.fn);
+    });
+  });
+};
 
 /**
- * class MarkdownIt
- *
- * Main parser/renderer class.
+ * Ruler.at(name, fn [, options])
+ * - name (String): rule name to replace.
+ * - fn (Function): new rule function.
+ * - options (Object): new rule options (not mandatory).
  *
- * ##### Usage
+ * Replace rule by name with new function & options. Throws error if name not
+ * found.
  *
- * ```javascript
- * // node.js, "classic" way:
- * var MarkdownIt = require('markdown-it'),
- *     md = new MarkdownIt();
- * var result = md.render('# markdown-it rulezz!');
+ * ##### Options:
  *
- * // node.js, the same, but with sugar:
- * var md = require('markdown-it')();
- * var result = md.render('# markdown-it rulezz!');
+ * - __alt__ - array with names of "alternate" chains.
  *
- * // browser without AMD, added to "window" on script load
- * // Note, there are no dash.
- * var md = window.markdownit();
- * var result = md.render('# markdown-it rulezz!');
- * ```
+ * ##### Example
  *
- * Single line rendering, without paragraph wrap:
+ * Replace existing typographer replacement rule with new one:
  *
  * ```javascript
  * var md = require('markdown-it')();
- * var result = md.renderInline('__markdown-it__ rulezz!');
+ *
+ * md.core.ruler.at('replacements', function replace(state) {
+ *   //...
+ * });
  * ```
  **/
-
+Ruler.prototype.at = function (name, fn, options) {
+  const index = this.__find__(name);
+  const opt = options || {};
+  if (index === -1) {
+    throw new Error('Parser rule not found: ' + name);
+  }
+  this.__rules__[index].fn = fn;
+  this.__rules__[index].alt = opt.alt || [];
+  this.__cache__ = null;
+};
+
 /**
- * new MarkdownIt([presetName, options])
- * - presetName (String): optional, `commonmark` / `zero`
- * - options (Object)
+ * Ruler.before(beforeName, ruleName, fn [, options])
+ * - beforeName (String): new rule will be added before this one.
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
  *
- * Creates parser instanse with given config. Can be called without `new`.
+ * Add new rule to chain before one with given name. See also
+ * [[Ruler.after]], [[Ruler.push]].
  *
- * ##### presetName
+ * ##### Options:
  *
- * MarkdownIt provides named presets as a convenience to quickly
- * enable/disable active syntax rules and options for common use cases.
+ * - __alt__ - array with names of "alternate" chains.
  *
- * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
- *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
- * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
- *   similar to GFM, used when no preset name given. Enables all available rules,
- *   but still without html, typographer & autolinker.
- * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
- *   all rules disabled. Useful to quickly setup your config via `.enable()`.
- *   For example, when you need only `bold` and `italic` markup and nothing else.
+ * ##### Example
  *
- * ##### options:
+ * ```javascript
+ * var md = require('markdown-it')();
  *
- * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
- *   That's not safe! You may need external sanitizer to protect output from XSS.
- *   It's better to extend features via plugins, instead of enabling HTML.
- * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
- *   (`<br />`). This is needed only for full CommonMark compatibility. In real
- *   world you will need HTML output.
- * - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
- * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
- *   Can be useful for external highlighters.
- * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
- * - __typographer__  - `false`. Set `true` to enable [some language-neutral
- *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
- *   quotes beautification (smartquotes).
- * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
- *   pairs, when typographer enabled and smartquotes on. For example, you can
- *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and
- *   `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
- * - __highlight__ - `null`. Highlighter function for fenced code blocks.
- *   Highlighter `function (str, lang)` should return escaped HTML. It can also
- *   return empty string if the source was not changed and should be escaped
- *   externaly. If result starts with <pre... internal wrapper is skipped.
+ * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+ *   //...
+ * });
+ * ```
+ **/
+Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
+  const index = this.__find__(beforeName);
+  const opt = options || {};
+  if (index === -1) {
+    throw new Error('Parser rule not found: ' + beforeName);
+  }
+  this.__rules__.splice(index, 0, {
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  });
+  this.__cache__ = null;
+};
+
+/**
+ * Ruler.after(afterName, ruleName, fn [, options])
+ * - afterName (String): new rule will be added after this one.
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
+ *
+ * Add new rule to chain after one with given name. See also
+ * [[Ruler.before]], [[Ruler.push]].
+ *
+ * ##### Options:
+ *
+ * - __alt__ - array with names of "alternate" chains.
  *
  * ##### Example
  *
  * ```javascript
- * // commonmark mode
- * var md = require('markdown-it')('commonmark');
- *
- * // default mode
  * var md = require('markdown-it')();
  *
- * // enable everything
- * var md = require('markdown-it')({
- *   html: true,
- *   linkify: true,
- *   typographer: true
+ * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+ *   //...
  * });
  * ```
+ **/
+Ruler.prototype.after = function (afterName, ruleName, fn, options) {
+  const index = this.__find__(afterName);
+  const opt = options || {};
+  if (index === -1) {
+    throw new Error('Parser rule not found: ' + afterName);
+  }
+  this.__rules__.splice(index + 1, 0, {
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  });
+  this.__cache__ = null;
+};
+
+/**
+ * Ruler.push(ruleName, fn [, options])
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
  *
- * ##### Syntax highlighting
+ * Push new rule to the end of chain. See also
+ * [[Ruler.before]], [[Ruler.after]].
  *
- * ```js
- * var hljs = require('highlight.js') // https://highlightjs.org/
+ * ##### Options:
  *
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;
- *       } catch (__) {}
- *     }
+ * - __alt__ - array with names of "alternate" chains.
  *
- *     return ''; // use external default escaping
- *   }
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ *
+ * md.core.ruler.push('my_rule', function replace(state) {
+ *   //...
  * });
  * ```
+ **/
+Ruler.prototype.push = function (ruleName, fn, options) {
+  const opt = options || {};
+  this.__rules__.push({
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  });
+  this.__cache__ = null;
+};
+
+/**
+ * Ruler.enable(list [, ignoreInvalid]) -> Array
+ * - list (String|Array): list of rule names to enable.
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
  *
- * Or with full wrapper override (if you need assign class to `<pre>`):
+ * Enable rules with given names. If any rule name not found - throw Error.
+ * Errors can be disabled by second param.
  *
- * ```javascript
- * var hljs = require('highlight.js') // https://highlightjs.org/
+ * Returns list of found rule names (if no exception happened).
  *
- * // Actual default values
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return '<pre class="hljs"><code>' +
- *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
- *                '</code></pre>';
- *       } catch (__) {}
- *     }
+ * See also [[Ruler.disable]], [[Ruler.enableOnly]].
+ **/
+Ruler.prototype.enable = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) {
+    list = [list];
+  }
+  const result = [];
+
+  // Search by name and enable
+  list.forEach(function (name) {
+    const idx = this.__find__(name);
+    if (idx < 0) {
+      if (ignoreInvalid) {
+        return;
+      }
+      throw new Error('Rules manager: invalid rule name ' + name);
+    }
+    this.__rules__[idx].enabled = true;
+    result.push(name);
+  }, this);
+  this.__cache__ = null;
+  return result;
+};
+
+/**
+ * Ruler.enableOnly(list [, ignoreInvalid])
+ * - list (String|Array): list of rule names to enable (whitelist).
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
  *
- *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
- *   }
- * });
- * ```
+ * Enable rules with given names, and disable everything else. If any rule name
+ * not found - throw Error. Errors can be disabled by second param.
  *
+ * See also [[Ruler.disable]], [[Ruler.enable]].
  **/
-function MarkdownIt(presetName, options) {
-  if (!(this instanceof MarkdownIt)) {
-    return new MarkdownIt(presetName, options);
+Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) {
+    list = [list];
+  }
+  this.__rules__.forEach(function (rule) {
+    rule.enabled = false;
+  });
+  this.enable(list, ignoreInvalid);
+};
+
+/**
+ * Ruler.disable(list [, ignoreInvalid]) -> Array
+ * - list (String|Array): list of rule names to disable.
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * Disable rules with given names. If any rule name not found - throw Error.
+ * Errors can be disabled by second param.
+ *
+ * Returns list of found rule names (if no exception happened).
+ *
+ * See also [[Ruler.enable]], [[Ruler.enableOnly]].
+ **/
+Ruler.prototype.disable = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) {
+    list = [list];
   }
+  const result = [];
 
-  if (!options) {
-    if (!utils.isString(presetName)) {
-      options = presetName || {};
-      presetName = 'default';
+  // Search by name and disable
+  list.forEach(function (name) {
+    const idx = this.__find__(name);
+    if (idx < 0) {
+      if (ignoreInvalid) {
+        return;
+      }
+      throw new Error('Rules manager: invalid rule name ' + name);
     }
+    this.__rules__[idx].enabled = false;
+    result.push(name);
+  }, this);
+  this.__cache__ = null;
+  return result;
+};
+
+/**
+ * Ruler.getRules(chainName) -> Array
+ *
+ * Return array of active functions (rules) for given chain name. It analyzes
+ * rules configuration, compiles caches if not exists and returns result.
+ *
+ * Default chain name is `''` (empty string). It can't be skipped. That's
+ * done intentionally, to keep signature monomorphic for high speed.
+ **/
+Ruler.prototype.getRules = function (chainName) {
+  if (this.__cache__ === null) {
+    this.__compile__();
   }
 
-  /**
-   * MarkdownIt#inline -> ParserInline
-   *
-   * Instance of [[ParserInline]]. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
-   **/
-  this.inline = new ParserInline();
+  // Chain can be empty, if rules disabled. But we still have to return Array.
+  return this.__cache__[chainName] || [];
+};
 
-  /**
-   * MarkdownIt#block -> ParserBlock
-   *
-   * Instance of [[ParserBlock]]. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
-   **/
-  this.block = new ParserBlock();
+// Token class
 
-  /**
-   * MarkdownIt#core -> Core
+/**
+ * class Token
+ **/
+
+/**
+ * new Token(type, tag, nesting)
+ *
+ * Create new token and fill passed properties.
+ **/
+function Token(type, tag, nesting) {
+  /**
+   * Token#type -> String
    *
-   * Instance of [[Core]] chain executor. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
+   * Type of the token (string, e.g. "paragraph_open")
    **/
-  this.core = new ParserCore();
+  this.type = type;
 
   /**
-   * MarkdownIt#renderer -> Renderer
-   *
-   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
-   * rules for new token types, generated by plugins.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * function myToken(tokens, idx, options, env, self) {
-   *   //...
-   *   return result;
-   * };
-   *
-   * md.renderer.rules['my_token'] = myToken
-   * ```
+   * Token#tag -> String
    *
-   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
+   * html tag name, e.g. "p"
    **/
-  this.renderer = new Renderer();
+  this.tag = tag;
 
   /**
-   * MarkdownIt#linkify -> LinkifyIt
+   * Token#attrs -> Array
    *
-   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
-   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
-   * rule.
+   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
    **/
-  this.linkify = new LinkifyIt();
+  this.attrs = null;
 
   /**
-   * MarkdownIt#validateLink(url) -> Boolean
+   * Token#map -> Array
    *
-   * Link validation function. CommonMark allows too much in links. By default
-   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
-   * except some embedded image types.
+   * Source map info. Format: `[ line_begin, line_end ]`
+   **/
+  this.map = null;
+
+  /**
+   * Token#nesting -> Number
    *
-   * You can change this behaviour:
+   * Level change (number in {-1, 0, 1} set), where:
    *
-   * ```javascript
-   * var md = require('markdown-it')();
-   * // enable everything
-   * md.validateLink = function () { return true; }
-   * ```
+   * -  `1` means the tag is opening
+   * -  `0` means the tag is self-closing
+   * - `-1` means the tag is closing
    **/
-  this.validateLink = validateLink;
+  this.nesting = nesting;
 
   /**
-   * MarkdownIt#normalizeLink(url) -> String
+   * Token#level -> Number
    *
-   * Function used to encode link url to a machine-readable format,
-   * which includes url-encoding, punycode, etc.
+   * nesting level, the same as `state.level`
    **/
-  this.normalizeLink = normalizeLink;
+  this.level = 0;
 
   /**
-   * MarkdownIt#normalizeLinkText(url) -> String
+   * Token#children -> Array
    *
-   * Function used to decode link url to a human-readable format`
+   * An array of child nodes (inline and img tokens)
    **/
-  this.normalizeLinkText = normalizeLinkText;
-
+  this.children = null;
 
-  // Expose utils & helpers for easy acces from plugins
+  /**
+   * Token#content -> String
+   *
+   * In a case of self-closing tag (code, html, fence, etc.),
+   * it has contents of this tag.
+   **/
+  this.content = '';
 
   /**
-   * MarkdownIt#utils -> utils
+   * Token#markup -> String
    *
-   * Assorted utility functions, useful to write plugins. See details
-   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).
+   * '*' or '_' for emphasis, fence string for fence, etc.
    **/
-  this.utils = utils;
+  this.markup = '';
 
   /**
-   * MarkdownIt#helpers -> helpers
+   * Token#info -> String
    *
-   * Link components parser functions, useful to write plugins. See details
-   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
+   * Additional information:
+   *
+   * - Info string for "fence" tokens
+   * - The value "auto" for autolink "link_open" and "link_close" tokens
+   * - The string value of the item marker for ordered-list "list_item_open" tokens
    **/
-  this.helpers = utils.assign({}, helpers);
+  this.info = '';
 
+  /**
+   * Token#meta -> Object
+   *
+   * A place for plugins to store an arbitrary data
+   **/
+  this.meta = null;
 
-  this.options = {};
-  this.configure(presetName);
+  /**
+   * Token#block -> Boolean
+   *
+   * True for block-level tokens, false for inline tokens.
+   * Used in renderer to calculate line breaks
+   **/
+  this.block = false;
 
-  if (options) { this.set(options); }
+  /**
+   * Token#hidden -> Boolean
+   *
+   * If it's true, ignore this element when rendering. Used for tight lists
+   * to hide paragraphs.
+   **/
+  this.hidden = false;
 }
 
-
-/** chainable
- * MarkdownIt.set(options)
- *
- * Set parser options (in the same format as in constructor). Probably, you
- * will never need it, but you can change options after constructor call.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')()
- *             .set({ html: true, breaks: true })
- *             .set({ typographer, true });
- * ```
+/**
+ * Token.attrIndex(name) -> Number
  *
- * __Note:__ To achieve the best possible performance, don't modify a
- * `markdown-it` instance options on the fly. If you need multiple configurations
- * it's best to create multiple instances and initialize each with separate
- * config.
+ * Search attribute index by name.
  **/
-MarkdownIt.prototype.set = function (options) {
-  utils.assign(this.options, options);
-  return this;
+Token.prototype.attrIndex = function attrIndex(name) {
+  if (!this.attrs) {
+    return -1;
+  }
+  const attrs = this.attrs;
+  for (let i = 0, len = attrs.length; i < len; i++) {
+    if (attrs[i][0] === name) {
+      return i;
+    }
+  }
+  return -1;
 };
 
-
-/** chainable, internal
- * MarkdownIt.configure(presets)
- *
- * Batch load of all options and compenent settings. This is internal method,
- * and you probably will not need it. But if you will - see available presets
- * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
+/**
+ * Token.attrPush(attrData)
  *
- * We strongly recommend to use presets instead of direct config loads. That
- * will give better compatibility with next versions.
+ * Add `[ name, value ]` attribute to list. Init attrs if necessary
  **/
-MarkdownIt.prototype.configure = function (presets) {
-  var self = this, presetName;
-
-  if (utils.isString(presets)) {
-    presetName = presets;
-    presets = config[presetName];
-    if (!presets) { throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name'); }
+Token.prototype.attrPush = function attrPush(attrData) {
+  if (this.attrs) {
+    this.attrs.push(attrData);
+  } else {
+    this.attrs = [attrData];
   }
+};
 
-  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\'t be empty'); }
-
-  if (presets.options) { self.set(presets.options); }
-
-  if (presets.components) {
-    Object.keys(presets.components).forEach(function (name) {
-      if (presets.components[name].rules) {
-        self[name].ruler.enableOnly(presets.components[name].rules);
-      }
-      if (presets.components[name].rules2) {
-        self[name].ruler2.enableOnly(presets.components[name].rules2);
-      }
-    });
+/**
+ * Token.attrSet(name, value)
+ *
+ * Set `name` attribute to `value`. Override old value if exists.
+ **/
+Token.prototype.attrSet = function attrSet(name, value) {
+  const idx = this.attrIndex(name);
+  const attrData = [name, value];
+  if (idx < 0) {
+    this.attrPush(attrData);
+  } else {
+    this.attrs[idx] = attrData;
   }
-  return this;
 };
 
-
-/** chainable
- * MarkdownIt.enable(list, ignoreInvalid)
- * - list (String|Array): rule name or list of rule names to enable
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable list or rules. It will automatically find appropriate components,
- * containing rules with given names. If rule not found, and `ignoreInvalid`
- * not set - throws exception.
- *
- * ##### Example
+/**
+ * Token.attrGet(name)
  *
- * ```javascript
- * var md = require('markdown-it')()
- *             .enable(['sub', 'sup'])
- *             .disable('smartquotes');
- * ```
+ * Get the value of attribute `name`, or null if it does not exist.
  **/
-MarkdownIt.prototype.enable = function (list, ignoreInvalid) {
-  var result = [];
-
-  if (!Array.isArray(list)) { list = [ list ]; }
-
-  [ 'core', 'block', 'inline' ].forEach(function (chain) {
-    result = result.concat(this[chain].ruler.enable(list, true));
-  }, this);
-
-  result = result.concat(this.inline.ruler2.enable(list, true));
-
-  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });
-
-  if (missed.length && !ignoreInvalid) {
-    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);
+Token.prototype.attrGet = function attrGet(name) {
+  const idx = this.attrIndex(name);
+  let value = null;
+  if (idx >= 0) {
+    value = this.attrs[idx][1];
   }
-
-  return this;
+  return value;
 };
 
-
-/** chainable
- * MarkdownIt.disable(list, ignoreInvalid)
- * - list (String|Array): rule name or list of rule names to disable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+/**
+ * Token.attrJoin(name, value)
  *
- * The same as [[MarkdownIt.enable]], but turn specified rules off.
+ * Join value to existing attribute via space. Or create new attribute if not
+ * exists. Useful to operate with token classes.
  **/
-MarkdownIt.prototype.disable = function (list, ignoreInvalid) {
-  var result = [];
-
-  if (!Array.isArray(list)) { list = [ list ]; }
-
-  [ 'core', 'block', 'inline' ].forEach(function (chain) {
-    result = result.concat(this[chain].ruler.disable(list, true));
-  }, this);
-
-  result = result.concat(this.inline.ruler2.disable(list, true));
-
-  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });
-
-  if (missed.length && !ignoreInvalid) {
-    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);
+Token.prototype.attrJoin = function attrJoin(name, value) {
+  const idx = this.attrIndex(name);
+  if (idx < 0) {
+    this.attrPush([name, value]);
+  } else {
+    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;
   }
-  return this;
 };
 
+// Core state object
+//
 
-/** chainable
- * MarkdownIt.use(plugin, params)
- *
- * Load specified plugin with given params into current parser instance.
- * It's just a sugar to call `plugin(md, params)` with curring.
- *
- * ##### Example
- *
- * ```javascript
- * var iterator = require('markdown-it-for-inline');
- * var md = require('markdown-it')()
- *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
- *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
- *             });
- * ```
- **/
-MarkdownIt.prototype.use = function (plugin /*, params, ... */) {
-  var args = [ this ].concat(Array.prototype.slice.call(arguments, 1));
-  plugin.apply(plugin, args);
-  return this;
-};
-
-
-/** internal
- * MarkdownIt.parse(src, env) -> Array
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Parse input string and return list of block tokens (special token type
- * "inline" will contain list of inline tokens). You should not call this
- * method directly, until you write custom renderer (for example, to produce
- * AST).
- *
- * `env` is used to pass data between "distributed" rules and return additional
- * metadata like reference info, needed for the renderer. It also can be used to
- * inject data in specific cases. Usually, you will be ok to pass `{}`,
- * and then pass updated object to renderer.
- **/
-MarkdownIt.prototype.parse = function (src, env) {
-  if (typeof src !== 'string') {
-    throw new Error('Input data should be a String');
-  }
-
-  var state = new this.core.State(src, this, env);
-
-  this.core.process(state);
-
-  return state.tokens;
-};
-
-
-/**
- * MarkdownIt.render(src [, env]) -> String
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Render markdown string into html. It does all magic for you :).
- *
- * `env` can be used to inject additional metadata (`{}` by default).
- * But you will not need it with high probability. See also comment
- * in [[MarkdownIt.parse]].
- **/
-MarkdownIt.prototype.render = function (src, env) {
-  env = env || {};
-
-  return this.renderer.render(this.parse(src, env), this.options, env);
-};
-
-
-/** internal
- * MarkdownIt.parseInline(src, env) -> Array
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
- * block tokens list with the single `inline` element, containing parsed inline
- * tokens in `children` property. Also updates `env` object.
- **/
-MarkdownIt.prototype.parseInline = function (src, env) {
-  var state = new this.core.State(src, this, env);
-
-  state.inlineMode = true;
-  this.core.process(state);
-
-  return state.tokens;
-};
+function StateCore(src, md, env) {
+  this.src = src;
+  this.env = env;
+  this.tokens = [];
+  this.inlineMode = false;
+  this.md = md; // link to parser instance
+}
 
+// re-export Token class to use in core rules
+StateCore.prototype.Token = Token;
 
-/**
- * MarkdownIt.renderInline(src [, env]) -> String
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
- * will NOT be wrapped into `<p>` tags.
- **/
-MarkdownIt.prototype.renderInline = function (src, env) {
-  env = env || {};
+// Normalize input string
 
-  return this.renderer.render(this.parseInline(src, env), this.options, env);
-};
+// https://spec.commonmark.org/0.29/#line-ending
+const NEWLINES_RE = /\r\n?|\n/g;
+const NULL_RE = /\0/g;
+function normalize(state) {
+  let str;
 
+  // Normalize newlines
+  str = state.src.replace(NEWLINES_RE, '\n');
 
-module.exports = MarkdownIt;
+  // Replace NULL characters
+  str = str.replace(NULL_RE, '\uFFFD');
+  state.src = str;
+}
 
+function block(state) {
+  let token;
+  if (state.inlineMode) {
+    token = new state.Token('inline', '', 0);
+    token.content = state.src;
+    token.map = [0, 1];
+    token.children = [];
+    state.tokens.push(token);
+  } else {
+    state.md.block.parse(state.src, state.md, state.env, state.tokens);
+  }
+}
 
-/***/ }),
+function inline(state) {
+  const tokens = state.tokens;
 
-/***/ 2471:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+  // Parse inlines
+  for (let i = 0, l = tokens.length; i < l; i++) {
+    const tok = tokens[i];
+    if (tok.type === 'inline') {
+      state.md.inline.parse(tok.content, state.md, state.env, tok.children);
+    }
+  }
+}
 
-"use strict";
-/** internal
- * class ParserBlock
- *
- * Block-level tokenizer.
- **/
+// Replace link-like texts with link nodes.
+//
+// Currently restricted by `md.validateLink()` to http/https/ftp
+//
 
+function isLinkOpen$1(str) {
+  return /^<a[>\s]/i.test(str);
+}
+function isLinkClose$1(str) {
+  return /^<\/a\s*>/i.test(str);
+}
+function linkify$1(state) {
+  const blockTokens = state.tokens;
+  if (!state.md.options.linkify) {
+    return;
+  }
+  for (let j = 0, l = blockTokens.length; j < l; j++) {
+    if (blockTokens[j].type !== 'inline' || !state.md.linkify.pretest(blockTokens[j].content)) {
+      continue;
+    }
+    let tokens = blockTokens[j].children;
+    let htmlLinkLevel = 0;
 
+    // We scan from the end, to keep position when new tags added.
+    // Use reversed logic in links start/end match
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      const currentToken = tokens[i];
 
-var Ruler           = __webpack_require__(9580);
+      // Skip content of markdown links
+      if (currentToken.type === 'link_close') {
+        i--;
+        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
+          i--;
+        }
+        continue;
+      }
 
+      // Skip content of html tag links
+      if (currentToken.type === 'html_inline') {
+        if (isLinkOpen$1(currentToken.content) && htmlLinkLevel > 0) {
+          htmlLinkLevel--;
+        }
+        if (isLinkClose$1(currentToken.content)) {
+          htmlLinkLevel++;
+        }
+      }
+      if (htmlLinkLevel > 0) {
+        continue;
+      }
+      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
+        const text = currentToken.content;
+        let links = state.md.linkify.match(text);
 
-var _rules = [
-  // First 2 params - rule name & source. Secondary array - list of rules,
-  // which can be terminated by this one.
-  [ 'table',      __webpack_require__(1785),      [ 'paragraph', 'reference' ] ],
-  [ 'code',       __webpack_require__(8768) ],
-  [ 'fence',      __webpack_require__(3542),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
-  [ 'blockquote', __webpack_require__(5258), [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
-  [ 'hr',         __webpack_require__(5634),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
-  [ 'list',       __webpack_require__(8532),       [ 'paragraph', 'reference', 'blockquote' ] ],
-  [ 'reference',  __webpack_require__(3804) ],
-  [ 'html_block', __webpack_require__(6329), [ 'paragraph', 'reference', 'blockquote' ] ],
-  [ 'heading',    __webpack_require__(1630),    [ 'paragraph', 'reference', 'blockquote' ] ],
-  [ 'lheading',   __webpack_require__(6850) ],
-  [ 'paragraph',  __webpack_require__(6864) ]
-];
+        // Now split string to nodes
+        const nodes = [];
+        let level = currentToken.level;
+        let lastPos = 0;
 
+        // forbid escape sequence at the start of the string,
+        // this avoids http\://example.com/ from being linkified as
+        // http:<a href="//example.com/">//example.com/</a>
+        if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === 'text_special') {
+          links = links.slice(1);
+        }
+        for (let ln = 0; ln < links.length; ln++) {
+          const url = links[ln].url;
+          const fullUrl = state.md.normalizeLink(url);
+          if (!state.md.validateLink(fullUrl)) {
+            continue;
+          }
+          let urlText = links[ln].text;
 
-/**
- * new ParserBlock()
- **/
-function ParserBlock() {
-  /**
-   * ParserBlock#ruler -> Ruler
-   *
-   * [[Ruler]] instance. Keep configuration of block rules.
-   **/
-  this.ruler = new Ruler();
+          // Linkifier might send raw hostnames like "example.com", where url
+          // starts with domain name. So we prepend http:// in those cases,
+          // and remove it afterwards.
+          //
+          if (!links[ln].schema) {
+            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '');
+          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
+            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');
+          } else {
+            urlText = state.md.normalizeLinkText(urlText);
+          }
+          const pos = links[ln].index;
+          if (pos > lastPos) {
+            const token = new state.Token('text', '', 0);
+            token.content = text.slice(lastPos, pos);
+            token.level = level;
+            nodes.push(token);
+          }
+          const token_o = new state.Token('link_open', 'a', 1);
+          token_o.attrs = [['href', fullUrl]];
+          token_o.level = level++;
+          token_o.markup = 'linkify';
+          token_o.info = 'auto';
+          nodes.push(token_o);
+          const token_t = new state.Token('text', '', 0);
+          token_t.content = urlText;
+          token_t.level = level;
+          nodes.push(token_t);
+          const token_c = new state.Token('link_close', 'a', -1);
+          token_c.level = --level;
+          token_c.markup = 'linkify';
+          token_c.info = 'auto';
+          nodes.push(token_c);
+          lastPos = links[ln].lastIndex;
+        }
+        if (lastPos < text.length) {
+          const token = new state.Token('text', '', 0);
+          token.content = text.slice(lastPos);
+          token.level = level;
+          nodes.push(token);
+        }
 
-  for (var i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });
+        // replace current node
+        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
+      }
+    }
   }
 }
 
-
-// Generate tokens for input range
+// Simple typographic replacements
+//
+// (c) (C) → ©
+// (tm) (TM) → ™
+// (r) (R) → ®
+// +- → ±
+// ... → … (also ?.... → ?.., !.... → !..)
+// ???????? → ???, !!!!! → !!!, `,,` → `,`
+// -- → &ndash;, --- → &mdash;
 //
-ParserBlock.prototype.tokenize = function (state, startLine, endLine) {
-  var ok, i,
-      rules = this.ruler.getRules(''),
-      len = rules.length,
-      line = startLine,
-      hasEmptyLines = false,
-      maxNesting = state.md.options.maxNesting;
 
-  while (line < endLine) {
-    state.line = line = state.skipEmptyLines(line);
-    if (line >= endLine) { break; }
+// TODO:
+// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
+// - multiplications 2 x 4 -> 2 × 4
 
-    // Termination condition for nested calls.
-    // Nested calls currently used for blockquotes & lists
-    if (state.sCount[line] < state.blkIndent) { break; }
+const RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
 
-    // If nesting level exceeded - skip tail to the end. That's not ordinary
-    // situation and we should not care about content.
-    if (state.level >= maxNesting) {
-      state.line = endLine;
-      break;
+// Workaround for phantomjs - need regex without /g flag,
+// or root check will fail every second time
+const SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
+const SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
+const SCOPED_ABBR = {
+  c: '©',
+  r: '®',
+  tm: '™'
+};
+function replaceFn(match, name) {
+  return SCOPED_ABBR[name.toLowerCase()];
+}
+function replace_scoped(inlineTokens) {
+  let inside_autolink = 0;
+  for (let i = inlineTokens.length - 1; i >= 0; i--) {
+    const token = inlineTokens[i];
+    if (token.type === 'text' && !inside_autolink) {
+      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
     }
-
-    // Try all possible rules.
-    // On success, rule should:
-    //
-    // - update `state.line`
-    // - update `state.tokens`
-    // - return true
-
-    for (i = 0; i < len; i++) {
-      ok = rules[i](state, line, endLine, false);
-      if (ok) { break; }
+    if (token.type === 'link_open' && token.info === 'auto') {
+      inside_autolink--;
     }
-
-    // set state.tight if we had an empty line before current tag
-    // i.e. latest empty line should not count
-    state.tight = !hasEmptyLines;
-
-    // paragraph might "eat" one newline after it in nested lists
-    if (state.isEmpty(state.line - 1)) {
-      hasEmptyLines = true;
+    if (token.type === 'link_close' && token.info === 'auto') {
+      inside_autolink++;
     }
-
-    line = state.line;
-
-    if (line < endLine && state.isEmpty(line)) {
-      hasEmptyLines = true;
-      line++;
-      state.line = line;
+  }
+}
+function replace_rare(inlineTokens) {
+  let inside_autolink = 0;
+  for (let i = inlineTokens.length - 1; i >= 0; i--) {
+    const token = inlineTokens[i];
+    if (token.type === 'text' && !inside_autolink) {
+      if (RARE_RE.test(token.content)) {
+        token.content = token.content.replace(/\+-/g, '±')
+        // .., ..., ....... -> …
+        // but ?..... & !..... -> ?.. & !..
+        .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..').replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')
+        // em-dash
+        .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\u2014')
+        // en-dash
+        .replace(/(^|\s)--(?=\s|$)/mg, '$1\u2013').replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, '$1\u2013');
+      }
+    }
+    if (token.type === 'link_open' && token.info === 'auto') {
+      inside_autolink--;
+    }
+    if (token.type === 'link_close' && token.info === 'auto') {
+      inside_autolink++;
     }
   }
-};
-
+}
+function replace(state) {
+  let blkIdx;
+  if (!state.md.options.typographer) {
+    return;
+  }
+  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+    if (state.tokens[blkIdx].type !== 'inline') {
+      continue;
+    }
+    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
+      replace_scoped(state.tokens[blkIdx].children);
+    }
+    if (RARE_RE.test(state.tokens[blkIdx].content)) {
+      replace_rare(state.tokens[blkIdx].children);
+    }
+  }
+}
 
-/**
- * ParserBlock.parse(str, md, env, outTokens)
- *
- * Process input string and push block tokens into `outTokens`
- **/
-ParserBlock.prototype.parse = function (src, md, env, outTokens) {
-  var state;
+// Convert straight quotation marks to typographic ones
+//
 
-  if (!src) { return; }
+const QUOTE_TEST_RE = /['"]/;
+const QUOTE_RE = /['"]/g;
+const APOSTROPHE = '\u2019'; /* ’ */
 
-  state = new this.State(src, md, env, outTokens);
+function replaceAt(str, index, ch) {
+  return str.slice(0, index) + ch + str.slice(index + 1);
+}
+function process_inlines(tokens, state) {
+  let j;
+  const stack = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const thisLevel = tokens[i].level;
+    for (j = stack.length - 1; j >= 0; j--) {
+      if (stack[j].level <= thisLevel) {
+        break;
+      }
+    }
+    stack.length = j + 1;
+    if (token.type !== 'text') {
+      continue;
+    }
+    let text = token.content;
+    let pos = 0;
+    let max = text.length;
 
-  this.tokenize(state, state.line, state.lineMax);
-};
+    /* eslint no-labels:0,block-scoped-var:0 */
+    OUTER: while (pos < max) {
+      QUOTE_RE.lastIndex = pos;
+      const t = QUOTE_RE.exec(text);
+      if (!t) {
+        break;
+      }
+      let canOpen = true;
+      let canClose = true;
+      pos = t.index + 1;
+      const isSingle = t[0] === "'";
 
+      // Find previous character,
+      // default to space if it's the beginning of the line
+      //
+      let lastChar = 0x20;
+      if (t.index - 1 >= 0) {
+        lastChar = text.charCodeAt(t.index - 1);
+      } else {
+        for (j = i - 1; j >= 0; j--) {
+          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20
+          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'
 
-ParserBlock.prototype.State = __webpack_require__(2948);
+          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
+          break;
+        }
+      }
 
+      // Find next character,
+      // default to space if it's the end of the line
+      //
+      let nextChar = 0x20;
+      if (pos < max) {
+        nextChar = text.charCodeAt(pos);
+      } else {
+        for (j = i + 1; j < tokens.length; j++) {
+          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20
+          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'
 
-module.exports = ParserBlock;
+          nextChar = tokens[j].content.charCodeAt(0);
+          break;
+        }
+      }
+      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
+      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+      const isLastWhiteSpace = isWhiteSpace(lastChar);
+      const isNextWhiteSpace = isWhiteSpace(nextChar);
+      if (isNextWhiteSpace) {
+        canOpen = false;
+      } else if (isNextPunctChar) {
+        if (!(isLastWhiteSpace || isLastPunctChar)) {
+          canOpen = false;
+        }
+      }
+      if (isLastWhiteSpace) {
+        canClose = false;
+      } else if (isLastPunctChar) {
+        if (!(isNextWhiteSpace || isNextPunctChar)) {
+          canClose = false;
+        }
+      }
+      if (nextChar === 0x22 /* " */ && t[0] === '"') {
+        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {
+          // special case: 1"" - count first quote as an inch
+          canClose = canOpen = false;
+        }
+      }
+      if (canOpen && canClose) {
+        // Replace quotes in the middle of punctuation sequence, but not
+        // in the middle of the words, i.e.:
+        //
+        // 1. foo " bar " baz - not replaced
+        // 2. foo-"-bar-"-baz - replaced
+        // 3. foo"bar"baz     - not replaced
+        //
+        canOpen = isLastPunctChar;
+        canClose = isNextPunctChar;
+      }
+      if (!canOpen && !canClose) {
+        // middle of word
+        if (isSingle) {
+          token.content = replaceAt(token.content, t.index, APOSTROPHE);
+        }
+        continue;
+      }
+      if (canClose) {
+        // this could be a closing quote, rewind the stack to get a match
+        for (j = stack.length - 1; j >= 0; j--) {
+          let item = stack[j];
+          if (stack[j].level < thisLevel) {
+            break;
+          }
+          if (item.single === isSingle && stack[j].level === thisLevel) {
+            item = stack[j];
+            let openQuote;
+            let closeQuote;
+            if (isSingle) {
+              openQuote = state.md.options.quotes[2];
+              closeQuote = state.md.options.quotes[3];
+            } else {
+              openQuote = state.md.options.quotes[0];
+              closeQuote = state.md.options.quotes[1];
+            }
 
+            // replace token.content *before* tokens[item.token].content,
+            // because, if they are pointing at the same token, replaceAt
+            // could mess up indices when quote length != 1
+            token.content = replaceAt(token.content, t.index, closeQuote);
+            tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);
+            pos += closeQuote.length - 1;
+            if (item.token === i) {
+              pos += openQuote.length - 1;
+            }
+            text = token.content;
+            max = text.length;
+            stack.length = j;
+            continue OUTER;
+          }
+        }
+      }
+      if (canOpen) {
+        stack.push({
+          token: i,
+          pos: t.index,
+          single: isSingle,
+          level: thisLevel
+        });
+      } else if (canClose && isSingle) {
+        token.content = replaceAt(token.content, t.index, APOSTROPHE);
+      }
+    }
+  }
+}
+function smartquotes(state) {
+  /* eslint max-depth:0 */
+  if (!state.md.options.typographer) {
+    return;
+  }
+  for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+    if (state.tokens[blkIdx].type !== 'inline' || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
+      continue;
+    }
+    process_inlines(state.tokens[blkIdx].children, state);
+  }
+}
 
-/***/ }),
+// Join raw text tokens with the rest of the text
+//
+// This is set as a separate rule to provide an opportunity for plugins
+// to run text replacements after text join, but before escape join.
+//
+// For example, `\:)` shouldn't be replaced with an emoji.
+//
 
-/***/ 7346:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+function text_join(state) {
+  let curr, last;
+  const blockTokens = state.tokens;
+  const l = blockTokens.length;
+  for (let j = 0; j < l; j++) {
+    if (blockTokens[j].type !== 'inline') continue;
+    const tokens = blockTokens[j].children;
+    const max = tokens.length;
+    for (curr = 0; curr < max; curr++) {
+      if (tokens[curr].type === 'text_special') {
+        tokens[curr].type = 'text';
+      }
+    }
+    for (curr = last = 0; curr < max; curr++) {
+      if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {
+        // collapse two adjacent text nodes
+        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
+      } else {
+        if (curr !== last) {
+          tokens[last] = tokens[curr];
+        }
+        last++;
+      }
+    }
+    if (curr !== last) {
+      tokens.length = last;
+    }
+  }
+}
 
-"use strict";
 /** internal
  * class Core
  *
@@ -14709,23 +16147,10 @@ module.exports = ParserBlock;
  * transformations.
  **/
 
-
-
-var Ruler  = __webpack_require__(9580);
-
-
-var _rules = [
-  [ 'normalize',      __webpack_require__(4129)      ],
-  [ 'block',          __webpack_require__(898)          ],
-  [ 'inline',         __webpack_require__(9827)         ],
-  [ 'linkify',        __webpack_require__(7830)        ],
-  [ 'replacements',   __webpack_require__(2834)   ],
-  [ 'smartquotes',    __webpack_require__(8450)    ],
-  // `text_join` finds `text_special` tokens (for escape sequences)
-  // and joins them with the rest of the text
-  [ 'text_join',      __webpack_require__(6633)      ]
-];
-
+const _rules$2 = [['normalize', normalize], ['block', block], ['inline', inline], ['linkify', linkify$1], ['replacements', replace], ['smartquotes', smartquotes],
+// `text_join` finds `text_special` tokens (for escape sequences)
+// and joins them with the rest of the text
+['text_join', text_join]];
 
 /**
  * new Core()
@@ -14737,16365 +16162,19423 @@ function Core() {
    * [[Ruler]] instance. Keep configuration of core rules.
    **/
   this.ruler = new Ruler();
-
-  for (var i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1]);
+  for (let i = 0; i < _rules$2.length; i++) {
+    this.ruler.push(_rules$2[i][0], _rules$2[i][1]);
   }
 }
 
-
 /**
  * Core.process(state)
  *
  * Executes core chain rules.
  **/
 Core.prototype.process = function (state) {
-  var i, l, rules;
-
-  rules = this.ruler.getRules('');
-
-  for (i = 0, l = rules.length; i < l; i++) {
+  const rules = this.ruler.getRules('');
+  for (let i = 0, l = rules.length; i < l; i++) {
     rules[i](state);
   }
 };
+Core.prototype.State = StateCore;
 
-Core.prototype.State = __webpack_require__(6480);
+// Parser state class
 
+function StateBlock(src, md, env, tokens) {
+  this.src = src;
 
-module.exports = Core;
+  // link to parser instance
+  this.md = md;
+  this.env = env;
 
+  //
+  // Internal state vartiables
+  //
 
-/***/ }),
+  this.tokens = tokens;
+  this.bMarks = []; // line begin offsets for fast jumps
+  this.eMarks = []; // line end offsets for fast jumps
+  this.tShift = []; // offsets of the first non-space characters (tabs not expanded)
+  this.sCount = []; // indents for each line (tabs expanded)
 
-/***/ 4485:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+  // An amount of virtual spaces (tabs expanded) between beginning
+  // of each line (bMarks) and real beginning of that line.
+  //
+  // It exists only as a hack because blockquotes override bMarks
+  // losing information in the process.
+  //
+  // It's used only when expanding tabs, you can think about it as
+  // an initial tab length, e.g. bsCount=21 applied to string `\t123`
+  // means first tab should be expanded to 4-21%4 === 3 spaces.
+  //
+  this.bsCount = [];
 
-"use strict";
-/** internal
- * class ParserInline
- *
- * Tokenizes paragraph content.
- **/
+  // block parser variables
 
+  // required block content indent (for example, if we are
+  // inside a list, it would be positioned after list marker)
+  this.blkIndent = 0;
+  this.line = 0; // line index in src
+  this.lineMax = 0; // lines count
+  this.tight = false; // loose/tight mode for lists
+  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)
+  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)
 
+  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
+  // used in lists to determine if they interrupt a paragraph
+  this.parentType = 'root';
+  this.level = 0;
 
-var Ruler           = __webpack_require__(9580);
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Parser rules
-
-var _rules = [
-  [ 'text',            __webpack_require__(9941) ],
-  [ 'linkify',         __webpack_require__(2906) ],
-  [ 'newline',         __webpack_require__(3905) ],
-  [ 'escape',          __webpack_require__(1917) ],
-  [ 'backticks',       __webpack_require__(40) ],
-  [ 'strikethrough',   (__webpack_require__(4814)/* .tokenize */ .w) ],
-  [ 'emphasis',        (__webpack_require__(7894)/* .tokenize */ .w) ],
-  [ 'link',            __webpack_require__(1727) ],
-  [ 'image',           __webpack_require__(3006) ],
-  [ 'autolink',        __webpack_require__(3420) ],
-  [ 'html_inline',     __webpack_require__(1779) ],
-  [ 'entity',          __webpack_require__(9391) ]
-];
-
-// `rule2` ruleset was created specifically for emphasis/strikethrough
-// post-processing and may be changed in the future.
-//
-// Don't use this for anything except pairs (plugins working with `balance_pairs`).
-//
-var _rules2 = [
-  [ 'balance_pairs',   __webpack_require__(9354) ],
-  [ 'strikethrough',   (__webpack_require__(4814)/* .postProcess */ .g) ],
-  [ 'emphasis',        (__webpack_require__(7894)/* .postProcess */ .g) ],
-  // rules for pairs separate '**' into its own text tokens, which may be left unused,
-  // rule below merges unused segments back with the rest of the text
-  [ 'fragments_join',  __webpack_require__(9969) ]
-];
-
-
-/**
- * new ParserInline()
- **/
-function ParserInline() {
-  var i;
-
-  /**
-   * ParserInline#ruler -> Ruler
-   *
-   * [[Ruler]] instance. Keep configuration of inline rules.
-   **/
-  this.ruler = new Ruler();
-
-  for (i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1]);
+  // Create caches
+  // Generate markers.
+  const s = this.src;
+  for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
+    const ch = s.charCodeAt(pos);
+    if (!indent_found) {
+      if (isSpace(ch)) {
+        indent++;
+        if (ch === 0x09) {
+          offset += 4 - offset % 4;
+        } else {
+          offset++;
+        }
+        continue;
+      } else {
+        indent_found = true;
+      }
+    }
+    if (ch === 0x0A || pos === len - 1) {
+      if (ch !== 0x0A) {
+        pos++;
+      }
+      this.bMarks.push(start);
+      this.eMarks.push(pos);
+      this.tShift.push(indent);
+      this.sCount.push(offset);
+      this.bsCount.push(0);
+      indent_found = false;
+      indent = 0;
+      offset = 0;
+      start = pos + 1;
+    }
   }
 
-  /**
-   * ParserInline#ruler2 -> Ruler
-   *
-   * [[Ruler]] instance. Second ruler used for post-processing
-   * (e.g. in emphasis-like rules).
-   **/
-  this.ruler2 = new Ruler();
-
-  for (i = 0; i < _rules2.length; i++) {
-    this.ruler2.push(_rules2[i][0], _rules2[i][1]);
-  }
+  // Push fake entry to simplify cache bounds checks
+  this.bMarks.push(s.length);
+  this.eMarks.push(s.length);
+  this.tShift.push(0);
+  this.sCount.push(0);
+  this.bsCount.push(0);
+  this.lineMax = this.bMarks.length - 1; // don't count last fake line
 }
 
-
-// Skip single token by running all rules in validation mode;
-// returns `true` if any rule reported success
+// Push new token to "stream".
 //
-ParserInline.prototype.skipToken = function (state) {
-  var ok, i, pos = state.pos,
-      rules = this.ruler.getRules(''),
-      len = rules.length,
-      maxNesting = state.md.options.maxNesting,
-      cache = state.cache;
-
+StateBlock.prototype.push = function (type, tag, nesting) {
+  const token = new Token(type, tag, nesting);
+  token.block = true;
+  if (nesting < 0) this.level--; // closing tag
+  token.level = this.level;
+  if (nesting > 0) this.level++; // opening tag
 
-  if (typeof cache[pos] !== 'undefined') {
-    state.pos = cache[pos];
-    return;
+  this.tokens.push(token);
+  return token;
+};
+StateBlock.prototype.isEmpty = function isEmpty(line) {
+  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
+};
+StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
+  for (let max = this.lineMax; from < max; from++) {
+    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
+      break;
+    }
   }
+  return from;
+};
 
-  if (state.level < maxNesting) {
-    for (i = 0; i < len; i++) {
-      // Increment state.level and decrement it later to limit recursion.
-      // It's harmless to do here, because no tokens are created. But ideally,
-      // we'd need a separate private state variable for this purpose.
-      //
-      state.level++;
-      ok = rules[i](state, true);
-      state.level--;
-
-      if (ok) { break; }
+// Skip spaces from given position.
+StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
+  for (let max = this.src.length; pos < max; pos++) {
+    const ch = this.src.charCodeAt(pos);
+    if (!isSpace(ch)) {
+      break;
     }
-  } else {
-    // Too much nesting, just skip until the end of the paragraph.
-    //
-    // NOTE: this will cause links to behave incorrectly in the following case,
-    //       when an amount of `[` is exactly equal to `maxNesting + 1`:
-    //
-    //       [[[[[[[[[[[[[[[[[[[[[foo]()
-    //
-    // TODO: remove this workaround when CM standard will allow nested links
-    //       (we can replace it by preventing links from being parsed in
-    //       validation mode)
-    //
-    state.pos = state.posMax;
   }
-
-  if (!ok) { state.pos++; }
-  cache[pos] = state.pos;
+  return pos;
 };
 
-
-// Generate tokens for input range
-//
-ParserInline.prototype.tokenize = function (state) {
-  var ok, i,
-      rules = this.ruler.getRules(''),
-      len = rules.length,
-      end = state.posMax,
-      maxNesting = state.md.options.maxNesting;
-
-  while (state.pos < end) {
-    // Try all possible rules.
-    // On success, rule should:
-    //
-    // - update `state.pos`
-    // - update `state.tokens`
-    // - return true
-
-    if (state.level < maxNesting) {
-      for (i = 0; i < len; i++) {
-        ok = rules[i](state, false);
-        if (ok) { break; }
-      }
+// Skip spaces from given position in reverse.
+StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
+  if (pos <= min) {
+    return pos;
+  }
+  while (pos > min) {
+    if (!isSpace(this.src.charCodeAt(--pos))) {
+      return pos + 1;
     }
+  }
+  return pos;
+};
 
-    if (ok) {
-      if (state.pos >= end) { break; }
-      continue;
+// Skip char codes from given position
+StateBlock.prototype.skipChars = function skipChars(pos, code) {
+  for (let max = this.src.length; pos < max; pos++) {
+    if (this.src.charCodeAt(pos) !== code) {
+      break;
     }
-
-    state.pending += state.src[state.pos++];
   }
+  return pos;
+};
 
-  if (state.pending) {
-    state.pushPending();
+// Skip char codes reverse from given position - 1
+StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
+  if (pos <= min) {
+    return pos;
+  }
+  while (pos > min) {
+    if (code !== this.src.charCodeAt(--pos)) {
+      return pos + 1;
+    }
   }
+  return pos;
 };
 
-
-/**
- * ParserInline.parse(str, md, env, outTokens)
- *
- * Process input string and push inline tokens into `outTokens`
- **/
-ParserInline.prototype.parse = function (str, md, env, outTokens) {
-  var i, rules, len;
-  var state = new this.State(str, md, env, outTokens);
-
-  this.tokenize(state);
-
-  rules = this.ruler2.getRules('');
-  len = rules.length;
-
-  for (i = 0; i < len; i++) {
-    rules[i](state);
+// cut lines range from source.
+StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
+  if (begin >= end) {
+    return '';
+  }
+  const queue = new Array(end - begin);
+  for (let i = 0, line = begin; line < end; line++, i++) {
+    let lineIndent = 0;
+    const lineStart = this.bMarks[line];
+    let first = lineStart;
+    let last;
+    if (line + 1 < end || keepLastLF) {
+      // No need for bounds check because we have fake entry on tail.
+      last = this.eMarks[line] + 1;
+    } else {
+      last = this.eMarks[line];
+    }
+    while (first < last && lineIndent < indent) {
+      const ch = this.src.charCodeAt(first);
+      if (isSpace(ch)) {
+        if (ch === 0x09) {
+          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
+        } else {
+          lineIndent++;
+        }
+      } else if (first - lineStart < this.tShift[line]) {
+        // patched tShift masked characters to look like spaces (blockquotes, list markers)
+        lineIndent++;
+      } else {
+        break;
+      }
+      first++;
+    }
+    if (lineIndent > indent) {
+      // partially expanding tabs in code blocks, e.g '\t\tfoobar'
+      // with indent=2 becomes '  \tfoobar'
+      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);
+    } else {
+      queue[i] = this.src.slice(first, last);
+    }
   }
+  return queue.join('');
 };
 
+// re-export Token class to use in block rules
+StateBlock.prototype.Token = Token;
 
-ParserInline.prototype.State = __webpack_require__(670);
-
-
-module.exports = ParserInline;
+// GFM table, https://github.github.com/gfm/#tables-extension-
 
 
-/***/ }),
+// Limit the amount of empty autocompleted cells in a table,
+// see https://github.com/markdown-it/markdown-it/issues/1000,
+//
+// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.
+// We set it to 65k, which can expand user input by a factor of x370
+// (256x256 square is 1.8kB expanded into 650kB).
+const MAX_AUTOCOMPLETED_CELLS = 0x10000;
+function getLine(state, line) {
+  const pos = state.bMarks[line] + state.tShift[line];
+  const max = state.eMarks[line];
+  return state.src.slice(pos, max);
+}
+function escapedSplit(str) {
+  const result = [];
+  const max = str.length;
+  let pos = 0;
+  let ch = str.charCodeAt(pos);
+  let isEscaped = false;
+  let lastPos = 0;
+  let current = '';
+  while (pos < max) {
+    if (ch === 0x7c /* | */) {
+      if (!isEscaped) {
+        // pipe separating cells, '|'
+        result.push(current + str.substring(lastPos, pos));
+        current = '';
+        lastPos = pos + 1;
+      } else {
+        // escaped pipe, '\|'
+        current += str.substring(lastPos, pos - 1);
+        lastPos = pos;
+      }
+    }
+    isEscaped = ch === 0x5c /* \ */;
+    pos++;
+    ch = str.charCodeAt(pos);
+  }
+  result.push(current + str.substring(lastPos));
+  return result;
+}
+function table(state, startLine, endLine, silent) {
+  // should have at least two lines
+  if (startLine + 2 > endLine) {
+    return false;
+  }
+  let nextLine = startLine + 1;
+  if (state.sCount[nextLine] < state.blkIndent) {
+    return false;
+  }
 
-/***/ 6895:
-/***/ ((module) => {
-
-"use strict";
-// Commonmark default options
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[nextLine] - state.blkIndent >= 4) {
+    return false;
+  }
 
+  // first character of the second line should be '|', '-', ':',
+  // and no other characters are allowed but spaces;
+  // basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
 
+  let pos = state.bMarks[nextLine] + state.tShift[nextLine];
+  if (pos >= state.eMarks[nextLine]) {
+    return false;
+  }
+  const firstCh = state.src.charCodeAt(pos++);
+  if (firstCh !== 0x7C /* | */ && firstCh !== 0x2D /* - */ && firstCh !== 0x3A /* : */) {
+    return false;
+  }
+  if (pos >= state.eMarks[nextLine]) {
+    return false;
+  }
+  const secondCh = state.src.charCodeAt(pos++);
+  if (secondCh !== 0x7C /* | */ && secondCh !== 0x2D /* - */ && secondCh !== 0x3A /* : */ && !isSpace(secondCh)) {
+    return false;
+  }
 
+  // if first character is '-', then second character must not be a space
+  // (due to parsing ambiguity with list)
+  if (firstCh === 0x2D /* - */ && isSpace(secondCh)) {
+    return false;
+  }
+  while (pos < state.eMarks[nextLine]) {
+    const ch = state.src.charCodeAt(pos);
+    if (ch !== 0x7C /* | */ && ch !== 0x2D /* - */ && ch !== 0x3A /* : */ && !isSpace(ch)) {
+      return false;
+    }
+    pos++;
+  }
+  let lineText = getLine(state, startLine + 1);
+  let columns = lineText.split('|');
+  const aligns = [];
+  for (let i = 0; i < columns.length; i++) {
+    const t = columns[i].trim();
+    if (!t) {
+      // allow empty columns before and after table, but not in between columns;
+      // e.g. allow ` |---| `, disallow ` ---||--- `
+      if (i === 0 || i === columns.length - 1) {
+        continue;
+      } else {
+        return false;
+      }
+    }
+    if (!/^:?-+:?$/.test(t)) {
+      return false;
+    }
+    if (t.charCodeAt(t.length - 1) === 0x3A /* : */) {
+      aligns.push(t.charCodeAt(0) === 0x3A /* : */ ? 'center' : 'right');
+    } else if (t.charCodeAt(0) === 0x3A /* : */) {
+      aligns.push('left');
+    } else {
+      aligns.push('');
+    }
+  }
+  lineText = getLine(state, startLine).trim();
+  if (lineText.indexOf('|') === -1) {
+    return false;
+  }
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  columns = escapedSplit(lineText);
+  if (columns.length && columns[0] === '') columns.shift();
+  if (columns.length && columns[columns.length - 1] === '') columns.pop();
 
-module.exports = {
-  options: {
-    html:         true,         // Enable HTML tags in source
-    xhtmlOut:     true,         // Use '/' to close single tags (<br />)
-    breaks:       false,        // Convert '\n' in paragraphs into <br>
-    langPrefix:   'language-',  // CSS language prefix for fenced blocks
-    linkify:      false,        // autoconvert URL-like texts to links
+  // header row will define an amount of columns in the entire table,
+  // and align row should be exactly the same (the rest of the rows can differ)
+  const columnCount = columns.length;
+  if (columnCount === 0 || columnCount !== aligns.length) {
+    return false;
+  }
+  if (silent) {
+    return true;
+  }
+  const oldParentType = state.parentType;
+  state.parentType = 'table';
 
-    // Enable some language-neutral replacements + quotes beautification
-    typographer:  false,
+  // use 'blockquote' lists for termination because it's
+  // the most similar to tables
+  const terminatorRules = state.md.block.ruler.getRules('blockquote');
+  const token_to = state.push('table_open', 'table', 1);
+  const tableLines = [startLine, 0];
+  token_to.map = tableLines;
+  const token_tho = state.push('thead_open', 'thead', 1);
+  token_tho.map = [startLine, startLine + 1];
+  const token_htro = state.push('tr_open', 'tr', 1);
+  token_htro.map = [startLine, startLine + 1];
+  for (let i = 0; i < columns.length; i++) {
+    const token_ho = state.push('th_open', 'th', 1);
+    if (aligns[i]) {
+      token_ho.attrs = [['style', 'text-align:' + aligns[i]]];
+    }
+    const token_il = state.push('inline', '', 0);
+    token_il.content = columns[i].trim();
+    token_il.children = [];
+    state.push('th_close', 'th', -1);
+  }
+  state.push('tr_close', 'tr', -1);
+  state.push('thead_close', 'thead', -1);
+  let tbodyLines;
+  let autocompletedCells = 0;
+  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
+    if (state.sCount[nextLine] < state.blkIndent) {
+      break;
+    }
+    let terminate = false;
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
+    }
+    if (terminate) {
+      break;
+    }
+    lineText = getLine(state, nextLine).trim();
+    if (!lineText) {
+      break;
+    }
+    if (state.sCount[nextLine] - state.blkIndent >= 4) {
+      break;
+    }
+    columns = escapedSplit(lineText);
+    if (columns.length && columns[0] === '') columns.shift();
+    if (columns.length && columns[columns.length - 1] === '') columns.pop();
 
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
-    //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
+    // note: autocomplete count can be negative if user specifies more columns than header,
+    // but that does not affect intended use (which is limiting expansion)
+    autocompletedCells += columnCount - columns.length;
+    if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) {
+      break;
+    }
+    if (nextLine === startLine + 2) {
+      const token_tbo = state.push('tbody_open', 'tbody', 1);
+      token_tbo.map = tbodyLines = [startLine + 2, 0];
+    }
+    const token_tro = state.push('tr_open', 'tr', 1);
+    token_tro.map = [nextLine, nextLine + 1];
+    for (let i = 0; i < columnCount; i++) {
+      const token_tdo = state.push('td_open', 'td', 1);
+      if (aligns[i]) {
+        token_tdo.attrs = [['style', 'text-align:' + aligns[i]]];
+      }
+      const token_il = state.push('inline', '', 0);
+      token_il.content = columns[i] ? columns[i].trim() : '';
+      token_il.children = [];
+      state.push('td_close', 'td', -1);
+    }
+    state.push('tr_close', 'tr', -1);
+  }
+  if (tbodyLines) {
+    state.push('tbody_close', 'tbody', -1);
+    tbodyLines[1] = nextLine;
+  }
+  state.push('table_close', 'table', -1);
+  tableLines[1] = nextLine;
+  state.parentType = oldParentType;
+  state.line = nextLine;
+  return true;
+}
 
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
-    //
-    highlight: null,
+// Code block (4 spaces padded)
 
-    maxNesting:   20            // Internal protection, recursion limit
-  },
+function code(state, startLine, endLine /*, silent */) {
+  if (state.sCount[startLine] - state.blkIndent < 4) {
+    return false;
+  }
+  let nextLine = startLine + 1;
+  let last = nextLine;
+  while (nextLine < endLine) {
+    if (state.isEmpty(nextLine)) {
+      nextLine++;
+      continue;
+    }
+    if (state.sCount[nextLine] - state.blkIndent >= 4) {
+      nextLine++;
+      last = nextLine;
+      continue;
+    }
+    break;
+  }
+  state.line = last;
+  const token = state.push('code_block', 'code', 0);
+  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\n';
+  token.map = [startLine, state.line];
+  return true;
+}
 
-  components: {
+// fences (``` lang, ~~~ lang)
 
-    core: {
-      rules: [
-        'normalize',
-        'block',
-        'inline',
-        'text_join'
-      ]
-    },
+function fence(state, startLine, endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  let max = state.eMarks[startLine];
 
-    block: {
-      rules: [
-        'blockquote',
-        'code',
-        'fence',
-        'heading',
-        'hr',
-        'html_block',
-        'lheading',
-        'list',
-        'reference',
-        'paragraph'
-      ]
-    },
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  if (pos + 3 > max) {
+    return false;
+  }
+  const marker = state.src.charCodeAt(pos);
+  if (marker !== 0x7E /* ~ */ && marker !== 0x60 /* ` */) {
+    return false;
+  }
 
-    inline: {
-      rules: [
-        'autolink',
-        'backticks',
-        'emphasis',
-        'entity',
-        'escape',
-        'html_inline',
-        'image',
-        'link',
-        'newline',
-        'text'
-      ],
-      rules2: [
-        'balance_pairs',
-        'emphasis',
-        'fragments_join'
-      ]
+  // scan marker length
+  let mem = pos;
+  pos = state.skipChars(pos, marker);
+  let len = pos - mem;
+  if (len < 3) {
+    return false;
+  }
+  const markup = state.src.slice(mem, pos);
+  const params = state.src.slice(pos, max);
+  if (marker === 0x60 /* ` */) {
+    if (params.indexOf(String.fromCharCode(marker)) >= 0) {
+      return false;
     }
   }
-};
 
+  // Since start is found, we can report success here in validation mode
+  if (silent) {
+    return true;
+  }
 
-/***/ }),
+  // search end of block
+  let nextLine = startLine;
+  let haveEndMarker = false;
+  for (;;) {
+    nextLine++;
+    if (nextLine >= endLine) {
+      // unclosed block should be autoclosed by end of document.
+      // also block seems to be autoclosed by end of parent
+      break;
+    }
+    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
+    max = state.eMarks[nextLine];
+    if (pos < max && state.sCount[nextLine] < state.blkIndent) {
+      // non-empty line with negative indent should stop the list:
+      // - ```
+      //  test
+      break;
+    }
+    if (state.src.charCodeAt(pos) !== marker) {
+      continue;
+    }
+    if (state.sCount[nextLine] - state.blkIndent >= 4) {
+      // closing fence should be indented less than 4 spaces
+      continue;
+    }
+    pos = state.skipChars(pos, marker);
 
-/***/ 4218:
-/***/ ((module) => {
+    // closing code fence must be at least as long as the opening one
+    if (pos - mem < len) {
+      continue;
+    }
 
-"use strict";
-// markdown-it default options
+    // make sure tail has spaces only
+    pos = state.skipSpaces(pos);
+    if (pos < max) {
+      continue;
+    }
+    haveEndMarker = true;
+    // found!
+    break;
+  }
 
+  // If a fence has heading spaces, they should be removed from its inner block
+  len = state.sCount[startLine];
+  state.line = nextLine + (haveEndMarker ? 1 : 0);
+  const token = state.push('fence', 'code', 0);
+  token.info = params;
+  token.content = state.getLines(startLine + 1, nextLine, len, true);
+  token.markup = markup;
+  token.map = [startLine, state.line];
+  return true;
+}
 
+// Block quotes
 
+function blockquote(state, startLine, endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  let max = state.eMarks[startLine];
+  const oldLineMax = state.lineMax;
 
-module.exports = {
-  options: {
-    html:         false,        // Enable HTML tags in source
-    xhtmlOut:     false,        // Use '/' to close single tags (<br />)
-    breaks:       false,        // Convert '\n' in paragraphs into <br>
-    langPrefix:   'language-',  // CSS language prefix for fenced blocks
-    linkify:      false,        // autoconvert URL-like texts to links
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
 
-    // Enable some language-neutral replacements + quotes beautification
-    typographer:  false,
+  // check the block quote marker
+  if (state.src.charCodeAt(pos) !== 0x3E /* > */) {
+    return false;
+  }
 
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
-    //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
+  // we know that it's going to be a valid blockquote,
+  // so no point trying to find the end of it in silent mode
+  if (silent) {
+    return true;
+  }
+  const oldBMarks = [];
+  const oldBSCount = [];
+  const oldSCount = [];
+  const oldTShift = [];
+  const terminatorRules = state.md.block.ruler.getRules('blockquote');
+  const oldParentType = state.parentType;
+  state.parentType = 'blockquote';
+  let lastLineEmpty = false;
+  let nextLine;
 
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
+  // Search the end of the block
+  //
+  // Block ends with either:
+  //  1. an empty line outside:
+  //     ```
+  //     > test
+  //
+  //     ```
+  //  2. an empty line inside:
+  //     ```
+  //     >
+  //     test
+  //     ```
+  //  3. another tag:
+  //     ```
+  //     > test
+  //      - - -
+  //     ```
+  for (nextLine = startLine; nextLine < endLine; nextLine++) {
+    // check if it's outdented, i.e. it's inside list item and indented
+    // less than said list item:
     //
-    highlight: null,
-
-    maxNesting:   100            // Internal protection, recursion limit
-  },
-
-  components: {
-
-    core: {},
-    block: {},
-    inline: {}
-  }
-};
-
-
-/***/ }),
-
-/***/ 873:
-/***/ ((module) => {
-
-"use strict";
-// "Zero" preset, with nothing enabled. Useful for manual configuring of simple
-// modes. For example, to parse bold/italic only.
-
+    // ```
+    // 1. anything
+    //    > current blockquote
+    // 2. checking this line
+    // ```
+    const isOutdented = state.sCount[nextLine] < state.blkIndent;
+    pos = state.bMarks[nextLine] + state.tShift[nextLine];
+    max = state.eMarks[nextLine];
+    if (pos >= max) {
+      // Case 1: line is not inside the blockquote, and this line is empty.
+      break;
+    }
+    if (state.src.charCodeAt(pos++) === 0x3E /* > */ && !isOutdented) {
+      // This line is inside the blockquote.
 
+      // set offset past spaces and ">"
+      let initial = state.sCount[nextLine] + 1;
+      let spaceAfterMarker;
+      let adjustTab;
 
+      // skip one optional space after '>'
+      if (state.src.charCodeAt(pos) === 0x20 /* space */) {
+        // ' >   test '
+        //     ^ -- position start of line here:
+        pos++;
+        initial++;
+        adjustTab = false;
+        spaceAfterMarker = true;
+      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {
+        spaceAfterMarker = true;
+        if ((state.bsCount[nextLine] + initial) % 4 === 3) {
+          // '  >\t  test '
+          //       ^ -- position start of line here (tab has width===1)
+          pos++;
+          initial++;
+          adjustTab = false;
+        } else {
+          // ' >\t  test '
+          //    ^ -- position start of line here + shift bsCount slightly
+          //         to make extra space appear
+          adjustTab = true;
+        }
+      } else {
+        spaceAfterMarker = false;
+      }
+      let offset = initial;
+      oldBMarks.push(state.bMarks[nextLine]);
+      state.bMarks[nextLine] = pos;
+      while (pos < max) {
+        const ch = state.src.charCodeAt(pos);
+        if (isSpace(ch)) {
+          if (ch === 0x09) {
+            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
+          } else {
+            offset++;
+          }
+        } else {
+          break;
+        }
+        pos++;
+      }
+      lastLineEmpty = pos >= max;
+      oldBSCount.push(state.bsCount[nextLine]);
+      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
+      oldSCount.push(state.sCount[nextLine]);
+      state.sCount[nextLine] = offset - initial;
+      oldTShift.push(state.tShift[nextLine]);
+      state.tShift[nextLine] = pos - state.bMarks[nextLine];
+      continue;
+    }
 
-module.exports = {
-  options: {
-    html:         false,        // Enable HTML tags in source
-    xhtmlOut:     false,        // Use '/' to close single tags (<br />)
-    breaks:       false,        // Convert '\n' in paragraphs into <br>
-    langPrefix:   'language-',  // CSS language prefix for fenced blocks
-    linkify:      false,        // autoconvert URL-like texts to links
+    // Case 2: line is not inside the blockquote, and the last line was empty.
+    if (lastLineEmpty) {
+      break;
+    }
 
-    // Enable some language-neutral replacements + quotes beautification
-    typographer:  false,
+    // Case 3: another tag found.
+    let terminate = false;
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
+    }
+    if (terminate) {
+      // Quirk to enforce "hard termination mode" for paragraphs;
+      // normally if you call `tokenize(state, startLine, nextLine)`,
+      // paragraphs will look below nextLine for paragraph continuation,
+      // but if blockquote is terminated by another tag, they shouldn't
+      state.lineMax = nextLine;
+      if (state.blkIndent !== 0) {
+        // state.blkIndent was non-zero, we now set it to zero,
+        // so we need to re-calculate all offsets to appear as
+        // if indent wasn't changed
+        oldBMarks.push(state.bMarks[nextLine]);
+        oldBSCount.push(state.bsCount[nextLine]);
+        oldTShift.push(state.tShift[nextLine]);
+        oldSCount.push(state.sCount[nextLine]);
+        state.sCount[nextLine] -= state.blkIndent;
+      }
+      break;
+    }
+    oldBMarks.push(state.bMarks[nextLine]);
+    oldBSCount.push(state.bsCount[nextLine]);
+    oldTShift.push(state.tShift[nextLine]);
+    oldSCount.push(state.sCount[nextLine]);
 
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
+    // A negative indentation means that this is a paragraph continuation
     //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
+    state.sCount[nextLine] = -1;
+  }
+  const oldIndent = state.blkIndent;
+  state.blkIndent = 0;
+  const token_o = state.push('blockquote_open', 'blockquote', 1);
+  token_o.markup = '>';
+  const lines = [startLine, 0];
+  token_o.map = lines;
+  state.md.block.tokenize(state, startLine, nextLine);
+  const token_c = state.push('blockquote_close', 'blockquote', -1);
+  token_c.markup = '>';
+  state.lineMax = oldLineMax;
+  state.parentType = oldParentType;
+  lines[1] = state.line;
 
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
-    //
-    highlight: null,
+  // Restore original tShift; this might not be necessary since the parser
+  // has already been here, but just to make sure we can do that.
+  for (let i = 0; i < oldTShift.length; i++) {
+    state.bMarks[i + startLine] = oldBMarks[i];
+    state.tShift[i + startLine] = oldTShift[i];
+    state.sCount[i + startLine] = oldSCount[i];
+    state.bsCount[i + startLine] = oldBSCount[i];
+  }
+  state.blkIndent = oldIndent;
+  return true;
+}
 
-    maxNesting:   20            // Internal protection, recursion limit
-  },
+// Horizontal rule
 
-  components: {
+function hr(state, startLine, endLine, silent) {
+  const max = state.eMarks[startLine];
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  const marker = state.src.charCodeAt(pos++);
 
-    core: {
-      rules: [
-        'normalize',
-        'block',
-        'inline',
-        'text_join'
-      ]
-    },
+  // Check hr marker
+  if (marker !== 0x2A /* * */ && marker !== 0x2D /* - */ && marker !== 0x5F /* _ */) {
+    return false;
+  }
 
-    block: {
-      rules: [
-        'paragraph'
-      ]
-    },
+  // markers can be mixed with spaces, but there should be at least 3 of them
 
-    inline: {
-      rules: [
-        'text'
-      ],
-      rules2: [
-        'balance_pairs',
-        'fragments_join'
-      ]
+  let cnt = 1;
+  while (pos < max) {
+    const ch = state.src.charCodeAt(pos++);
+    if (ch !== marker && !isSpace(ch)) {
+      return false;
+    }
+    if (ch === marker) {
+      cnt++;
     }
   }
-};
+  if (cnt < 3) {
+    return false;
+  }
+  if (silent) {
+    return true;
+  }
+  state.line = startLine + 1;
+  const token = state.push('hr', 'hr', 0);
+  token.map = [startLine, state.line];
+  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
+  return true;
+}
 
+// Lists
 
-/***/ }),
 
-/***/ 7529:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+// Search `[-+*][\n ]`, returns next pos after marker on success
+// or -1 on fail.
+function skipBulletListMarker(state, startLine) {
+  const max = state.eMarks[startLine];
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  const marker = state.src.charCodeAt(pos++);
+  // Check bullet
+  if (marker !== 0x2A /* * */ && marker !== 0x2D /* - */ && marker !== 0x2B /* + */) {
+    return -1;
+  }
+  if (pos < max) {
+    const ch = state.src.charCodeAt(pos);
+    if (!isSpace(ch)) {
+      // " -test " - is not a list item
+      return -1;
+    }
+  }
+  return pos;
+}
 
-"use strict";
-/**
- * class Renderer
- *
- * Generates HTML from parsed token stream. Each instance has independent
- * copy of rules. Those can be rewritten with ease. Also, you can add new
- * rules if you create plugin and adds new token types.
- **/
+// Search `\d+[.)][\n ]`, returns next pos after marker on success
+// or -1 on fail.
+function skipOrderedListMarker(state, startLine) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  let pos = start;
 
+  // List marker should have at least 2 chars (digit + dot)
+  if (pos + 1 >= max) {
+    return -1;
+  }
+  let ch = state.src.charCodeAt(pos++);
+  if (ch < 0x30 /* 0 */ || ch > 0x39 /* 9 */) {
+    return -1;
+  }
+  for (;;) {
+    // EOL -> fail
+    if (pos >= max) {
+      return -1;
+    }
+    ch = state.src.charCodeAt(pos++);
+    if (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) {
+      // List marker should have no more than 9 digits
+      // (prevents integer overflow in browsers)
+      if (pos - start >= 10) {
+        return -1;
+      }
+      continue;
+    }
 
+    // found valid marker
+    if (ch === 0x29 /* ) */ || ch === 0x2e /* . */) {
+      break;
+    }
+    return -1;
+  }
+  if (pos < max) {
+    ch = state.src.charCodeAt(pos);
+    if (!isSpace(ch)) {
+      // " 1.test " - is not a list item
+      return -1;
+    }
+  }
+  return pos;
+}
+function markTightParagraphs(state, idx) {
+  const level = state.level + 2;
+  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
+    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
+      state.tokens[i + 2].hidden = true;
+      state.tokens[i].hidden = true;
+      i += 2;
+    }
+  }
+}
+function list(state, startLine, endLine, silent) {
+  let max, pos, start, token;
+  let nextLine = startLine;
+  let tight = true;
 
-var assign          = (__webpack_require__(7022).assign);
-var unescapeAll     = (__webpack_require__(7022).unescapeAll);
-var escapeHtml      = (__webpack_require__(7022).escapeHtml);
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[nextLine] - state.blkIndent >= 4) {
+    return false;
+  }
 
+  // Special case:
+  //  - item 1
+  //   - item 2
+  //    - item 3
+  //     - item 4
+  //      - this one is a paragraph continuation
+  if (state.listIndent >= 0 && state.sCount[nextLine] - state.listIndent >= 4 && state.sCount[nextLine] < state.blkIndent) {
+    return false;
+  }
+  let isTerminatingParagraph = false;
 
-////////////////////////////////////////////////////////////////////////////////
+  // limit conditions when list can interrupt
+  // a paragraph (validation mode only)
+  if (silent && state.parentType === 'paragraph') {
+    // Next list item should still terminate previous list item;
+    //
+    // This code can fail if plugins use blkIndent as well as lists,
+    // but I hope the spec gets fixed long before that happens.
+    //
+    if (state.sCount[nextLine] >= state.blkIndent) {
+      isTerminatingParagraph = true;
+    }
+  }
 
-var default_rules = {};
+  // Detect list type and position after marker
+  let isOrdered;
+  let markerValue;
+  let posAfterMarker;
+  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
+    isOrdered = true;
+    start = state.bMarks[nextLine] + state.tShift[nextLine];
+    markerValue = Number(state.src.slice(start, posAfterMarker - 1));
 
+    // If we're starting a new ordered list right after
+    // a paragraph, it should start with 1.
+    if (isTerminatingParagraph && markerValue !== 1) return false;
+  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
+    isOrdered = false;
+  } else {
+    return false;
+  }
 
-default_rules.code_inline = function (tokens, idx, options, env, slf) {
-  var token = tokens[idx];
-
-  return  '<code' + slf.renderAttrs(token) + '>' +
-          escapeHtml(tokens[idx].content) +
-          '</code>';
-};
+  // If we're starting a new unordered list right after
+  // a paragraph, first line should not be empty.
+  if (isTerminatingParagraph) {
+    if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false;
+  }
 
+  // For validation mode we can terminate immediately
+  if (silent) {
+    return true;
+  }
 
-default_rules.code_block = function (tokens, idx, options, env, slf) {
-  var token = tokens[idx];
+  // We should terminate list on style change. Remember first one to compare.
+  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
 
-  return  '<pre' + slf.renderAttrs(token) + '><code>' +
-          escapeHtml(tokens[idx].content) +
-          '</code></pre>\n';
-};
+  // Start list
+  const listTokIdx = state.tokens.length;
+  if (isOrdered) {
+    token = state.push('ordered_list_open', 'ol', 1);
+    if (markerValue !== 1) {
+      token.attrs = [['start', markerValue]];
+    }
+  } else {
+    token = state.push('bullet_list_open', 'ul', 1);
+  }
+  const listLines = [nextLine, 0];
+  token.map = listLines;
+  token.markup = String.fromCharCode(markerCharCode);
 
+  //
+  // Iterate list items
+  //
 
-default_rules.fence = function (tokens, idx, options, env, slf) {
-  var token = tokens[idx],
-      info = token.info ? unescapeAll(token.info).trim() : '',
-      langName = '',
-      langAttrs = '',
-      highlighted, i, arr, tmpAttrs, tmpToken;
+  let prevEmptyEnd = false;
+  const terminatorRules = state.md.block.ruler.getRules('list');
+  const oldParentType = state.parentType;
+  state.parentType = 'list';
+  while (nextLine < endLine) {
+    pos = posAfterMarker;
+    max = state.eMarks[nextLine];
+    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);
+    let offset = initial;
+    while (pos < max) {
+      const ch = state.src.charCodeAt(pos);
+      if (ch === 0x09) {
+        offset += 4 - (offset + state.bsCount[nextLine]) % 4;
+      } else if (ch === 0x20) {
+        offset++;
+      } else {
+        break;
+      }
+      pos++;
+    }
+    const contentStart = pos;
+    let indentAfterMarker;
+    if (contentStart >= max) {
+      // trimming space in "-    \n  3" case, indent is 1 here
+      indentAfterMarker = 1;
+    } else {
+      indentAfterMarker = offset - initial;
+    }
 
-  if (info) {
-    arr = info.split(/(\s+)/g);
-    langName = arr[0];
-    langAttrs = arr.slice(2).join('');
-  }
+    // If we have more than 4 spaces, the indent is 1
+    // (the rest is just indented code block)
+    if (indentAfterMarker > 4) {
+      indentAfterMarker = 1;
+    }
 
-  if (options.highlight) {
-    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
-  } else {
-    highlighted = escapeHtml(token.content);
-  }
+    // "  -  test"
+    //  ^^^^^ - calculating total length of this thing
+    const indent = initial + indentAfterMarker;
 
-  if (highlighted.indexOf('<pre') === 0) {
-    return highlighted + '\n';
-  }
+    // Run subparser & write tokens
+    token = state.push('list_item_open', 'li', 1);
+    token.markup = String.fromCharCode(markerCharCode);
+    const itemLines = [nextLine, 0];
+    token.map = itemLines;
+    if (isOrdered) {
+      token.info = state.src.slice(start, posAfterMarker - 1);
+    }
 
-  // If language exists, inject class gently, without modifying original token.
-  // May be, one day we will add .deepClone() for token and simplify this part, but
-  // now we prefer to keep things local.
-  if (info) {
-    i        = token.attrIndex('class');
-    tmpAttrs = token.attrs ? token.attrs.slice() : [];
+    // change current state, then restore it after parser subcall
+    const oldTight = state.tight;
+    const oldTShift = state.tShift[nextLine];
+    const oldSCount = state.sCount[nextLine];
 
-    if (i < 0) {
-      tmpAttrs.push([ 'class', options.langPrefix + langName ]);
+    //  - example list
+    // ^ listIndent position will be here
+    //   ^ blkIndent position will be here
+    //
+    const oldListIndent = state.listIndent;
+    state.listIndent = state.blkIndent;
+    state.blkIndent = indent;
+    state.tight = true;
+    state.tShift[nextLine] = contentStart - state.bMarks[nextLine];
+    state.sCount[nextLine] = offset;
+    if (contentStart >= max && state.isEmpty(nextLine + 1)) {
+      // workaround for this case
+      // (list item is empty, list terminates before "foo"):
+      // ~~~~~~~~
+      //   -
+      //
+      //     foo
+      // ~~~~~~~~
+      state.line = Math.min(state.line + 2, endLine);
     } else {
-      tmpAttrs[i] = tmpAttrs[i].slice();
-      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;
+      state.md.block.tokenize(state, nextLine, endLine, true);
     }
 
-    // Fake token just to render attributes
-    tmpToken = {
-      attrs: tmpAttrs
-    };
+    // If any of list item is tight, mark list as tight
+    if (!state.tight || prevEmptyEnd) {
+      tight = false;
+    }
+    // Item become loose if finish with empty line,
+    // but we should filter last element, because it means list finish
+    prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);
+    state.blkIndent = state.listIndent;
+    state.listIndent = oldListIndent;
+    state.tShift[nextLine] = oldTShift;
+    state.sCount[nextLine] = oldSCount;
+    state.tight = oldTight;
+    token = state.push('list_item_close', 'li', -1);
+    token.markup = String.fromCharCode(markerCharCode);
+    nextLine = state.line;
+    itemLines[1] = nextLine;
+    if (nextLine >= endLine) {
+      break;
+    }
 
-    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'
-          + highlighted
-          + '</code></pre>\n';
-  }
+    //
+    // Try to check if list is terminated or continued.
+    //
+    if (state.sCount[nextLine] < state.blkIndent) {
+      break;
+    }
 
+    // if it's indented more than 3 spaces, it should be a code block
+    if (state.sCount[nextLine] - state.blkIndent >= 4) {
+      break;
+    }
 
-  return  '<pre><code' + slf.renderAttrs(token) + '>'
-        + highlighted
-        + '</code></pre>\n';
-};
+    // fail if terminating block found
+    let terminate = false;
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
+    }
+    if (terminate) {
+      break;
+    }
 
+    // fail if list has another type
+    if (isOrdered) {
+      posAfterMarker = skipOrderedListMarker(state, nextLine);
+      if (posAfterMarker < 0) {
+        break;
+      }
+      start = state.bMarks[nextLine] + state.tShift[nextLine];
+    } else {
+      posAfterMarker = skipBulletListMarker(state, nextLine);
+      if (posAfterMarker < 0) {
+        break;
+      }
+    }
+    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
+      break;
+    }
+  }
 
-default_rules.image = function (tokens, idx, options, env, slf) {
-  var token = tokens[idx];
+  // Finalize list
+  if (isOrdered) {
+    token = state.push('ordered_list_close', 'ol', -1);
+  } else {
+    token = state.push('bullet_list_close', 'ul', -1);
+  }
+  token.markup = String.fromCharCode(markerCharCode);
+  listLines[1] = nextLine;
+  state.line = nextLine;
+  state.parentType = oldParentType;
 
-  // "alt" attr MUST be set, even if empty. Because it's mandatory and
-  // should be placed on proper position for tests.
-  //
-  // Replace content with actual value
+  // mark paragraphs tight if needed
+  if (tight) {
+    markTightParagraphs(state, listTokIdx);
+  }
+  return true;
+}
 
-  token.attrs[token.attrIndex('alt')][1] =
-    slf.renderInlineAsText(token.children, options, env);
+function reference(state, startLine, _endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  let max = state.eMarks[startLine];
+  let nextLine = startLine + 1;
 
-  return slf.renderToken(tokens, idx, options);
-};
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  if (state.src.charCodeAt(pos) !== 0x5B /* [ */) {
+    return false;
+  }
+  function getNextLine(nextLine) {
+    const endLine = state.lineMax;
+    if (nextLine >= endLine || state.isEmpty(nextLine)) {
+      // empty line or end of input
+      return null;
+    }
+    let isContinuation = false;
 
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) {
+      isContinuation = true;
+    }
 
-default_rules.hardbreak = function (tokens, idx, options /*, env */) {
-  return options.xhtmlOut ? '<br />\n' : '<br>\n';
-};
-default_rules.softbreak = function (tokens, idx, options /*, env */) {
-  return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n';
-};
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) {
+      isContinuation = true;
+    }
+    if (!isContinuation) {
+      const terminatorRules = state.md.block.ruler.getRules('reference');
+      const oldParentType = state.parentType;
+      state.parentType = 'reference';
+
+      // Some tags can terminate paragraph without empty line.
+      let terminate = false;
+      for (let i = 0, l = terminatorRules.length; i < l; i++) {
+        if (terminatorRules[i](state, nextLine, endLine, true)) {
+          terminate = true;
+          break;
+        }
+      }
+      state.parentType = oldParentType;
+      if (terminate) {
+        // terminated by another block
+        return null;
+      }
+    }
+    const pos = state.bMarks[nextLine] + state.tShift[nextLine];
+    const max = state.eMarks[nextLine];
 
+    // max + 1 explicitly includes the newline
+    return state.src.slice(pos, max + 1);
+  }
+  let str = state.src.slice(pos, max + 1);
+  max = str.length;
+  let labelEnd = -1;
+  for (pos = 1; pos < max; pos++) {
+    const ch = str.charCodeAt(pos);
+    if (ch === 0x5B /* [ */) {
+      return false;
+    } else if (ch === 0x5D /* ] */) {
+      labelEnd = pos;
+      break;
+    } else if (ch === 0x0A /* \n */) {
+      const lineContent = getNextLine(nextLine);
+      if (lineContent !== null) {
+        str += lineContent;
+        max = str.length;
+        nextLine++;
+      }
+    } else if (ch === 0x5C /* \ */) {
+      pos++;
+      if (pos < max && str.charCodeAt(pos) === 0x0A) {
+        const lineContent = getNextLine(nextLine);
+        if (lineContent !== null) {
+          str += lineContent;
+          max = str.length;
+          nextLine++;
+        }
+      }
+    }
+  }
+  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A /* : */) {
+    return false;
+  }
 
-default_rules.text = function (tokens, idx /*, options, env */) {
-  return escapeHtml(tokens[idx].content);
-};
+  // [label]:   destination   'title'
+  //         ^^^ skip optional whitespace here
+  for (pos = labelEnd + 2; pos < max; pos++) {
+    const ch = str.charCodeAt(pos);
+    if (ch === 0x0A) {
+      const lineContent = getNextLine(nextLine);
+      if (lineContent !== null) {
+        str += lineContent;
+        max = str.length;
+        nextLine++;
+      }
+    } else if (isSpace(ch)) ; else {
+      break;
+    }
+  }
 
+  // [label]:   destination   'title'
+  //            ^^^^^^^^^^^ parse this
+  const destRes = state.md.helpers.parseLinkDestination(str, pos, max);
+  if (!destRes.ok) {
+    return false;
+  }
+  const href = state.md.normalizeLink(destRes.str);
+  if (!state.md.validateLink(href)) {
+    return false;
+  }
+  pos = destRes.pos;
 
-default_rules.html_block = function (tokens, idx /*, options, env */) {
-  return tokens[idx].content;
-};
-default_rules.html_inline = function (tokens, idx /*, options, env */) {
-  return tokens[idx].content;
-};
+  // save cursor state, we could require to rollback later
+  const destEndPos = pos;
+  const destEndLineNo = nextLine;
 
+  // [label]:   destination   'title'
+  //                       ^^^ skipping those spaces
+  const start = pos;
+  for (; pos < max; pos++) {
+    const ch = str.charCodeAt(pos);
+    if (ch === 0x0A) {
+      const lineContent = getNextLine(nextLine);
+      if (lineContent !== null) {
+        str += lineContent;
+        max = str.length;
+        nextLine++;
+      }
+    } else if (isSpace(ch)) ; else {
+      break;
+    }
+  }
 
-/**
- * new Renderer()
- *
- * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
- **/
-function Renderer() {
+  // [label]:   destination   'title'
+  //                          ^^^^^^^ parse this
+  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
+  while (titleRes.can_continue) {
+    const lineContent = getNextLine(nextLine);
+    if (lineContent === null) break;
+    str += lineContent;
+    pos = max;
+    max = str.length;
+    nextLine++;
+    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
+  }
+  let title;
+  if (pos < max && start !== pos && titleRes.ok) {
+    title = titleRes.str;
+    pos = titleRes.pos;
+  } else {
+    title = '';
+    pos = destEndPos;
+    nextLine = destEndLineNo;
+  }
 
-  /**
-   * Renderer#rules -> Object
-   *
-   * Contains render rules for tokens. Can be updated and extended.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.renderer.rules.strong_open  = function () { return '<b>'; };
-   * md.renderer.rules.strong_close = function () { return '</b>'; };
-   *
-   * var result = md.renderInline(...);
-   * ```
-   *
-   * Each rule is called as independent static function with fixed signature:
-   *
-   * ```javascript
-   * function my_token_render(tokens, idx, options, env, renderer) {
-   *   // ...
-   *   return renderedHTML;
-   * }
-   * ```
-   *
-   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
-   * for more details and examples.
-   **/
-  this.rules = assign({}, default_rules);
-}
+  // skip trailing spaces until the rest of the line
+  while (pos < max) {
+    const ch = str.charCodeAt(pos);
+    if (!isSpace(ch)) {
+      break;
+    }
+    pos++;
+  }
+  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    if (title) {
+      // garbage at the end of the line after title,
+      // but it could still be a valid reference if we roll back
+      title = '';
+      pos = destEndPos;
+      nextLine = destEndLineNo;
+      while (pos < max) {
+        const ch = str.charCodeAt(pos);
+        if (!isSpace(ch)) {
+          break;
+        }
+        pos++;
+      }
+    }
+  }
+  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    // garbage at the end of the line
+    return false;
+  }
+  const label = normalizeReference(str.slice(1, labelEnd));
+  if (!label) {
+    // CommonMark 0.20 disallows empty labels
+    return false;
+  }
 
+  // Reference can not terminate anything. This check is for safety only.
+  /* istanbul ignore if */
+  if (silent) {
+    return true;
+  }
+  if (typeof state.env.references === 'undefined') {
+    state.env.references = {};
+  }
+  if (typeof state.env.references[label] === 'undefined') {
+    state.env.references[label] = {
+      title,
+      href
+    };
+  }
+  state.line = nextLine;
+  return true;
+}
 
-/**
- * Renderer.renderAttrs(token) -> String
- *
- * Render token attributes to string.
- **/
-Renderer.prototype.renderAttrs = function renderAttrs(token) {
-  var i, l, result;
+// List of valid html blocks names, according to commonmark spec
+// https://spec.commonmark.org/0.30/#html-blocks
 
-  if (!token.attrs) { return ''; }
+var block_names = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'search', 'section', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];
 
-  result = '';
+// Regexps to match html elements
 
-  for (i = 0, l = token.attrs.length; i < l; i++) {
-    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
-  }
+const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
+const unquoted = '[^"\'=<>`\\x00-\\x20]+';
+const single_quoted = "'[^']*'";
+const double_quoted = '"[^"]*"';
+const attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';
+const attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)';
+const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
+const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
+const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
+const processing = '<[?][\\s\\S]*?[?]>';
+const declaration = '<![A-Za-z][^>]*>';
+const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
+const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');
+const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');
 
-  return result;
-};
+// HTML block
 
 
-/**
- * Renderer.renderToken(tokens, idx, options) -> String
- * - tokens (Array): list of tokens
- * - idx (Numbed): token index to render
- * - options (Object): params of parser instance
- *
- * Default token renderer. Can be overriden by custom function
- * in [[Renderer#rules]].
- **/
-Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
-  var nextToken,
-      result = '',
-      needLf = false,
-      token = tokens[idx];
+// An array of opening and corresponding closing sequences for html tags,
+// last argument defines whether it can terminate a paragraph or not
+//
+const HTML_SEQUENCES = [[/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true], [/^<!--/, /-->/, true], [/^<\?/, /\?>/, true], [/^<![A-Z]/, />/, true], [/^<!\[CDATA\[/, /\]\]>/, true], [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'), /^$/, false]];
+function html_block(state, startLine, endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  let max = state.eMarks[startLine];
 
-  // Tight list paragraphs
-  if (token.hidden) {
-    return '';
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
   }
-
-  // Insert a newline between hidden paragraph and subsequent opening
-  // block-level tag.
-  //
-  // For example, here we should insert a newline before blockquote:
-  //  - a
-  //    >
-  //
-  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
-    result += '\n';
+  if (!state.md.options.html) {
+    return false;
   }
-
-  // Add token name, e.g. `<img`
-  result += (token.nesting === -1 ? '</' : '<') + token.tag;
-
-  // Encode attributes, e.g. `<img src="foo"`
-  result += this.renderAttrs(token);
-
-  // Add a slash for self-closing tags, e.g. `<img src="foo" /`
-  if (token.nesting === 0 && options.xhtmlOut) {
-    result += ' /';
+  if (state.src.charCodeAt(pos) !== 0x3C /* < */) {
+    return false;
   }
+  let lineText = state.src.slice(pos, max);
+  let i = 0;
+  for (; i < HTML_SEQUENCES.length; i++) {
+    if (HTML_SEQUENCES[i][0].test(lineText)) {
+      break;
+    }
+  }
+  if (i === HTML_SEQUENCES.length) {
+    return false;
+  }
+  if (silent) {
+    // true if this sequence can be a terminator, false otherwise
+    return HTML_SEQUENCES[i][2];
+  }
+  let nextLine = startLine + 1;
 
-  // Check if we need to add a newline after this tag
-  if (token.block) {
-    needLf = true;
-
-    if (token.nesting === 1) {
-      if (idx + 1 < tokens.length) {
-        nextToken = tokens[idx + 1];
-
-        if (nextToken.type === 'inline' || nextToken.hidden) {
-          // Block-level tag containing an inline tag.
-          //
-          needLf = false;
-
-        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
-          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
-          //
-          needLf = false;
+  // If we are here - we detected HTML block.
+  // Let's roll down till block end.
+  if (!HTML_SEQUENCES[i][1].test(lineText)) {
+    for (; nextLine < endLine; nextLine++) {
+      if (state.sCount[nextLine] < state.blkIndent) {
+        break;
+      }
+      pos = state.bMarks[nextLine] + state.tShift[nextLine];
+      max = state.eMarks[nextLine];
+      lineText = state.src.slice(pos, max);
+      if (HTML_SEQUENCES[i][1].test(lineText)) {
+        if (lineText.length !== 0) {
+          nextLine++;
         }
+        break;
       }
     }
   }
+  state.line = nextLine;
+  const token = state.push('html_block', '', 0);
+  token.map = [startLine, nextLine];
+  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
+  return true;
+}
 
-  result += needLf ? '>\n' : '>';
+// heading (#, ##, ...)
 
-  return result;
-};
+function heading(state, startLine, endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine];
+  let max = state.eMarks[startLine];
 
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  let ch = state.src.charCodeAt(pos);
+  if (ch !== 0x23 /* # */ || pos >= max) {
+    return false;
+  }
 
-/**
- * Renderer.renderInline(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * The same as [[Renderer.render]], but for single token of `inline` type.
- **/
-Renderer.prototype.renderInline = function (tokens, options, env) {
-  var type,
-      result = '',
-      rules = this.rules;
+  // count heading level
+  let level = 1;
+  ch = state.src.charCodeAt(++pos);
+  while (ch === 0x23 /* # */ && pos < max && level <= 6) {
+    level++;
+    ch = state.src.charCodeAt(++pos);
+  }
+  if (level > 6 || pos < max && !isSpace(ch)) {
+    return false;
+  }
+  if (silent) {
+    return true;
+  }
 
-  for (var i = 0, len = tokens.length; i < len; i++) {
-    type = tokens[i].type;
+  // Let's cut tails like '    ###  ' from the end of string
 
-    if (typeof rules[type] !== 'undefined') {
-      result += rules[type](tokens, i, options, env, this);
-    } else {
-      result += this.renderToken(tokens, i, options);
-    }
+  max = state.skipSpacesBack(max, pos);
+  const tmp = state.skipCharsBack(max, 0x23, pos); // #
+  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
+    max = tmp;
   }
+  state.line = startLine + 1;
+  const token_o = state.push('heading_open', 'h' + String(level), 1);
+  token_o.markup = '########'.slice(0, level);
+  token_o.map = [startLine, state.line];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = state.src.slice(pos, max).trim();
+  token_i.map = [startLine, state.line];
+  token_i.children = [];
+  const token_c = state.push('heading_close', 'h' + String(level), -1);
+  token_c.markup = '########'.slice(0, level);
+  return true;
+}
 
-  return result;
-};
-
+// lheading (---, ===)
 
-/** internal
- * Renderer.renderInlineAsText(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * Special kludge for image `alt` attributes to conform CommonMark spec.
- * Don't try to use it! Spec requires to show `alt` content with stripped markup,
- * instead of simple escaping.
- **/
-Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
-  var result = '';
+function lheading(state, startLine, endLine /*, silent */) {
+  const terminatorRules = state.md.block.ruler.getRules('paragraph');
 
-  for (var i = 0, len = tokens.length; i < len; i++) {
-    if (tokens[i].type === 'text') {
-      result += tokens[i].content;
-    } else if (tokens[i].type === 'image') {
-      result += this.renderInlineAsText(tokens[i].children, options, env);
-    } else if (tokens[i].type === 'softbreak') {
-      result += '\n';
-    }
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
   }
+  const oldParentType = state.parentType;
+  state.parentType = 'paragraph'; // use paragraph to match terminatorRules
 
-  return result;
-};
-
+  // jump line-by-line until empty one or EOF
+  let level = 0;
+  let marker;
+  let nextLine = startLine + 1;
+  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) {
+      continue;
+    }
 
-/**
- * Renderer.render(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * Takes token stream and generates HTML. Probably, you will never need to call
- * this method directly.
- **/
-Renderer.prototype.render = function (tokens, options, env) {
-  var i, len, type,
-      result = '',
-      rules = this.rules;
+    //
+    // Check for underline in setext header
+    //
+    if (state.sCount[nextLine] >= state.blkIndent) {
+      let pos = state.bMarks[nextLine] + state.tShift[nextLine];
+      const max = state.eMarks[nextLine];
+      if (pos < max) {
+        marker = state.src.charCodeAt(pos);
+        if (marker === 0x2D /* - */ || marker === 0x3D /* = */) {
+          pos = state.skipChars(pos, marker);
+          pos = state.skipSpaces(pos);
+          if (pos >= max) {
+            level = marker === 0x3D /* = */ ? 1 : 2;
+            break;
+          }
+        }
+      }
+    }
 
-  for (i = 0, len = tokens.length; i < len; i++) {
-    type = tokens[i].type;
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) {
+      continue;
+    }
 
-    if (type === 'inline') {
-      result += this.renderInline(tokens[i].children, options, env);
-    } else if (typeof rules[type] !== 'undefined') {
-      result += rules[tokens[i].type](tokens, i, options, env, this);
-    } else {
-      result += this.renderToken(tokens, i, options, env);
+    // Some tags can terminate paragraph without empty line.
+    let terminate = false;
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
     }
+    if (terminate) {
+      break;
+    }
+  }
+  if (!level) {
+    // Didn't find valid underline
+    return false;
   }
+  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
+  state.line = nextLine + 1;
+  const token_o = state.push('heading_open', 'h' + String(level), 1);
+  token_o.markup = String.fromCharCode(marker);
+  token_o.map = [startLine, state.line];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = content;
+  token_i.map = [startLine, state.line - 1];
+  token_i.children = [];
+  const token_c = state.push('heading_close', 'h' + String(level), -1);
+  token_c.markup = String.fromCharCode(marker);
+  state.parentType = oldParentType;
+  return true;
+}
 
-  return result;
-};
+// Paragraph
 
-module.exports = Renderer;
+function paragraph(state, startLine, endLine) {
+  const terminatorRules = state.md.block.ruler.getRules('paragraph');
+  const oldParentType = state.parentType;
+  let nextLine = startLine + 1;
+  state.parentType = 'paragraph';
 
+  // jump line-by-line until empty one or EOF
+  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) {
+      continue;
+    }
 
-/***/ }),
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) {
+      continue;
+    }
 
-/***/ 9580:
-/***/ ((module) => {
+    // Some tags can terminate paragraph without empty line.
+    let terminate = false;
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
+    }
+    if (terminate) {
+      break;
+    }
+  }
+  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
+  state.line = nextLine;
+  const token_o = state.push('paragraph_open', 'p', 1);
+  token_o.map = [startLine, state.line];
+  const token_i = state.push('inline', '', 0);
+  token_i.content = content;
+  token_i.map = [startLine, state.line];
+  token_i.children = [];
+  state.push('paragraph_close', 'p', -1);
+  state.parentType = oldParentType;
+  return true;
+}
 
-"use strict";
-/**
- * class Ruler
- *
- * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
- * [[MarkdownIt#inline]] to manage sequences of functions (rules):
- *
- * - keep rules in defined order
- * - assign the name to each rule
- * - enable/disable rules
- * - add/replace rules
- * - allow assign rules to additional named chains (in the same)
- * - cacheing lists of active rules
+/** internal
+ * class ParserBlock
  *
- * You will not need use this class directly until write plugins. For simple
- * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
- * [[MarkdownIt.use]].
+ * Block-level tokenizer.
  **/
 
-
+const _rules$1 = [
+// First 2 params - rule name & source. Secondary array - list of rules,
+// which can be terminated by this one.
+['table', table, ['paragraph', 'reference']], ['code', code], ['fence', fence, ['paragraph', 'reference', 'blockquote', 'list']], ['blockquote', blockquote, ['paragraph', 'reference', 'blockquote', 'list']], ['hr', hr, ['paragraph', 'reference', 'blockquote', 'list']], ['list', list, ['paragraph', 'reference', 'blockquote']], ['reference', reference], ['html_block', html_block, ['paragraph', 'reference', 'blockquote']], ['heading', heading, ['paragraph', 'reference', 'blockquote']], ['lheading', lheading], ['paragraph', paragraph]];
 
 /**
- * new Ruler()
+ * new ParserBlock()
  **/
-function Ruler() {
-  // List of added rules. Each element is:
-  //
-  // {
-  //   name: XXX,
-  //   enabled: Boolean,
-  //   fn: Function(),
-  //   alt: [ name2, name3 ]
-  // }
-  //
-  this.__rules__ = [];
-
-  // Cached rule chains.
-  //
-  // First level - chain name, '' for default.
-  // Second level - diginal anchor for fast filtering by charcodes.
-  //
-  this.__cache__ = null;
+function ParserBlock() {
+  /**
+   * ParserBlock#ruler -> Ruler
+   *
+   * [[Ruler]] instance. Keep configuration of block rules.
+   **/
+  this.ruler = new Ruler();
+  for (let i = 0; i < _rules$1.length; i++) {
+    this.ruler.push(_rules$1[i][0], _rules$1[i][1], {
+      alt: (_rules$1[i][2] || []).slice()
+    });
+  }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Helper methods, should not be used directly
-
-
-// Find rule index by name
+// Generate tokens for input range
 //
-Ruler.prototype.__find__ = function (name) {
-  for (var i = 0; i < this.__rules__.length; i++) {
-    if (this.__rules__[i].name === name) {
-      return i;
+ParserBlock.prototype.tokenize = function (state, startLine, endLine) {
+  const rules = this.ruler.getRules('');
+  const len = rules.length;
+  const maxNesting = state.md.options.maxNesting;
+  let line = startLine;
+  let hasEmptyLines = false;
+  while (line < endLine) {
+    state.line = line = state.skipEmptyLines(line);
+    if (line >= endLine) {
+      break;
     }
-  }
-  return -1;
-};
 
+    // Termination condition for nested calls.
+    // Nested calls currently used for blockquotes & lists
+    if (state.sCount[line] < state.blkIndent) {
+      break;
+    }
 
-// Build rules lookup cache
-//
-Ruler.prototype.__compile__ = function () {
-  var self = this;
-  var chains = [ '' ];
-
-  // collect unique names
-  self.__rules__.forEach(function (rule) {
-    if (!rule.enabled) { return; }
+    // If nesting level exceeded - skip tail to the end. That's not ordinary
+    // situation and we should not care about content.
+    if (state.level >= maxNesting) {
+      state.line = endLine;
+      break;
+    }
 
-    rule.alt.forEach(function (altName) {
-      if (chains.indexOf(altName) < 0) {
-        chains.push(altName);
+    // Try all possible rules.
+    // On success, rule should:
+    //
+    // - update `state.line`
+    // - update `state.tokens`
+    // - return true
+    const prevLine = state.line;
+    let ok = false;
+    for (let i = 0; i < len; i++) {
+      ok = rules[i](state, line, endLine, false);
+      if (ok) {
+        if (prevLine >= state.line) {
+          throw new Error("block rule didn't increment state.line");
+        }
+        break;
       }
-    });
-  });
-
-  self.__cache__ = {};
+    }
 
-  chains.forEach(function (chain) {
-    self.__cache__[chain] = [];
-    self.__rules__.forEach(function (rule) {
-      if (!rule.enabled) { return; }
+    // this can only happen if user disables paragraph rule
+    if (!ok) throw new Error('none of the block rules matched');
 
-      if (chain && rule.alt.indexOf(chain) < 0) { return; }
+    // set state.tight if we had an empty line before current tag
+    // i.e. latest empty line should not count
+    state.tight = !hasEmptyLines;
 
-      self.__cache__[chain].push(rule.fn);
-    });
-  });
+    // paragraph might "eat" one newline after it in nested lists
+    if (state.isEmpty(state.line - 1)) {
+      hasEmptyLines = true;
+    }
+    line = state.line;
+    if (line < endLine && state.isEmpty(line)) {
+      hasEmptyLines = true;
+      line++;
+      state.line = line;
+    }
+  }
 };
 
-
 /**
- * Ruler.at(name, fn [, options])
- * - name (String): rule name to replace.
- * - fn (Function): new rule function.
- * - options (Object): new rule options (not mandatory).
- *
- * Replace rule by name with new function & options. Throws error if name not
- * found.
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * Replace existing typographer replacement rule with new one:
- *
- * ```javascript
- * var md = require('markdown-it')();
+ * ParserBlock.parse(str, md, env, outTokens)
  *
- * md.core.ruler.at('replacements', function replace(state) {
- *   //...
- * });
- * ```
+ * Process input string and push block tokens into `outTokens`
  **/
-Ruler.prototype.at = function (name, fn, options) {
-  var index = this.__find__(name);
-  var opt = options || {};
-
-  if (index === -1) { throw new Error('Parser rule not found: ' + name); }
-
-  this.__rules__[index].fn = fn;
-  this.__rules__[index].alt = opt.alt || [];
-  this.__cache__ = null;
+ParserBlock.prototype.parse = function (src, md, env, outTokens) {
+  if (!src) {
+    return;
+  }
+  const state = new this.State(src, md, env, outTokens);
+  this.tokenize(state, state.line, state.lineMax);
 };
+ParserBlock.prototype.State = StateBlock;
 
+// Inline parser state
 
-/**
- * Ruler.before(beforeName, ruleName, fn [, options])
- * - beforeName (String): new rule will be added before this one.
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Add new rule to chain before one with given name. See also
- * [[Ruler.after]], [[Ruler.push]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
-  var index = this.__find__(beforeName);
-  var opt = options || {};
+function StateInline(src, md, env, outTokens) {
+  this.src = src;
+  this.env = env;
+  this.md = md;
+  this.tokens = outTokens;
+  this.tokens_meta = Array(outTokens.length);
+  this.pos = 0;
+  this.posMax = this.src.length;
+  this.level = 0;
+  this.pending = '';
+  this.pendingLevel = 0;
 
-  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName); }
+  // Stores { start: end } pairs. Useful for backtrack
+  // optimization of pairs parse (emphasis, strikes).
+  this.cache = {};
 
-  this.__rules__.splice(index, 0, {
-    name: ruleName,
-    enabled: true,
-    fn: fn,
-    alt: opt.alt || []
-  });
+  // List of emphasis-like delimiters for current tag
+  this.delimiters = [];
 
-  this.__cache__ = null;
-};
+  // Stack of delimiter lists for upper level tags
+  this._prev_delimiters = [];
 
+  // backtick length => last seen position
+  this.backticks = {};
+  this.backticksScanned = false;
 
-/**
- * Ruler.after(afterName, ruleName, fn [, options])
- * - afterName (String): new rule will be added after this one.
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Add new rule to chain after one with given name. See also
- * [[Ruler.before]], [[Ruler.push]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.inline.ruler.after('text', 'my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.after = function (afterName, ruleName, fn, options) {
-  var index = this.__find__(afterName);
-  var opt = options || {};
-
-  if (index === -1) { throw new Error('Parser rule not found: ' + afterName); }
+  // Counter used to disable inline linkify-it execution
+  // inside <a> and markdown links
+  this.linkLevel = 0;
+}
 
-  this.__rules__.splice(index + 1, 0, {
-    name: ruleName,
-    enabled: true,
-    fn: fn,
-    alt: opt.alt || []
-  });
+// Flush pending text
+//
+StateInline.prototype.pushPending = function () {
+  const token = new Token('text', '', 0);
+  token.content = this.pending;
+  token.level = this.pendingLevel;
+  this.tokens.push(token);
+  this.pending = '';
+  return token;
+};
 
-  this.__cache__ = null;
+// Push new token to "stream".
+// If pending text exists - flush it as text token
+//
+StateInline.prototype.push = function (type, tag, nesting) {
+  if (this.pending) {
+    this.pushPending();
+  }
+  const token = new Token(type, tag, nesting);
+  let token_meta = null;
+  if (nesting < 0) {
+    // closing tag
+    this.level--;
+    this.delimiters = this._prev_delimiters.pop();
+  }
+  token.level = this.level;
+  if (nesting > 0) {
+    // opening tag
+    this.level++;
+    this._prev_delimiters.push(this.delimiters);
+    this.delimiters = [];
+    token_meta = {
+      delimiters: this.delimiters
+    };
+  }
+  this.pendingLevel = this.level;
+  this.tokens.push(token);
+  this.tokens_meta.push(token_meta);
+  return token;
 };
 
-/**
- * Ruler.push(ruleName, fn [, options])
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Push new rule to the end of chain. See also
- * [[Ruler.before]], [[Ruler.after]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.core.ruler.push('my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.push = function (ruleName, fn, options) {
-  var opt = options || {};
+// Scan a sequence of emphasis-like markers, and determine whether
+// it can start an emphasis sequence or end an emphasis sequence.
+//
+//  - start - position to scan from (it should point at a valid marker);
+//  - canSplitWord - determine if these markers can be found inside a word
+//
+StateInline.prototype.scanDelims = function (start, canSplitWord) {
+  const max = this.posMax;
+  const marker = this.src.charCodeAt(start);
 
-  this.__rules__.push({
-    name: ruleName,
-    enabled: true,
-    fn: fn,
-    alt: opt.alt || []
-  });
+  // treat beginning of the line as a whitespace
+  const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;
+  let pos = start;
+  while (pos < max && this.src.charCodeAt(pos) === marker) {
+    pos++;
+  }
+  const count = pos - start;
 
-  this.__cache__ = null;
+  // treat end of the line as a whitespace
+  const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;
+  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
+  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+  const isLastWhiteSpace = isWhiteSpace(lastChar);
+  const isNextWhiteSpace = isWhiteSpace(nextChar);
+  const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
+  const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
+  const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar);
+  const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar);
+  return {
+    can_open,
+    can_close,
+    length: count
+  };
 };
 
+// re-export Token class to use in block rules
+StateInline.prototype.Token = Token;
 
-/**
- * Ruler.enable(list [, ignoreInvalid]) -> Array
- * - list (String|Array): list of rule names to enable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable rules with given names. If any rule name not found - throw Error.
- * Errors can be disabled by second param.
- *
- * Returns list of found rule names (if no exception happened).
- *
- * See also [[Ruler.disable]], [[Ruler.enableOnly]].
- **/
-Ruler.prototype.enable = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [ list ]; }
-
-  var result = [];
+// Skip text characters for text token, place those to pending buffer
+// and increment current pos
 
-  // Search by name and enable
-  list.forEach(function (name) {
-    var idx = this.__find__(name);
+// Rule to skip pure text
+// '{}$%@~+=:' reserved for extentions
 
-    if (idx < 0) {
-      if (ignoreInvalid) { return; }
-      throw new Error('Rules manager: invalid rule name ' + name);
-    }
-    this.__rules__[idx].enabled = true;
-    result.push(name);
-  }, this);
+// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
 
-  this.__cache__ = null;
-  return result;
-};
+// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
+// http://spec.commonmark.org/0.15/#ascii-punctuation-character
+function isTerminatorChar(ch) {
+  switch (ch) {
+    case 0x0A /* \n */:
+    case 0x21 /* ! */:
+    case 0x23 /* # */:
+    case 0x24 /* $ */:
+    case 0x25 /* % */:
+    case 0x26 /* & */:
+    case 0x2A /* * */:
+    case 0x2B /* + */:
+    case 0x2D /* - */:
+    case 0x3A /* : */:
+    case 0x3C /* < */:
+    case 0x3D /* = */:
+    case 0x3E /* > */:
+    case 0x40 /* @ */:
+    case 0x5B /* [ */:
+    case 0x5C /* \ */:
+    case 0x5D /* ] */:
+    case 0x5E /* ^ */:
+    case 0x5F /* _ */:
+    case 0x60 /* ` */:
+    case 0x7B /* { */:
+    case 0x7D /* } */:
+    case 0x7E /* ~ */:
+      return true;
+    default:
+      return false;
+  }
+}
+function text(state, silent) {
+  let pos = state.pos;
+  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
+    pos++;
+  }
+  if (pos === state.pos) {
+    return false;
+  }
+  if (!silent) {
+    state.pending += state.src.slice(state.pos, pos);
+  }
+  state.pos = pos;
+  return true;
+}
 
+// Alternative implementation, for memory.
+//
+// It costs 10% of performance, but allows extend terminators list, if place it
+// to `ParserInline` property. Probably, will switch to it sometime, such
+// flexibility required.
 
-/**
- * Ruler.enableOnly(list [, ignoreInvalid])
- * - list (String|Array): list of rule names to enable (whitelist).
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable rules with given names, and disable everything else. If any rule name
- * not found - throw Error. Errors can be disabled by second param.
- *
- * See also [[Ruler.disable]], [[Ruler.enable]].
- **/
-Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [ list ]; }
+/*
+var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;
 
-  this.__rules__.forEach(function (rule) { rule.enabled = false; });
+module.exports = function text(state, silent) {
+  var pos = state.pos,
+      idx = state.src.slice(pos).search(TERMINATOR_RE);
 
-  this.enable(list, ignoreInvalid);
-};
+  // first char is terminator -> empty text
+  if (idx === 0) { return false; }
 
+  // no terminator -> text till end of string
+  if (idx < 0) {
+    if (!silent) { state.pending += state.src.slice(pos); }
+    state.pos = state.src.length;
+    return true;
+  }
 
-/**
- * Ruler.disable(list [, ignoreInvalid]) -> Array
- * - list (String|Array): list of rule names to disable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Disable rules with given names. If any rule name not found - throw Error.
- * Errors can be disabled by second param.
- *
- * Returns list of found rule names (if no exception happened).
- *
- * See also [[Ruler.enable]], [[Ruler.enableOnly]].
- **/
-Ruler.prototype.disable = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [ list ]; }
+  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }
 
-  var result = [];
+  state.pos += idx;
 
-  // Search by name and disable
-  list.forEach(function (name) {
-    var idx = this.__find__(name);
+  return true;
+}; */
 
-    if (idx < 0) {
-      if (ignoreInvalid) { return; }
-      throw new Error('Rules manager: invalid rule name ' + name);
-    }
-    this.__rules__[idx].enabled = false;
-    result.push(name);
-  }, this);
+// Process links like https://example.org/
 
-  this.__cache__ = null;
-  return result;
-};
+// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+const SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
+function linkify(state, silent) {
+  if (!state.md.options.linkify) return false;
+  if (state.linkLevel > 0) return false;
+  const pos = state.pos;
+  const max = state.posMax;
+  if (pos + 3 > max) return false;
+  if (state.src.charCodeAt(pos) !== 0x3A /* : */) return false;
+  if (state.src.charCodeAt(pos + 1) !== 0x2F /* / */) return false;
+  if (state.src.charCodeAt(pos + 2) !== 0x2F /* / */) return false;
+  const match = state.pending.match(SCHEME_RE);
+  if (!match) return false;
+  const proto = match[1];
+  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
+  if (!link) return false;
+  let url = link.url;
 
+  // invalid link, but still detected by linkify somehow;
+  // need to check to prevent infinite loop below
+  if (url.length <= proto.length) return false;
 
-/**
- * Ruler.getRules(chainName) -> Array
- *
- * Return array of active functions (rules) for given chain name. It analyzes
- * rules configuration, compiles caches if not exists and returns result.
- *
- * Default chain name is `''` (empty string). It can't be skipped. That's
- * done intentionally, to keep signature monomorphic for high speed.
- **/
-Ruler.prototype.getRules = function (chainName) {
-  if (this.__cache__ === null) {
-    this.__compile__();
+  // disallow '*' at the end of the link (conflicts with emphasis)
+  url = url.replace(/\*+$/, '');
+  const fullUrl = state.md.normalizeLink(url);
+  if (!state.md.validateLink(fullUrl)) return false;
+  if (!silent) {
+    state.pending = state.pending.slice(0, -proto.length);
+    const token_o = state.push('link_open', 'a', 1);
+    token_o.attrs = [['href', fullUrl]];
+    token_o.markup = 'linkify';
+    token_o.info = 'auto';
+    const token_t = state.push('text', '', 0);
+    token_t.content = state.md.normalizeLinkText(url);
+    const token_c = state.push('link_close', 'a', -1);
+    token_c.markup = 'linkify';
+    token_c.info = 'auto';
   }
+  state.pos += url.length - proto.length;
+  return true;
+}
 
-  // Chain can be empty, if rules disabled. But we still have to return Array.
-  return this.__cache__[chainName] || [];
-};
-
-module.exports = Ruler;
-
-
-/***/ }),
+// Proceess '\n'
 
-/***/ 5258:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+function newline(state, silent) {
+  let pos = state.pos;
+  if (state.src.charCodeAt(pos) !== 0x0A /* \n */) {
+    return false;
+  }
+  const pmax = state.pending.length - 1;
+  const max = state.posMax;
 
-"use strict";
-// Block quotes
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function blockquote(state, startLine, endLine, silent) {
-  var adjustTab,
-      ch,
-      i,
-      initial,
-      l,
-      lastLineEmpty,
-      lines,
-      nextLine,
-      offset,
-      oldBMarks,
-      oldBSCount,
-      oldIndent,
-      oldParentType,
-      oldSCount,
-      oldTShift,
-      spaceAfterMarker,
-      terminate,
-      terminatorRules,
-      token,
-      isOutdented,
-      oldLineMax = state.lineMax,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine];
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
+  // '  \n' -> hardbreak
+  // Lookup in pending chars is bad practice! Don't copy to other rules!
+  // Pending string is stored in concat mode, indexed lookups will cause
+  // convertion to flat mode.
+  if (!silent) {
+    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
+      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
+        // Find whitespaces tail of pending chars.
+        let ws = pmax - 1;
+        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--;
+        state.pending = state.pending.slice(0, ws);
+        state.push('hardbreak', 'br', 0);
+      } else {
+        state.pending = state.pending.slice(0, -1);
+        state.push('softbreak', 'br', 0);
+      }
+    } else {
+      state.push('softbreak', 'br', 0);
+    }
+  }
+  pos++;
 
-  // check the block quote marker
-  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; }
+  // skip heading spaces for next line
+  while (pos < max && isSpace(state.src.charCodeAt(pos))) {
+    pos++;
+  }
+  state.pos = pos;
+  return true;
+}
 
-  // we know that it's going to be a valid blockquote,
-  // so no point trying to find the end of it in silent mode
-  if (silent) { return true; }
+// Process escaped chars and hardbreaks
 
-  // set offset past spaces and ">"
-  initial = offset = state.sCount[startLine] + 1;
+const ESCAPED = [];
+for (let i = 0; i < 256; i++) {
+  ESCAPED.push(0);
+}
+'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'.split('').forEach(function (ch) {
+  ESCAPED[ch.charCodeAt(0)] = 1;
+});
+function escape(state, silent) {
+  let pos = state.pos;
+  const max = state.posMax;
+  if (state.src.charCodeAt(pos) !== 0x5C /* \ */) return false;
+  pos++;
 
-  // skip one optional space after '>'
-  if (state.src.charCodeAt(pos) === 0x20 /* space */) {
-    // ' >   test '
-    //     ^ -- position start of line here:
+  // '\' at the end of the inline block
+  if (pos >= max) return false;
+  let ch1 = state.src.charCodeAt(pos);
+  if (ch1 === 0x0A) {
+    if (!silent) {
+      state.push('hardbreak', 'br', 0);
+    }
     pos++;
-    initial++;
-    offset++;
-    adjustTab = false;
-    spaceAfterMarker = true;
-  } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {
-    spaceAfterMarker = true;
-
-    if ((state.bsCount[startLine] + offset) % 4 === 3) {
-      // '  >\t  test '
-      //       ^ -- position start of line here (tab has width===1)
+    // skip leading whitespaces from next line
+    while (pos < max) {
+      ch1 = state.src.charCodeAt(pos);
+      if (!isSpace(ch1)) break;
+      pos++;
+    }
+    state.pos = pos;
+    return true;
+  }
+  let escapedStr = state.src[pos];
+  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
+    const ch2 = state.src.charCodeAt(pos + 1);
+    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
+      escapedStr += state.src[pos + 1];
       pos++;
-      initial++;
-      offset++;
-      adjustTab = false;
+    }
+  }
+  const origStr = '\\' + escapedStr;
+  if (!silent) {
+    const token = state.push('text_special', '', 0);
+    if (ch1 < 256 && ESCAPED[ch1] !== 0) {
+      token.content = escapedStr;
     } else {
-      // ' >\t  test '
-      //    ^ -- position start of line here + shift bsCount slightly
-      //         to make extra space appear
-      adjustTab = true;
+      token.content = origStr;
     }
-  } else {
-    spaceAfterMarker = false;
+    token.markup = origStr;
+    token.info = 'escape';
   }
+  state.pos = pos + 1;
+  return true;
+}
 
-  oldBMarks = [ state.bMarks[startLine] ];
-  state.bMarks[startLine] = pos;
-
-  while (pos < max) {
-    ch = state.src.charCodeAt(pos);
+// Parse backticks
 
-    if (isSpace(ch)) {
-      if (ch === 0x09) {
-        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;
-      } else {
-        offset++;
-      }
-    } else {
-      break;
-    }
+function backtick(state, silent) {
+  let pos = state.pos;
+  const ch = state.src.charCodeAt(pos);
+  if (ch !== 0x60 /* ` */) {
+    return false;
+  }
+  const start = pos;
+  pos++;
+  const max = state.posMax;
 
+  // scan marker length
+  while (pos < max && state.src.charCodeAt(pos) === 0x60 /* ` */) {
     pos++;
   }
+  const marker = state.src.slice(start, pos);
+  const openerLength = marker.length;
+  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
+    if (!silent) state.pending += marker;
+    state.pos += openerLength;
+    return true;
+  }
+  let matchEnd = pos;
+  let matchStart;
 
-  oldBSCount = [ state.bsCount[startLine] ];
-  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);
+  // Nothing found in the cache, scan until the end of the line (or until marker is found)
+  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
+    matchEnd = matchStart + 1;
 
-  lastLineEmpty = pos >= max;
+    // scan marker length
+    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60 /* ` */) {
+      matchEnd++;
+    }
+    const closerLength = matchEnd - matchStart;
+    if (closerLength === openerLength) {
+      // Found matching closer length.
+      if (!silent) {
+        const token = state.push('code_inline', 'code', 0);
+        token.markup = marker;
+        token.content = state.src.slice(pos, matchStart).replace(/\n/g, ' ').replace(/^ (.+) $/, '$1');
+      }
+      state.pos = matchEnd;
+      return true;
+    }
 
-  oldSCount = [ state.sCount[startLine] ];
-  state.sCount[startLine] = offset - initial;
+    // Some different length found, put it in cache as upper limit of where closer can be found
+    state.backticks[closerLength] = matchStart;
+  }
 
-  oldTShift = [ state.tShift[startLine] ];
-  state.tShift[startLine] = pos - state.bMarks[startLine];
+  // Scanned through the end, didn't find anything
+  state.backticksScanned = true;
+  if (!silent) state.pending += marker;
+  state.pos += openerLength;
+  return true;
+}
 
-  terminatorRules = state.md.block.ruler.getRules('blockquote');
+// ~~strike through~~
+//
 
-  oldParentType = state.parentType;
-  state.parentType = 'blockquote';
+// Insert each marker as a separate text token, and add it to delimiter list
+//
+function strikethrough_tokenize(state, silent) {
+  const start = state.pos;
+  const marker = state.src.charCodeAt(start);
+  if (silent) {
+    return false;
+  }
+  if (marker !== 0x7E /* ~ */) {
+    return false;
+  }
+  const scanned = state.scanDelims(state.pos, true);
+  let len = scanned.length;
+  const ch = String.fromCharCode(marker);
+  if (len < 2) {
+    return false;
+  }
+  let token;
+  if (len % 2) {
+    token = state.push('text', '', 0);
+    token.content = ch;
+    len--;
+  }
+  for (let i = 0; i < len; i += 2) {
+    token = state.push('text', '', 0);
+    token.content = ch + ch;
+    state.delimiters.push({
+      marker,
+      length: 0,
+      // disable "rule of 3" length checks meant for emphasis
+      token: state.tokens.length - 1,
+      end: -1,
+      open: scanned.can_open,
+      close: scanned.can_close
+    });
+  }
+  state.pos += scanned.length;
+  return true;
+}
+function postProcess$1(state, delimiters) {
+  let token;
+  const loneMarkers = [];
+  const max = delimiters.length;
+  for (let i = 0; i < max; i++) {
+    const startDelim = delimiters[i];
+    if (startDelim.marker !== 0x7E /* ~ */) {
+      continue;
+    }
+    if (startDelim.end === -1) {
+      continue;
+    }
+    const endDelim = delimiters[startDelim.end];
+    token = state.tokens[startDelim.token];
+    token.type = 's_open';
+    token.tag = 's';
+    token.nesting = 1;
+    token.markup = '~~';
+    token.content = '';
+    token = state.tokens[endDelim.token];
+    token.type = 's_close';
+    token.tag = 's';
+    token.nesting = -1;
+    token.markup = '~~';
+    token.content = '';
+    if (state.tokens[endDelim.token - 1].type === 'text' && state.tokens[endDelim.token - 1].content === '~') {
+      loneMarkers.push(endDelim.token - 1);
+    }
+  }
 
-  // Search the end of the block
+  // If a marker sequence has an odd number of characters, it's splitted
+  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
+  // start of the sequence.
   //
-  // Block ends with either:
-  //  1. an empty line outside:
-  //     ```
-  //     > test
+  // So, we have to move all those markers after subsequent s_close tags.
   //
-  //     ```
-  //  2. an empty line inside:
-  //     ```
-  //     >
-  //     test
-  //     ```
-  //  3. another tag:
-  //     ```
-  //     > test
-  //      - - -
-  //     ```
-  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
-    // check if it's outdented, i.e. it's inside list item and indented
-    // less than said list item:
-    //
-    // ```
-    // 1. anything
-    //    > current blockquote
-    // 2. checking this line
-    // ```
-    isOutdented = state.sCount[nextLine] < state.blkIndent;
-
-    pos = state.bMarks[nextLine] + state.tShift[nextLine];
-    max = state.eMarks[nextLine];
+  while (loneMarkers.length) {
+    const i = loneMarkers.pop();
+    let j = i + 1;
+    while (j < state.tokens.length && state.tokens[j].type === 's_close') {
+      j++;
+    }
+    j--;
+    if (i !== j) {
+      token = state.tokens[j];
+      state.tokens[j] = state.tokens[i];
+      state.tokens[i] = token;
+    }
+  }
+}
 
-    if (pos >= max) {
-      // Case 1: line is not inside the blockquote, and this line is empty.
-      break;
+// Walk through delimiter list and replace text tokens with tags
+//
+function strikethrough_postProcess(state) {
+  const tokens_meta = state.tokens_meta;
+  const max = state.tokens_meta.length;
+  postProcess$1(state, state.delimiters);
+  for (let curr = 0; curr < max; curr++) {
+    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
+      postProcess$1(state, tokens_meta[curr].delimiters);
     }
+  }
+}
+var r_strikethrough = {
+  tokenize: strikethrough_tokenize,
+  postProcess: strikethrough_postProcess
+};
 
-    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {
-      // This line is inside the blockquote.
+// Process *this* and _that_
+//
 
-      // set offset past spaces and ">"
-      initial = offset = state.sCount[nextLine] + 1;
+// Insert each marker as a separate text token, and add it to delimiter list
+//
+function emphasis_tokenize(state, silent) {
+  const start = state.pos;
+  const marker = state.src.charCodeAt(start);
+  if (silent) {
+    return false;
+  }
+  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) {
+    return false;
+  }
+  const scanned = state.scanDelims(state.pos, marker === 0x2A);
+  for (let i = 0; i < scanned.length; i++) {
+    const token = state.push('text', '', 0);
+    token.content = String.fromCharCode(marker);
+    state.delimiters.push({
+      // Char code of the starting marker (number).
+      //
+      marker,
+      // Total length of these series of delimiters.
+      //
+      length: scanned.length,
+      // A position of the token this delimiter corresponds to.
+      //
+      token: state.tokens.length - 1,
+      // If this delimiter is matched as a valid opener, `end` will be
+      // equal to its position, otherwise it's `-1`.
+      //
+      end: -1,
+      // Boolean flags that determine if this delimiter could open or close
+      // an emphasis.
+      //
+      open: scanned.can_open,
+      close: scanned.can_close
+    });
+  }
+  state.pos += scanned.length;
+  return true;
+}
+function postProcess(state, delimiters) {
+  const max = delimiters.length;
+  for (let i = max - 1; i >= 0; i--) {
+    const startDelim = delimiters[i];
+    if (startDelim.marker !== 0x5F /* _ */ && startDelim.marker !== 0x2A /* * */) {
+      continue;
+    }
 
-      // skip one optional space after '>'
-      if (state.src.charCodeAt(pos) === 0x20 /* space */) {
-        // ' >   test '
-        //     ^ -- position start of line here:
-        pos++;
-        initial++;
-        offset++;
-        adjustTab = false;
-        spaceAfterMarker = true;
-      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {
-        spaceAfterMarker = true;
+    // Process only opening markers
+    if (startDelim.end === -1) {
+      continue;
+    }
+    const endDelim = delimiters[startDelim.end];
 
-        if ((state.bsCount[nextLine] + offset) % 4 === 3) {
-          // '  >\t  test '
-          //       ^ -- position start of line here (tab has width===1)
-          pos++;
-          initial++;
-          offset++;
-          adjustTab = false;
-        } else {
-          // ' >\t  test '
-          //    ^ -- position start of line here + shift bsCount slightly
-          //         to make extra space appear
-          adjustTab = true;
-        }
-      } else {
-        spaceAfterMarker = false;
-      }
-
-      oldBMarks.push(state.bMarks[nextLine]);
-      state.bMarks[nextLine] = pos;
-
-      while (pos < max) {
-        ch = state.src.charCodeAt(pos);
-
-        if (isSpace(ch)) {
-          if (ch === 0x09) {
-            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
-          } else {
-            offset++;
-          }
-        } else {
-          break;
-        }
-
-        pos++;
-      }
+    // If the previous delimiter has the same marker and is adjacent to this one,
+    // merge those into one strong delimiter.
+    //
+    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
+    //
+    const isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 &&
+    // check that first two markers match and adjacent
+    delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 &&
+    // check that last two markers are adjacent (we can safely assume they match)
+    delimiters[startDelim.end + 1].token === endDelim.token + 1;
+    const ch = String.fromCharCode(startDelim.marker);
+    const token_o = state.tokens[startDelim.token];
+    token_o.type = isStrong ? 'strong_open' : 'em_open';
+    token_o.tag = isStrong ? 'strong' : 'em';
+    token_o.nesting = 1;
+    token_o.markup = isStrong ? ch + ch : ch;
+    token_o.content = '';
+    const token_c = state.tokens[endDelim.token];
+    token_c.type = isStrong ? 'strong_close' : 'em_close';
+    token_c.tag = isStrong ? 'strong' : 'em';
+    token_c.nesting = -1;
+    token_c.markup = isStrong ? ch + ch : ch;
+    token_c.content = '';
+    if (isStrong) {
+      state.tokens[delimiters[i - 1].token].content = '';
+      state.tokens[delimiters[startDelim.end + 1].token].content = '';
+      i--;
+    }
+  }
+}
 
-      lastLineEmpty = pos >= max;
+// Walk through delimiter list and replace text tokens with tags
+//
+function emphasis_post_process(state) {
+  const tokens_meta = state.tokens_meta;
+  const max = state.tokens_meta.length;
+  postProcess(state, state.delimiters);
+  for (let curr = 0; curr < max; curr++) {
+    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
+      postProcess(state, tokens_meta[curr].delimiters);
+    }
+  }
+}
+var r_emphasis = {
+  tokenize: emphasis_tokenize,
+  postProcess: emphasis_post_process
+};
 
-      oldBSCount.push(state.bsCount[nextLine]);
-      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
+// Process [link](<to> "stuff")
 
-      oldSCount.push(state.sCount[nextLine]);
-      state.sCount[nextLine] = offset - initial;
+function link(state, silent) {
+  let code, label, res, ref;
+  let href = '';
+  let title = '';
+  let start = state.pos;
+  let parseReference = true;
+  if (state.src.charCodeAt(state.pos) !== 0x5B /* [ */) {
+    return false;
+  }
+  const oldPos = state.pos;
+  const max = state.posMax;
+  const labelStart = state.pos + 1;
+  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
 
-      oldTShift.push(state.tShift[nextLine]);
-      state.tShift[nextLine] = pos - state.bMarks[nextLine];
-      continue;
-    }
+  // parser failed to find ']', so it's not a valid link
+  if (labelEnd < 0) {
+    return false;
+  }
+  let pos = labelEnd + 1;
+  if (pos < max && state.src.charCodeAt(pos) === 0x28 /* ( */) {
+    //
+    // Inline link
+    //
 
-    // Case 2: line is not inside the blockquote, and the last line was empty.
-    if (lastLineEmpty) { break; }
+    // might have found a valid shortcut link, disable reference parsing
+    parseReference = false;
 
-    // Case 3: another tag found.
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
+    // [link](  <href>  "title"  )
+    //        ^^ skipping these spaces
+    pos++;
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos);
+      if (!isSpace(code) && code !== 0x0A) {
         break;
       }
     }
-
-    if (terminate) {
-      // Quirk to enforce "hard termination mode" for paragraphs;
-      // normally if you call `tokenize(state, startLine, nextLine)`,
-      // paragraphs will look below nextLine for paragraph continuation,
-      // but if blockquote is terminated by another tag, they shouldn't
-      state.lineMax = nextLine;
-
-      if (state.blkIndent !== 0) {
-        // state.blkIndent was non-zero, we now set it to zero,
-        // so we need to re-calculate all offsets to appear as
-        // if indent wasn't changed
-        oldBMarks.push(state.bMarks[nextLine]);
-        oldBSCount.push(state.bsCount[nextLine]);
-        oldTShift.push(state.tShift[nextLine]);
-        oldSCount.push(state.sCount[nextLine]);
-        state.sCount[nextLine] -= state.blkIndent;
-      }
-
-      break;
+    if (pos >= max) {
+      return false;
     }
 
-    oldBMarks.push(state.bMarks[nextLine]);
-    oldBSCount.push(state.bsCount[nextLine]);
-    oldTShift.push(state.tShift[nextLine]);
-    oldSCount.push(state.sCount[nextLine]);
-
-    // A negative indentation means that this is a paragraph continuation
-    //
-    state.sCount[nextLine] = -1;
-  }
-
-  oldIndent = state.blkIndent;
-  state.blkIndent = 0;
-
-  token        = state.push('blockquote_open', 'blockquote', 1);
-  token.markup = '>';
-  token.map    = lines = [ startLine, 0 ];
-
-  state.md.block.tokenize(state, startLine, nextLine);
+    // [link](  <href>  "title"  )
+    //          ^^^^^^ parsing link destination
+    start = pos;
+    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
+    if (res.ok) {
+      href = state.md.normalizeLink(res.str);
+      if (state.md.validateLink(href)) {
+        pos = res.pos;
+      } else {
+        href = '';
+      }
 
-  token        = state.push('blockquote_close', 'blockquote', -1);
-  token.markup = '>';
+      // [link](  <href>  "title"  )
+      //                ^^ skipping these spaces
+      start = pos;
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos);
+        if (!isSpace(code) && code !== 0x0A) {
+          break;
+        }
+      }
 
-  state.lineMax = oldLineMax;
-  state.parentType = oldParentType;
-  lines[1] = state.line;
+      // [link](  <href>  "title"  )
+      //                  ^^^^^^^ parsing link title
+      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
+      if (pos < max && start !== pos && res.ok) {
+        title = res.str;
+        pos = res.pos;
 
-  // Restore original tShift; this might not be necessary since the parser
-  // has already been here, but just to make sure we can do that.
-  for (i = 0; i < oldTShift.length; i++) {
-    state.bMarks[i + startLine] = oldBMarks[i];
-    state.tShift[i + startLine] = oldTShift[i];
-    state.sCount[i + startLine] = oldSCount[i];
-    state.bsCount[i + startLine] = oldBSCount[i];
+        // [link](  <href>  "title"  )
+        //                         ^^ skipping these spaces
+        for (; pos < max; pos++) {
+          code = state.src.charCodeAt(pos);
+          if (!isSpace(code) && code !== 0x0A) {
+            break;
+          }
+        }
+      }
+    }
+    if (pos >= max || state.src.charCodeAt(pos) !== 0x29 /* ) */) {
+      // parsing a valid shortcut link failed, fallback to reference
+      parseReference = true;
+    }
+    pos++;
   }
-  state.blkIndent = oldIndent;
-
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 8768:
-/***/ ((module) => {
-
-"use strict";
-// Code block (4 spaces padded)
-
-
-
-
-module.exports = function code(state, startLine, endLine/*, silent*/) {
-  var nextLine, last, token;
-
-  if (state.sCount[startLine] - state.blkIndent < 4) { return false; }
-
-  last = nextLine = startLine + 1;
-
-  while (nextLine < endLine) {
-    if (state.isEmpty(nextLine)) {
-      nextLine++;
-      continue;
+  if (parseReference) {
+    //
+    // Link reference
+    //
+    if (typeof state.env.references === 'undefined') {
+      return false;
+    }
+    if (pos < max && state.src.charCodeAt(pos) === 0x5B /* [ */) {
+      start = pos + 1;
+      pos = state.md.helpers.parseLinkLabel(state, pos);
+      if (pos >= 0) {
+        label = state.src.slice(start, pos++);
+      } else {
+        pos = labelEnd + 1;
+      }
+    } else {
+      pos = labelEnd + 1;
     }
 
-    if (state.sCount[nextLine] - state.blkIndent >= 4) {
-      nextLine++;
-      last = nextLine;
-      continue;
+    // covers label === '' and label === undefined
+    // (collapsed reference link and shortcut reference link respectively)
+    if (!label) {
+      label = state.src.slice(labelStart, labelEnd);
     }
-    break;
+    ref = state.env.references[normalizeReference(label)];
+    if (!ref) {
+      state.pos = oldPos;
+      return false;
+    }
+    href = ref.href;
+    title = ref.title;
   }
 
-  state.line = last;
-
-  token         = state.push('code_block', 'code', 0);
-  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\n';
-  token.map     = [ startLine, state.line ];
-
+  //
+  // We found the end of the link, and know for a fact it's a valid link;
+  // so all that's left to do is to call tokenizer.
+  //
+  if (!silent) {
+    state.pos = labelStart;
+    state.posMax = labelEnd;
+    const token_o = state.push('link_open', 'a', 1);
+    const attrs = [['href', href]];
+    token_o.attrs = attrs;
+    if (title) {
+      attrs.push(['title', title]);
+    }
+    state.linkLevel++;
+    state.md.inline.tokenize(state);
+    state.linkLevel--;
+    state.push('link_close', 'a', -1);
+  }
+  state.pos = pos;
+  state.posMax = max;
   return true;
-};
-
-
-/***/ }),
-
-/***/ 3542:
-/***/ ((module) => {
-
-"use strict";
-// fences (``` lang, ~~~ lang)
-
-
-
-
-module.exports = function fence(state, startLine, endLine, silent) {
-  var marker, len, params, nextLine, mem, token, markup,
-      haveEndMarker = false,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine];
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
+}
 
-  if (pos + 3 > max) { return false; }
+// Process ![image](<src> "title")
 
-  marker = state.src.charCodeAt(pos);
+function image(state, silent) {
+  let code, content, label, pos, ref, res, title, start;
+  let href = '';
+  const oldPos = state.pos;
+  const max = state.posMax;
+  if (state.src.charCodeAt(state.pos) !== 0x21 /* ! */) {
+    return false;
+  }
+  if (state.src.charCodeAt(state.pos + 1) !== 0x5B /* [ */) {
+    return false;
+  }
+  const labelStart = state.pos + 2;
+  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
 
-  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {
+  // parser failed to find ']', so it's not a valid link
+  if (labelEnd < 0) {
     return false;
   }
+  pos = labelEnd + 1;
+  if (pos < max && state.src.charCodeAt(pos) === 0x28 /* ( */) {
+    //
+    // Inline link
+    //
 
-  // scan marker length
-  mem = pos;
-  pos = state.skipChars(pos, marker);
+    // [link](  <href>  "title"  )
+    //        ^^ skipping these spaces
+    pos++;
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos);
+      if (!isSpace(code) && code !== 0x0A) {
+        break;
+      }
+    }
+    if (pos >= max) {
+      return false;
+    }
 
-  len = pos - mem;
+    // [link](  <href>  "title"  )
+    //          ^^^^^^ parsing link destination
+    start = pos;
+    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
+    if (res.ok) {
+      href = state.md.normalizeLink(res.str);
+      if (state.md.validateLink(href)) {
+        pos = res.pos;
+      } else {
+        href = '';
+      }
+    }
 
-  if (len < 3) { return false; }
+    // [link](  <href>  "title"  )
+    //                ^^ skipping these spaces
+    start = pos;
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos);
+      if (!isSpace(code) && code !== 0x0A) {
+        break;
+      }
+    }
 
-  markup = state.src.slice(mem, pos);
-  params = state.src.slice(pos, max);
+    // [link](  <href>  "title"  )
+    //                  ^^^^^^^ parsing link title
+    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
+    if (pos < max && start !== pos && res.ok) {
+      title = res.str;
+      pos = res.pos;
 
-  if (marker === 0x60 /* ` */) {
-    if (params.indexOf(String.fromCharCode(marker)) >= 0) {
+      // [link](  <href>  "title"  )
+      //                         ^^ skipping these spaces
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos);
+        if (!isSpace(code) && code !== 0x0A) {
+          break;
+        }
+      }
+    } else {
+      title = '';
+    }
+    if (pos >= max || state.src.charCodeAt(pos) !== 0x29 /* ) */) {
+      state.pos = oldPos;
+      return false;
+    }
+    pos++;
+  } else {
+    //
+    // Link reference
+    //
+    if (typeof state.env.references === 'undefined') {
+      return false;
+    }
+    if (pos < max && state.src.charCodeAt(pos) === 0x5B /* [ */) {
+      start = pos + 1;
+      pos = state.md.helpers.parseLinkLabel(state, pos);
+      if (pos >= 0) {
+        label = state.src.slice(start, pos++);
+      } else {
+        pos = labelEnd + 1;
+      }
+    } else {
+      pos = labelEnd + 1;
+    }
+
+    // covers label === '' and label === undefined
+    // (collapsed reference link and shortcut reference link respectively)
+    if (!label) {
+      label = state.src.slice(labelStart, labelEnd);
+    }
+    ref = state.env.references[normalizeReference(label)];
+    if (!ref) {
+      state.pos = oldPos;
       return false;
     }
+    href = ref.href;
+    title = ref.title;
   }
 
-  // Since start is found, we can report success here in validation mode
-  if (silent) { return true; }
+  //
+  // We found the end of the link, and know for a fact it's a valid link;
+  // so all that's left to do is to call tokenizer.
+  //
+  if (!silent) {
+    content = state.src.slice(labelStart, labelEnd);
+    const tokens = [];
+    state.md.inline.parse(content, state.md, state.env, tokens);
+    const token = state.push('image', 'img', 0);
+    const attrs = [['src', href], ['alt', '']];
+    token.attrs = attrs;
+    token.children = tokens;
+    token.content = content;
+    if (title) {
+      attrs.push(['title', title]);
+    }
+  }
+  state.pos = pos;
+  state.posMax = max;
+  return true;
+}
 
-  // search end of block
-  nextLine = startLine;
+// Process autolinks '<protocol:...>'
 
+/* eslint max-len:0 */
+const EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
+/* eslint-disable-next-line no-control-regex */
+const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
+function autolink(state, silent) {
+  let pos = state.pos;
+  if (state.src.charCodeAt(pos) !== 0x3C /* < */) {
+    return false;
+  }
+  const start = state.pos;
+  const max = state.posMax;
   for (;;) {
-    nextLine++;
-    if (nextLine >= endLine) {
-      // unclosed block should be autoclosed by end of document.
-      // also block seems to be autoclosed by end of parent
-      break;
+    if (++pos >= max) return false;
+    const ch = state.src.charCodeAt(pos);
+    if (ch === 0x3C /* < */) return false;
+    if (ch === 0x3E /* > */) break;
+  }
+  const url = state.src.slice(start + 1, pos);
+  if (AUTOLINK_RE.test(url)) {
+    const fullUrl = state.md.normalizeLink(url);
+    if (!state.md.validateLink(fullUrl)) {
+      return false;
     }
-
-    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
-    max = state.eMarks[nextLine];
-
-    if (pos < max && state.sCount[nextLine] < state.blkIndent) {
-      // non-empty line with negative indent should stop the list:
-      // - ```
-      //  test
-      break;
+    if (!silent) {
+      const token_o = state.push('link_open', 'a', 1);
+      token_o.attrs = [['href', fullUrl]];
+      token_o.markup = 'autolink';
+      token_o.info = 'auto';
+      const token_t = state.push('text', '', 0);
+      token_t.content = state.md.normalizeLinkText(url);
+      const token_c = state.push('link_close', 'a', -1);
+      token_c.markup = 'autolink';
+      token_c.info = 'auto';
     }
-
-    if (state.src.charCodeAt(pos) !== marker) { continue; }
-
-    if (state.sCount[nextLine] - state.blkIndent >= 4) {
-      // closing fence should be indented less than 4 spaces
-      continue;
+    state.pos += url.length + 2;
+    return true;
+  }
+  if (EMAIL_RE.test(url)) {
+    const fullUrl = state.md.normalizeLink('mailto:' + url);
+    if (!state.md.validateLink(fullUrl)) {
+      return false;
     }
-
-    pos = state.skipChars(pos, marker);
-
-    // closing code fence must be at least as long as the opening one
-    if (pos - mem < len) { continue; }
-
-    // make sure tail has spaces only
-    pos = state.skipSpaces(pos);
-
-    if (pos < max) { continue; }
-
-    haveEndMarker = true;
-    // found!
-    break;
+    if (!silent) {
+      const token_o = state.push('link_open', 'a', 1);
+      token_o.attrs = [['href', fullUrl]];
+      token_o.markup = 'autolink';
+      token_o.info = 'auto';
+      const token_t = state.push('text', '', 0);
+      token_t.content = state.md.normalizeLinkText(url);
+      const token_c = state.push('link_close', 'a', -1);
+      token_c.markup = 'autolink';
+      token_c.info = 'auto';
+    }
+    state.pos += url.length + 2;
+    return true;
   }
+  return false;
+}
 
-  // If a fence has heading spaces, they should be removed from its inner block
-  len = state.sCount[startLine];
+// Process html tags
 
-  state.line = nextLine + (haveEndMarker ? 1 : 0);
+function isLinkOpen(str) {
+  return /^<a[>\s]/i.test(str);
+}
+function isLinkClose(str) {
+  return /^<\/a\s*>/i.test(str);
+}
+function isLetter(ch) {
+  /* eslint no-bitwise:0 */
+  const lc = ch | 0x20; // to lower case
+  return lc >= 0x61 /* a */ && lc <= 0x7a /* z */;
+}
+function html_inline(state, silent) {
+  if (!state.md.options.html) {
+    return false;
+  }
 
-  token         = state.push('fence', 'code', 0);
-  token.info    = params;
-  token.content = state.getLines(startLine + 1, nextLine, len, true);
-  token.markup  = markup;
-  token.map     = [ startLine, state.line ];
+  // Check start
+  const max = state.posMax;
+  const pos = state.pos;
+  if (state.src.charCodeAt(pos) !== 0x3C /* < */ || pos + 2 >= max) {
+    return false;
+  }
 
+  // Quick fail on second char
+  const ch = state.src.charCodeAt(pos + 1);
+  if (ch !== 0x21 /* ! */ && ch !== 0x3F /* ? */ && ch !== 0x2F /* / */ && !isLetter(ch)) {
+    return false;
+  }
+  const match = state.src.slice(pos).match(HTML_TAG_RE);
+  if (!match) {
+    return false;
+  }
+  if (!silent) {
+    const token = state.push('html_inline', '', 0);
+    token.content = match[0];
+    if (isLinkOpen(token.content)) state.linkLevel++;
+    if (isLinkClose(token.content)) state.linkLevel--;
+  }
+  state.pos += match[0].length;
   return true;
-};
-
-
-/***/ }),
-
-/***/ 1630:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// heading (#, ##, ...)
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function heading(state, startLine, endLine, silent) {
-  var ch, level, tmp, token,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine];
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  ch  = state.src.charCodeAt(pos);
+}
 
-  if (ch !== 0x23/* # */ || pos >= max) { return false; }
+// Process html entity - &#123;, &#xAF;, &quot;, ...
 
-  // count heading level
-  level = 1;
-  ch = state.src.charCodeAt(++pos);
-  while (ch === 0x23/* # */ && pos < max && level <= 6) {
-    level++;
-    ch = state.src.charCodeAt(++pos);
+const DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
+const NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
+function entity(state, silent) {
+  const pos = state.pos;
+  const max = state.posMax;
+  if (state.src.charCodeAt(pos) !== 0x26 /* & */) return false;
+  if (pos + 1 >= max) return false;
+  const ch = state.src.charCodeAt(pos + 1);
+  if (ch === 0x23 /* # */) {
+    const match = state.src.slice(pos).match(DIGITAL_RE);
+    if (match) {
+      if (!silent) {
+        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
+        const token = state.push('text_special', '', 0);
+        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);
+        token.markup = match[0];
+        token.info = 'entity';
+      }
+      state.pos += match[0].length;
+      return true;
+    }
+  } else {
+    const match = state.src.slice(pos).match(NAMED_RE);
+    if (match) {
+      const decoded = entities.decodeHTML(match[0]);
+      if (decoded !== match[0]) {
+        if (!silent) {
+          const token = state.push('text_special', '', 0);
+          token.content = decoded;
+          token.markup = match[0];
+          token.info = 'entity';
+        }
+        state.pos += match[0].length;
+        return true;
+      }
+    }
   }
+  return false;
+}
 
-  if (level > 6 || (pos < max && !isSpace(ch))) { return false; }
-
-  if (silent) { return true; }
-
-  // Let's cut tails like '    ###  ' from the end of string
-
-  max = state.skipSpacesBack(max, pos);
-  tmp = state.skipCharsBack(max, 0x23, pos); // #
-  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
-    max = tmp;
-  }
+// For each opening emphasis-like marker find a matching closing one
+//
 
-  state.line = startLine + 1;
+function processDelimiters(delimiters) {
+  const openersBottom = {};
+  const max = delimiters.length;
+  if (!max) return;
 
-  token        = state.push('heading_open', 'h' + String(level), 1);
-  token.markup = '########'.slice(0, level);
-  token.map    = [ startLine, state.line ];
+  // headerIdx is the first delimiter of the current (where closer is) delimiter run
+  let headerIdx = 0;
+  let lastTokenIdx = -2; // needs any value lower than -1
+  const jumps = [];
+  for (let closerIdx = 0; closerIdx < max; closerIdx++) {
+    const closer = delimiters[closerIdx];
+    jumps.push(0);
 
-  token          = state.push('inline', '', 0);
-  token.content  = state.src.slice(pos, max).trim();
-  token.map      = [ startLine, state.line ];
-  token.children = [];
+    // markers belong to same delimiter run if:
+    //  - they have adjacent tokens
+    //  - AND markers are the same
+    //
+    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
+      headerIdx = closerIdx;
+    }
+    lastTokenIdx = closer.token;
 
-  token        = state.push('heading_close', 'h' + String(level), -1);
-  token.markup = '########'.slice(0, level);
+    // Length is only used for emphasis-specific "rule of 3",
+    // if it's not defined (in strikethrough or 3rd party plugins),
+    // we can default it to 0 to disable those checks.
+    //
+    closer.length = closer.length || 0;
+    if (!closer.close) continue;
 
-  return true;
-};
+    // Previously calculated lower bounds (previous fails)
+    // for each marker, each delimiter length modulo 3,
+    // and for whether this closer can be an opener;
+    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
+    /* eslint-disable-next-line no-prototype-builtins */
+    if (!openersBottom.hasOwnProperty(closer.marker)) {
+      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
+    }
+    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];
+    let openerIdx = headerIdx - jumps[headerIdx] - 1;
+    let newMinOpenerIdx = openerIdx;
+    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
+      const opener = delimiters[openerIdx];
+      if (opener.marker !== closer.marker) continue;
+      if (opener.open && opener.end < 0) {
+        let isOddMatch = false;
 
-
-/***/ }),
-
-/***/ 5634:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Horizontal rule
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function hr(state, startLine, endLine, silent) {
-  var marker, cnt, ch, token,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine];
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  marker = state.src.charCodeAt(pos++);
-
-  // Check hr marker
-  if (marker !== 0x2A/* * */ &&
-      marker !== 0x2D/* - */ &&
-      marker !== 0x5F/* _ */) {
-    return false;
+        // from spec:
+        //
+        // If one of the delimiters can both open and close emphasis, then the
+        // sum of the lengths of the delimiter runs containing the opening and
+        // closing delimiters must not be a multiple of 3 unless both lengths
+        // are multiples of 3.
+        //
+        if (opener.close || closer.open) {
+          if ((opener.length + closer.length) % 3 === 0) {
+            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
+              isOddMatch = true;
+            }
+          }
+        }
+        if (!isOddMatch) {
+          // If previous delimiter cannot be an opener, we can safely skip
+          // the entire sequence in future checks. This is required to make
+          // sure algorithm has linear complexity (see *_*_*_*_*_... case).
+          //
+          const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;
+          jumps[closerIdx] = closerIdx - openerIdx + lastJump;
+          jumps[openerIdx] = lastJump;
+          closer.open = false;
+          opener.end = closerIdx;
+          opener.close = false;
+          newMinOpenerIdx = -1;
+          // treat next token as start of run,
+          // it optimizes skips in **<...>**a**<...>** pathological case
+          lastTokenIdx = -2;
+          break;
+        }
+      }
+    }
+    if (newMinOpenerIdx !== -1) {
+      // If match for this delimiter run failed, we want to set lower bound for
+      // future lookups. This is required to make sure algorithm has linear
+      // complexity.
+      //
+      // See details here:
+      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
+      //
+      openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;
+    }
   }
-
-  // markers can be mixed with spaces, but there should be at least 3 of them
-
-  cnt = 1;
-  while (pos < max) {
-    ch = state.src.charCodeAt(pos++);
-    if (ch !== marker && !isSpace(ch)) { return false; }
-    if (ch === marker) { cnt++; }
+}
+function link_pairs(state) {
+  const tokens_meta = state.tokens_meta;
+  const max = state.tokens_meta.length;
+  processDelimiters(state.delimiters);
+  for (let curr = 0; curr < max; curr++) {
+    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
+      processDelimiters(tokens_meta[curr].delimiters);
+    }
   }
+}
 
-  if (cnt < 3) { return false; }
-
-  if (silent) { return true; }
-
-  state.line = startLine + 1;
-
-  token        = state.push('hr', 'hr', 0);
-  token.map    = [ startLine, state.line ];
-  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
-
-  return true;
-};
-
-
-/***/ }),
+// Clean up tokens after emphasis and strikethrough postprocessing:
+// merge adjacent text nodes into one and re-calculate all token levels
+//
+// This is necessary because initially emphasis delimiter markers (*, _, ~)
+// are treated as their own separate text tokens. Then emphasis rule either
+// leaves them as text (needed to merge with adjacent text) or turns them
+// into opening/closing tags (which messes up levels inside).
+//
 
-/***/ 6329:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+function fragments_join(state) {
+  let curr, last;
+  let level = 0;
+  const tokens = state.tokens;
+  const max = state.tokens.length;
+  for (curr = last = 0; curr < max; curr++) {
+    // re-calculate levels after emphasis/strikethrough turns some text nodes
+    // into opening/closing tags
+    if (tokens[curr].nesting < 0) level--; // closing tag
+    tokens[curr].level = level;
+    if (tokens[curr].nesting > 0) level++; // opening tag
 
-"use strict";
-// HTML block
+    if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {
+      // collapse two adjacent text nodes
+      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
+    } else {
+      if (curr !== last) {
+        tokens[last] = tokens[curr];
+      }
+      last++;
+    }
+  }
+  if (curr !== last) {
+    tokens.length = last;
+  }
+}
 
+/** internal
+ * class ParserInline
+ *
+ * Tokenizes paragraph content.
+ **/
 
 
+// Parser rules
 
-var block_names = __webpack_require__(813);
-var HTML_OPEN_CLOSE_TAG_RE = (__webpack_require__(1947)/* .HTML_OPEN_CLOSE_TAG_RE */ .q);
+const _rules = [['text', text], ['linkify', linkify], ['newline', newline], ['escape', escape], ['backticks', backtick], ['strikethrough', r_strikethrough.tokenize], ['emphasis', r_emphasis.tokenize], ['link', link], ['image', image], ['autolink', autolink], ['html_inline', html_inline], ['entity', entity]];
 
-// An array of opening and corresponding closing sequences for html tags,
-// last argument defines whether it can terminate a paragraph or not
+// `rule2` ruleset was created specifically for emphasis/strikethrough
+// post-processing and may be changed in the future.
 //
-var HTML_SEQUENCES = [
-  [ /^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true ],
-  [ /^<!--/,        /-->/,   true ],
-  [ /^<\?/,         /\?>/,   true ],
-  [ /^<![A-Z]/,     />/,     true ],
-  [ /^<!\[CDATA\[/, /\]\]>/, true ],
-  [ new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true ],
-  [ new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'),  /^$/, false ]
-];
-
-
-module.exports = function html_block(state, startLine, endLine, silent) {
-  var i, nextLine, token, lineText,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine];
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  if (!state.md.options.html) { return false; }
-
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }
-
-  lineText = state.src.slice(pos, max);
+// Don't use this for anything except pairs (plugins working with `balance_pairs`).
+//
+const _rules2 = [['balance_pairs', link_pairs], ['strikethrough', r_strikethrough.postProcess], ['emphasis', r_emphasis.postProcess],
+// rules for pairs separate '**' into its own text tokens, which may be left unused,
+// rule below merges unused segments back with the rest of the text
+['fragments_join', fragments_join]];
 
-  for (i = 0; i < HTML_SEQUENCES.length; i++) {
-    if (HTML_SEQUENCES[i][0].test(lineText)) { break; }
+/**
+ * new ParserInline()
+ **/
+function ParserInline() {
+  /**
+   * ParserInline#ruler -> Ruler
+   *
+   * [[Ruler]] instance. Keep configuration of inline rules.
+   **/
+  this.ruler = new Ruler();
+  for (let i = 0; i < _rules.length; i++) {
+    this.ruler.push(_rules[i][0], _rules[i][1]);
   }
 
-  if (i === HTML_SEQUENCES.length) { return false; }
-
-  if (silent) {
-    // true if this sequence can be a terminator, false otherwise
-    return HTML_SEQUENCES[i][2];
+  /**
+   * ParserInline#ruler2 -> Ruler
+   *
+   * [[Ruler]] instance. Second ruler used for post-processing
+   * (e.g. in emphasis-like rules).
+   **/
+  this.ruler2 = new Ruler();
+  for (let i = 0; i < _rules2.length; i++) {
+    this.ruler2.push(_rules2[i][0], _rules2[i][1]);
   }
+}
 
-  nextLine = startLine + 1;
-
-  // If we are here - we detected HTML block.
-  // Let's roll down till block end.
-  if (!HTML_SEQUENCES[i][1].test(lineText)) {
-    for (; nextLine < endLine; nextLine++) {
-      if (state.sCount[nextLine] < state.blkIndent) { break; }
-
-      pos = state.bMarks[nextLine] + state.tShift[nextLine];
-      max = state.eMarks[nextLine];
-      lineText = state.src.slice(pos, max);
-
-      if (HTML_SEQUENCES[i][1].test(lineText)) {
-        if (lineText.length !== 0) { nextLine++; }
+// Skip single token by running all rules in validation mode;
+// returns `true` if any rule reported success
+//
+ParserInline.prototype.skipToken = function (state) {
+  const pos = state.pos;
+  const rules = this.ruler.getRules('');
+  const len = rules.length;
+  const maxNesting = state.md.options.maxNesting;
+  const cache = state.cache;
+  if (typeof cache[pos] !== 'undefined') {
+    state.pos = cache[pos];
+    return;
+  }
+  let ok = false;
+  if (state.level < maxNesting) {
+    for (let i = 0; i < len; i++) {
+      // Increment state.level and decrement it later to limit recursion.
+      // It's harmless to do here, because no tokens are created. But ideally,
+      // we'd need a separate private state variable for this purpose.
+      //
+      state.level++;
+      ok = rules[i](state, true);
+      state.level--;
+      if (ok) {
+        if (pos >= state.pos) {
+          throw new Error("inline rule didn't increment state.pos");
+        }
         break;
       }
     }
+  } else {
+    // Too much nesting, just skip until the end of the paragraph.
+    //
+    // NOTE: this will cause links to behave incorrectly in the following case,
+    //       when an amount of `[` is exactly equal to `maxNesting + 1`:
+    //
+    //       [[[[[[[[[[[[[[[[[[[[[foo]()
+    //
+    // TODO: remove this workaround when CM standard will allow nested links
+    //       (we can replace it by preventing links from being parsed in
+    //       validation mode)
+    //
+    state.pos = state.posMax;
   }
-
-  state.line = nextLine;
-
-  token         = state.push('html_block', '', 0);
-  token.map     = [ startLine, nextLine ];
-  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
-
-  return true;
+  if (!ok) {
+    state.pos++;
+  }
+  cache[pos] = state.pos;
 };
 
-
-/***/ }),
-
-/***/ 6850:
-/***/ ((module) => {
-
-"use strict";
-// lheading (---, ===)
-
-
-
-
-module.exports = function lheading(state, startLine, endLine/*, silent*/) {
-  var content, terminate, i, l, token, pos, max, level, marker,
-      nextLine = startLine + 1, oldParentType,
-      terminatorRules = state.md.block.ruler.getRules('paragraph');
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  oldParentType = state.parentType;
-  state.parentType = 'paragraph'; // use paragraph to match terminatorRules
-
-  // jump line-by-line until empty one or EOF
-  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }
-
-    //
-    // Check for underline in setext header
+// Generate tokens for input range
+//
+ParserInline.prototype.tokenize = function (state) {
+  const rules = this.ruler.getRules('');
+  const len = rules.length;
+  const end = state.posMax;
+  const maxNesting = state.md.options.maxNesting;
+  while (state.pos < end) {
+    // Try all possible rules.
+    // On success, rule should:
     //
-    if (state.sCount[nextLine] >= state.blkIndent) {
-      pos = state.bMarks[nextLine] + state.tShift[nextLine];
-      max = state.eMarks[nextLine];
-
-      if (pos < max) {
-        marker = state.src.charCodeAt(pos);
-
-        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {
-          pos = state.skipChars(pos, marker);
-          pos = state.skipSpaces(pos);
-
-          if (pos >= max) {
-            level = (marker === 0x3D/* = */ ? 1 : 2);
-            break;
+    // - update `state.pos`
+    // - update `state.tokens`
+    // - return true
+    const prevPos = state.pos;
+    let ok = false;
+    if (state.level < maxNesting) {
+      for (let i = 0; i < len; i++) {
+        ok = rules[i](state, false);
+        if (ok) {
+          if (prevPos >= state.pos) {
+            throw new Error("inline rule didn't increment state.pos");
           }
+          break;
         }
       }
     }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { continue; }
-
-    // Some tags can terminate paragraph without empty line.
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
+    if (ok) {
+      if (state.pos >= end) {
         break;
       }
+      continue;
     }
-    if (terminate) { break; }
+    state.pending += state.src[state.pos++];
   }
-
-  if (!level) {
-    // Didn't find valid underline
-    return false;
+  if (state.pending) {
+    state.pushPending();
   }
-
-  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
-
-  state.line = nextLine + 1;
-
-  token          = state.push('heading_open', 'h' + String(level), 1);
-  token.markup   = String.fromCharCode(marker);
-  token.map      = [ startLine, state.line ];
-
-  token          = state.push('inline', '', 0);
-  token.content  = content;
-  token.map      = [ startLine, state.line - 1 ];
-  token.children = [];
-
-  token          = state.push('heading_close', 'h' + String(level), -1);
-  token.markup   = String.fromCharCode(marker);
-
-  state.parentType = oldParentType;
-
-  return true;
 };
 
+/**
+ * ParserInline.parse(str, md, env, outTokens)
+ *
+ * Process input string and push inline tokens into `outTokens`
+ **/
+ParserInline.prototype.parse = function (str, md, env, outTokens) {
+  const state = new this.State(str, md, env, outTokens);
+  this.tokenize(state);
+  const rules = this.ruler2.getRules('');
+  const len = rules.length;
+  for (let i = 0; i < len; i++) {
+    rules[i](state);
+  }
+};
+ParserInline.prototype.State = StateInline;
 
-/***/ }),
-
-/***/ 8532:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Lists
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-// Search `[-+*][\n ]`, returns next pos after marker on success
-// or -1 on fail.
-function skipBulletListMarker(state, startLine) {
-  var marker, pos, max, ch;
+// markdown-it default options
 
-  pos = state.bMarks[startLine] + state.tShift[startLine];
-  max = state.eMarks[startLine];
+var cfg_default = {
+  options: {
+    // Enable HTML tags in source
+    html: false,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: false,
+    // Convert '\n' in paragraphs into <br>
+    breaks: false,
+    // CSS language prefix for fenced blocks
+    langPrefix: 'language-',
+    // autoconvert URL-like texts to links
+    linkify: false,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: false,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: '\u201c\u201d\u2018\u2019',
+    /* “”‘’ */
 
-  marker = state.src.charCodeAt(pos++);
-  // Check bullet
-  if (marker !== 0x2A/* * */ &&
-      marker !== 0x2D/* - */ &&
-      marker !== 0x2B/* + */) {
-    return -1;
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    maxNesting: 100
+  },
+  components: {
+    core: {},
+    block: {},
+    inline: {}
   }
+};
 
-  if (pos < max) {
-    ch = state.src.charCodeAt(pos);
+// "Zero" preset, with nothing enabled. Useful for manual configuring of simple
+// modes. For example, to parse bold/italic only.
 
-    if (!isSpace(ch)) {
-      // " -test " - is not a list item
-      return -1;
+var cfg_zero = {
+  options: {
+    // Enable HTML tags in source
+    html: false,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: false,
+    // Convert '\n' in paragraphs into <br>
+    breaks: false,
+    // CSS language prefix for fenced blocks
+    langPrefix: 'language-',
+    // autoconvert URL-like texts to links
+    linkify: false,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: false,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: '\u201c\u201d\u2018\u2019',
+    /* “”‘’ */
+
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    maxNesting: 20
+  },
+  components: {
+    core: {
+      rules: ['normalize', 'block', 'inline', 'text_join']
+    },
+    block: {
+      rules: ['paragraph']
+    },
+    inline: {
+      rules: ['text'],
+      rules2: ['balance_pairs', 'fragments_join']
     }
   }
+};
 
-  return pos;
-}
-
-// Search `\d+[.)][\n ]`, returns next pos after marker on success
-// or -1 on fail.
-function skipOrderedListMarker(state, startLine) {
-  var ch,
-      start = state.bMarks[startLine] + state.tShift[startLine],
-      pos = start,
-      max = state.eMarks[startLine];
-
-  // List marker should have at least 2 chars (digit + dot)
-  if (pos + 1 >= max) { return -1; }
-
-  ch = state.src.charCodeAt(pos++);
-
-  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; }
-
-  for (;;) {
-    // EOL -> fail
-    if (pos >= max) { return -1; }
-
-    ch = state.src.charCodeAt(pos++);
-
-    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {
-
-      // List marker should have no more than 9 digits
-      // (prevents integer overflow in browsers)
-      if (pos - start >= 10) { return -1; }
+// Commonmark default options
 
-      continue;
-    }
+var cfg_commonmark = {
+  options: {
+    // Enable HTML tags in source
+    html: true,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: true,
+    // Convert '\n' in paragraphs into <br>
+    breaks: false,
+    // CSS language prefix for fenced blocks
+    langPrefix: 'language-',
+    // autoconvert URL-like texts to links
+    linkify: false,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: false,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: '\u201c\u201d\u2018\u2019',
+    /* “”‘’ */
 
-    // found valid marker
-    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {
-      break;
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    maxNesting: 20
+  },
+  components: {
+    core: {
+      rules: ['normalize', 'block', 'inline', 'text_join']
+    },
+    block: {
+      rules: ['blockquote', 'code', 'fence', 'heading', 'hr', 'html_block', 'lheading', 'list', 'reference', 'paragraph']
+    },
+    inline: {
+      rules: ['autolink', 'backticks', 'emphasis', 'entity', 'escape', 'html_inline', 'image', 'link', 'newline', 'text'],
+      rules2: ['balance_pairs', 'emphasis', 'fragments_join']
     }
-
-    return -1;
   }
+};
 
+// Main parser class
 
-  if (pos < max) {
-    ch = state.src.charCodeAt(pos);
-
-    if (!isSpace(ch)) {
-      // " 1.test " - is not a list item
-      return -1;
-    }
-  }
-  return pos;
-}
+const config = {
+  default: cfg_default,
+  zero: cfg_zero,
+  commonmark: cfg_commonmark
+};
 
-function markTightParagraphs(state, idx) {
-  var i, l,
-      level = state.level + 2;
+//
+// This validator can prohibit more than really needed to prevent XSS. It's a
+// tradeoff to keep code simple and to be secure by default.
+//
+// If you need different setup - override validator method as you wish. Or
+// replace it with dummy function and use external sanitizer.
+//
 
-  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
-    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
-      state.tokens[i + 2].hidden = true;
-      state.tokens[i].hidden = true;
-      i += 2;
+const BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
+const GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
+function validateLink(url) {
+  // url should be normalized at this point, and existing entities are decoded
+  const str = url.trim().toLowerCase();
+  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;
+}
+const RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:'];
+function normalizeLink(url) {
+  const parsed = mdurl__namespace.parse(url, true);
+  if (parsed.hostname) {
+    // Encode hostnames in urls like:
+    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    //
+    // We don't encode unknown schemas, because it's likely that we encode
+    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    //
+    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
+      try {
+        parsed.hostname = punycode.toASCII(parsed.hostname);
+      } catch (er) {/**/}
     }
   }
+  return mdurl__namespace.encode(mdurl__namespace.format(parsed));
 }
-
-
-module.exports = function list(state, startLine, endLine, silent) {
-  var ch,
-      contentStart,
-      i,
-      indent,
-      indentAfterMarker,
-      initial,
-      isOrdered,
-      itemLines,
-      l,
-      listLines,
-      listTokIdx,
-      markerCharCode,
-      markerValue,
-      max,
-      nextLine,
-      offset,
-      oldListIndent,
-      oldParentType,
-      oldSCount,
-      oldTShift,
-      oldTight,
-      pos,
-      posAfterMarker,
-      prevEmptyEnd,
-      start,
-      terminate,
-      terminatorRules,
-      token,
-      isTerminatingParagraph = false,
-      tight = true;
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  // Special case:
-  //  - item 1
-  //   - item 2
-  //    - item 3
-  //     - item 4
-  //      - this one is a paragraph continuation
-  if (state.listIndent >= 0 &&
-      state.sCount[startLine] - state.listIndent >= 4 &&
-      state.sCount[startLine] < state.blkIndent) {
-    return false;
-  }
-
-  // limit conditions when list can interrupt
-  // a paragraph (validation mode only)
-  if (silent && state.parentType === 'paragraph') {
-    // Next list item should still terminate previous list item;
+function normalizeLinkText(url) {
+  const parsed = mdurl__namespace.parse(url, true);
+  if (parsed.hostname) {
+    // Encode hostnames in urls like:
+    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
     //
-    // This code can fail if plugins use blkIndent as well as lists,
-    // but I hope the spec gets fixed long before that happens.
+    // We don't encode unknown schemas, because it's likely that we encode
+    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
     //
-    if (state.sCount[startLine] >= state.blkIndent) {
-      isTerminatingParagraph = true;
+    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
+      try {
+        parsed.hostname = punycode.toUnicode(parsed.hostname);
+      } catch (er) {/**/}
     }
   }
 
-  // Detect list type and position after marker
-  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
-    isOrdered = true;
-    start = state.bMarks[startLine] + state.tShift[startLine];
-    markerValue = Number(state.src.slice(start, posAfterMarker - 1));
-
-    // If we're starting a new ordered list right after
-    // a paragraph, it should start with 1.
-    if (isTerminatingParagraph && markerValue !== 1) return false;
-
-  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {
-    isOrdered = false;
+  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
+  return mdurl__namespace.decode(mdurl__namespace.format(parsed), mdurl__namespace.decode.defaultChars + '%');
+}
 
-  } else {
-    return false;
-  }
+/**
+ * class MarkdownIt
+ *
+ * Main parser/renderer class.
+ *
+ * ##### Usage
+ *
+ * ```javascript
+ * // node.js, "classic" way:
+ * var MarkdownIt = require('markdown-it'),
+ *     md = new MarkdownIt();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // node.js, the same, but with sugar:
+ * var md = require('markdown-it')();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // browser without AMD, added to "window" on script load
+ * // Note, there are no dash.
+ * var md = window.markdownit();
+ * var result = md.render('# markdown-it rulezz!');
+ * ```
+ *
+ * Single line rendering, without paragraph wrap:
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ * var result = md.renderInline('__markdown-it__ rulezz!');
+ * ```
+ **/
 
-  // If we're starting a new unordered list right after
-  // a paragraph, first line should not be empty.
-  if (isTerminatingParagraph) {
-    if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]) return false;
-  }
-
-  // We should terminate list on style change. Remember first one to compare.
-  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
-
-  // For validation mode we can terminate immediately
-  if (silent) { return true; }
-
-  // Start list
-  listTokIdx = state.tokens.length;
-
-  if (isOrdered) {
-    token       = state.push('ordered_list_open', 'ol', 1);
-    if (markerValue !== 1) {
-      token.attrs = [ [ 'start', markerValue ] ];
-    }
-
-  } else {
-    token       = state.push('bullet_list_open', 'ul', 1);
-  }
-
-  token.map    = listLines = [ startLine, 0 ];
-  token.markup = String.fromCharCode(markerCharCode);
-
-  //
-  // Iterate list items
-  //
-
-  nextLine = startLine;
-  prevEmptyEnd = false;
-  terminatorRules = state.md.block.ruler.getRules('list');
-
-  oldParentType = state.parentType;
-  state.parentType = 'list';
-
-  while (nextLine < endLine) {
-    pos = posAfterMarker;
-    max = state.eMarks[nextLine];
-
-    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);
-
-    while (pos < max) {
-      ch = state.src.charCodeAt(pos);
-
-      if (ch === 0x09) {
-        offset += 4 - (offset + state.bsCount[nextLine]) % 4;
-      } else if (ch === 0x20) {
-        offset++;
-      } else {
-        break;
-      }
-
-      pos++;
-    }
-
-    contentStart = pos;
-
-    if (contentStart >= max) {
-      // trimming space in "-    \n  3" case, indent is 1 here
-      indentAfterMarker = 1;
-    } else {
-      indentAfterMarker = offset - initial;
-    }
-
-    // If we have more than 4 spaces, the indent is 1
-    // (the rest is just indented code block)
-    if (indentAfterMarker > 4) { indentAfterMarker = 1; }
-
-    // "  -  test"
-    //  ^^^^^ - calculating total length of this thing
-    indent = initial + indentAfterMarker;
-
-    // Run subparser & write tokens
-    token        = state.push('list_item_open', 'li', 1);
-    token.markup = String.fromCharCode(markerCharCode);
-    token.map    = itemLines = [ startLine, 0 ];
-    if (isOrdered) {
-      token.info = state.src.slice(start, posAfterMarker - 1);
-    }
-
-    // change current state, then restore it after parser subcall
-    oldTight = state.tight;
-    oldTShift = state.tShift[startLine];
-    oldSCount = state.sCount[startLine];
-
-    //  - example list
-    // ^ listIndent position will be here
-    //   ^ blkIndent position will be here
-    //
-    oldListIndent = state.listIndent;
-    state.listIndent = state.blkIndent;
-    state.blkIndent = indent;
-
-    state.tight = true;
-    state.tShift[startLine] = contentStart - state.bMarks[startLine];
-    state.sCount[startLine] = offset;
-
-    if (contentStart >= max && state.isEmpty(startLine + 1)) {
-      // workaround for this case
-      // (list item is empty, list terminates before "foo"):
-      // ~~~~~~~~
-      //   -
-      //
-      //     foo
-      // ~~~~~~~~
-      state.line = Math.min(state.line + 2, endLine);
-    } else {
-      state.md.block.tokenize(state, startLine, endLine, true);
-    }
-
-    // If any of list item is tight, mark list as tight
-    if (!state.tight || prevEmptyEnd) {
-      tight = false;
-    }
-    // Item become loose if finish with empty line,
-    // but we should filter last element, because it means list finish
-    prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1);
-
-    state.blkIndent = state.listIndent;
-    state.listIndent = oldListIndent;
-    state.tShift[startLine] = oldTShift;
-    state.sCount[startLine] = oldSCount;
-    state.tight = oldTight;
-
-    token        = state.push('list_item_close', 'li', -1);
-    token.markup = String.fromCharCode(markerCharCode);
-
-    nextLine = startLine = state.line;
-    itemLines[1] = nextLine;
-    contentStart = state.bMarks[startLine];
-
-    if (nextLine >= endLine) { break; }
-
-    //
-    // Try to check if list is terminated or continued.
-    //
-    if (state.sCount[nextLine] < state.blkIndent) { break; }
-
-    // if it's indented more than 3 spaces, it should be a code block
-    if (state.sCount[startLine] - state.blkIndent >= 4) { break; }
-
-    // fail if terminating block found
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
-        break;
-      }
-    }
-    if (terminate) { break; }
-
-    // fail if list has another type
-    if (isOrdered) {
-      posAfterMarker = skipOrderedListMarker(state, nextLine);
-      if (posAfterMarker < 0) { break; }
-      start = state.bMarks[nextLine] + state.tShift[nextLine];
-    } else {
-      posAfterMarker = skipBulletListMarker(state, nextLine);
-      if (posAfterMarker < 0) { break; }
-    }
-
-    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; }
-  }
-
-  // Finalize list
-  if (isOrdered) {
-    token = state.push('ordered_list_close', 'ol', -1);
-  } else {
-    token = state.push('bullet_list_close', 'ul', -1);
-  }
-  token.markup = String.fromCharCode(markerCharCode);
-
-  listLines[1] = nextLine;
-  state.line = nextLine;
-
-  state.parentType = oldParentType;
-
-  // mark paragraphs tight if needed
-  if (tight) {
-    markTightParagraphs(state, listTokIdx);
-  }
-
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 6864:
-/***/ ((module) => {
-
-"use strict";
-// Paragraph
-
-
-
-
-module.exports = function paragraph(state, startLine/*, endLine*/) {
-  var content, terminate, i, l, token, oldParentType,
-      nextLine = startLine + 1,
-      terminatorRules = state.md.block.ruler.getRules('paragraph'),
-      endLine = state.lineMax;
-
-  oldParentType = state.parentType;
-  state.parentType = 'paragraph';
-
-  // jump line-by-line until empty one or EOF
-  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { continue; }
-
-    // Some tags can terminate paragraph without empty line.
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
-        break;
-      }
-    }
-    if (terminate) { break; }
-  }
-
-  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
-
-  state.line = nextLine;
-
-  token          = state.push('paragraph_open', 'p', 1);
-  token.map      = [ startLine, state.line ];
-
-  token          = state.push('inline', '', 0);
-  token.content  = content;
-  token.map      = [ startLine, state.line ];
-  token.children = [];
-
-  token          = state.push('paragraph_close', 'p', -1);
-
-  state.parentType = oldParentType;
-
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 3804:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-
-var normalizeReference   = (__webpack_require__(7022).normalizeReference);
-var isSpace              = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function reference(state, startLine, _endLine, silent) {
-  var ch,
-      destEndPos,
-      destEndLineNo,
-      endLine,
-      href,
-      i,
-      l,
-      label,
-      labelEnd,
-      oldParentType,
-      res,
-      start,
-      str,
-      terminate,
-      terminatorRules,
-      title,
-      lines = 0,
-      pos = state.bMarks[startLine] + state.tShift[startLine],
-      max = state.eMarks[startLine],
-      nextLine = startLine + 1;
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-
-  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false; }
-
-  // Simple check to quickly interrupt scan on [link](url) at the start of line.
-  // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54
-  while (++pos < max) {
-    if (state.src.charCodeAt(pos) === 0x5D /* ] */ &&
-        state.src.charCodeAt(pos - 1) !== 0x5C/* \ */) {
-      if (pos + 1 === max) { return false; }
-      if (state.src.charCodeAt(pos + 1) !== 0x3A/* : */) { return false; }
-      break;
-    }
-  }
-
-  endLine = state.lineMax;
-
-  // jump line-by-line until empty one or EOF
-  terminatorRules = state.md.block.ruler.getRules('reference');
-
-  oldParentType = state.parentType;
-  state.parentType = 'reference';
-
-  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { continue; }
-
-    // Some tags can terminate paragraph without empty line.
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
-        break;
-      }
-    }
-    if (terminate) { break; }
-  }
-
-  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
-  max = str.length;
-
-  for (pos = 1; pos < max; pos++) {
-    ch = str.charCodeAt(pos);
-    if (ch === 0x5B /* [ */) {
-      return false;
-    } else if (ch === 0x5D /* ] */) {
-      labelEnd = pos;
-      break;
-    } else if (ch === 0x0A /* \n */) {
-      lines++;
-    } else if (ch === 0x5C /* \ */) {
-      pos++;
-      if (pos < max && str.charCodeAt(pos) === 0x0A) {
-        lines++;
-      }
-    }
-  }
-
-  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false; }
-
-  // [label]:   destination   'title'
-  //         ^^^ skip optional whitespace here
-  for (pos = labelEnd + 2; pos < max; pos++) {
-    ch = str.charCodeAt(pos);
-    if (ch === 0x0A) {
-      lines++;
-    } else if (isSpace(ch)) {
-      /*eslint no-empty:0*/
-    } else {
-      break;
-    }
-  }
-
-  // [label]:   destination   'title'
-  //            ^^^^^^^^^^^ parse this
-  res = state.md.helpers.parseLinkDestination(str, pos, max);
-  if (!res.ok) { return false; }
-
-  href = state.md.normalizeLink(res.str);
-  if (!state.md.validateLink(href)) { return false; }
-
-  pos = res.pos;
-  lines += res.lines;
-
-  // save cursor state, we could require to rollback later
-  destEndPos = pos;
-  destEndLineNo = lines;
-
-  // [label]:   destination   'title'
-  //                       ^^^ skipping those spaces
-  start = pos;
-  for (; pos < max; pos++) {
-    ch = str.charCodeAt(pos);
-    if (ch === 0x0A) {
-      lines++;
-    } else if (isSpace(ch)) {
-      /*eslint no-empty:0*/
-    } else {
-      break;
-    }
-  }
-
-  // [label]:   destination   'title'
-  //                          ^^^^^^^ parse this
-  res = state.md.helpers.parseLinkTitle(str, pos, max);
-  if (pos < max && start !== pos && res.ok) {
-    title = res.str;
-    pos = res.pos;
-    lines += res.lines;
-  } else {
-    title = '';
-    pos = destEndPos;
-    lines = destEndLineNo;
-  }
-
-  // skip trailing spaces until the rest of the line
-  while (pos < max) {
-    ch = str.charCodeAt(pos);
-    if (!isSpace(ch)) { break; }
-    pos++;
-  }
-
-  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
-    if (title) {
-      // garbage at the end of the line after title,
-      // but it could still be a valid reference if we roll back
-      title = '';
-      pos = destEndPos;
-      lines = destEndLineNo;
-      while (pos < max) {
-        ch = str.charCodeAt(pos);
-        if (!isSpace(ch)) { break; }
-        pos++;
-      }
-    }
-  }
-
-  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
-    // garbage at the end of the line
-    return false;
-  }
-
-  label = normalizeReference(str.slice(1, labelEnd));
-  if (!label) {
-    // CommonMark 0.20 disallows empty labels
-    return false;
-  }
-
-  // Reference can not terminate anything. This check is for safety only.
-  /*istanbul ignore if*/
-  if (silent) { return true; }
-
-  if (typeof state.env.references === 'undefined') {
-    state.env.references = {};
-  }
-  if (typeof state.env.references[label] === 'undefined') {
-    state.env.references[label] = { title: title, href: href };
-  }
-
-  state.parentType = oldParentType;
-
-  state.line = startLine + lines + 1;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 2948:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Parser state class
-
-
-
-var Token = __webpack_require__(5872);
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-function StateBlock(src, md, env, tokens) {
-  var ch, s, start, pos, len, indent, offset, indent_found;
-
-  this.src = src;
-
-  // link to parser instance
-  this.md     = md;
-
-  this.env = env;
-
-  //
-  // Internal state vartiables
-  //
-
-  this.tokens = tokens;
-
-  this.bMarks = [];  // line begin offsets for fast jumps
-  this.eMarks = [];  // line end offsets for fast jumps
-  this.tShift = [];  // offsets of the first non-space characters (tabs not expanded)
-  this.sCount = [];  // indents for each line (tabs expanded)
-
-  // An amount of virtual spaces (tabs expanded) between beginning
-  // of each line (bMarks) and real beginning of that line.
-  //
-  // It exists only as a hack because blockquotes override bMarks
-  // losing information in the process.
-  //
-  // It's used only when expanding tabs, you can think about it as
-  // an initial tab length, e.g. bsCount=21 applied to string `\t123`
-  // means first tab should be expanded to 4-21%4 === 3 spaces.
-  //
-  this.bsCount = [];
-
-  // block parser variables
-  this.blkIndent  = 0; // required block content indent (for example, if we are
-                       // inside a list, it would be positioned after list marker)
-  this.line       = 0; // line index in src
-  this.lineMax    = 0; // lines count
-  this.tight      = false;  // loose/tight mode for lists
-  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)
-  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)
-
-  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
-  // used in lists to determine if they interrupt a paragraph
-  this.parentType = 'root';
-
-  this.level = 0;
-
-  // renderer
-  this.result = '';
-
-  // Create caches
-  // Generate markers.
-  s = this.src;
-  indent_found = false;
-
-  for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {
-    ch = s.charCodeAt(pos);
-
-    if (!indent_found) {
-      if (isSpace(ch)) {
-        indent++;
-
-        if (ch === 0x09) {
-          offset += 4 - offset % 4;
-        } else {
-          offset++;
-        }
-        continue;
-      } else {
-        indent_found = true;
-      }
-    }
-
-    if (ch === 0x0A || pos === len - 1) {
-      if (ch !== 0x0A) { pos++; }
-      this.bMarks.push(start);
-      this.eMarks.push(pos);
-      this.tShift.push(indent);
-      this.sCount.push(offset);
-      this.bsCount.push(0);
-
-      indent_found = false;
-      indent = 0;
-      offset = 0;
-      start = pos + 1;
-    }
-  }
-
-  // Push fake entry to simplify cache bounds checks
-  this.bMarks.push(s.length);
-  this.eMarks.push(s.length);
-  this.tShift.push(0);
-  this.sCount.push(0);
-  this.bsCount.push(0);
-
-  this.lineMax = this.bMarks.length - 1; // don't count last fake line
-}
-
-// Push new token to "stream".
-//
-StateBlock.prototype.push = function (type, tag, nesting) {
-  var token = new Token(type, tag, nesting);
-  token.block = true;
-
-  if (nesting < 0) this.level--; // closing tag
-  token.level = this.level;
-  if (nesting > 0) this.level++; // opening tag
-
-  this.tokens.push(token);
-  return token;
-};
-
-StateBlock.prototype.isEmpty = function isEmpty(line) {
-  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
-};
-
-StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
-  for (var max = this.lineMax; from < max; from++) {
-    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
-      break;
-    }
-  }
-  return from;
-};
-
-// Skip spaces from given position.
-StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
-  var ch;
-
-  for (var max = this.src.length; pos < max; pos++) {
-    ch = this.src.charCodeAt(pos);
-    if (!isSpace(ch)) { break; }
-  }
-  return pos;
-};
-
-// Skip spaces from given position in reverse.
-StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
-  if (pos <= min) { return pos; }
-
-  while (pos > min) {
-    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1; }
-  }
-  return pos;
-};
-
-// Skip char codes from given position
-StateBlock.prototype.skipChars = function skipChars(pos, code) {
-  for (var max = this.src.length; pos < max; pos++) {
-    if (this.src.charCodeAt(pos) !== code) { break; }
-  }
-  return pos;
-};
-
-// Skip char codes reverse from given position - 1
-StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
-  if (pos <= min) { return pos; }
-
-  while (pos > min) {
-    if (code !== this.src.charCodeAt(--pos)) { return pos + 1; }
-  }
-  return pos;
-};
-
-// cut lines range from source.
-StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
-  var i, lineIndent, ch, first, last, queue, lineStart,
-      line = begin;
-
-  if (begin >= end) {
-    return '';
-  }
-
-  queue = new Array(end - begin);
-
-  for (i = 0; line < end; line++, i++) {
-    lineIndent = 0;
-    lineStart = first = this.bMarks[line];
-
-    if (line + 1 < end || keepLastLF) {
-      // No need for bounds check because we have fake entry on tail.
-      last = this.eMarks[line] + 1;
-    } else {
-      last = this.eMarks[line];
-    }
-
-    while (first < last && lineIndent < indent) {
-      ch = this.src.charCodeAt(first);
-
-      if (isSpace(ch)) {
-        if (ch === 0x09) {
-          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
-        } else {
-          lineIndent++;
-        }
-      } else if (first - lineStart < this.tShift[line]) {
-        // patched tShift masked characters to look like spaces (blockquotes, list markers)
-        lineIndent++;
-      } else {
-        break;
-      }
-
-      first++;
-    }
-
-    if (lineIndent > indent) {
-      // partially expanding tabs in code blocks, e.g '\t\tfoobar'
-      // with indent=2 becomes '  \tfoobar'
-      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);
-    } else {
-      queue[i] = this.src.slice(first, last);
-    }
-  }
-
-  return queue.join('');
-};
-
-// re-export Token class to use in block rules
-StateBlock.prototype.Token = Token;
-
-
-module.exports = StateBlock;
-
-
-/***/ }),
-
-/***/ 1785:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// GFM table, https://github.github.com/gfm/#tables-extension-
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-function getLine(state, line) {
-  var pos = state.bMarks[line] + state.tShift[line],
-      max = state.eMarks[line];
-
-  return state.src.slice(pos, max);
-}
-
-function escapedSplit(str) {
-  var result = [],
-      pos = 0,
-      max = str.length,
-      ch,
-      isEscaped = false,
-      lastPos = 0,
-      current = '';
-
-  ch  = str.charCodeAt(pos);
-
-  while (pos < max) {
-    if (ch === 0x7c/* | */) {
-      if (!isEscaped) {
-        // pipe separating cells, '|'
-        result.push(current + str.substring(lastPos, pos));
-        current = '';
-        lastPos = pos + 1;
-      } else {
-        // escaped pipe, '\|'
-        current += str.substring(lastPos, pos - 1);
-        lastPos = pos;
-      }
-    }
-
-    isEscaped = (ch === 0x5c/* \ */);
-    pos++;
-
-    ch = str.charCodeAt(pos);
-  }
-
-  result.push(current + str.substring(lastPos));
-
-  return result;
-}
-
-
-module.exports = function table(state, startLine, endLine, silent) {
-  var ch, lineText, pos, i, l, nextLine, columns, columnCount, token,
-      aligns, t, tableLines, tbodyLines, oldParentType, terminate,
-      terminatorRules, firstCh, secondCh;
-
-  // should have at least two lines
-  if (startLine + 2 > endLine) { return false; }
-
-  nextLine = startLine + 1;
-
-  if (state.sCount[nextLine] < state.blkIndent) { return false; }
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false; }
-
-  // first character of the second line should be '|', '-', ':',
-  // and no other characters are allowed but spaces;
-  // basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
-
-  pos = state.bMarks[nextLine] + state.tShift[nextLine];
-  if (pos >= state.eMarks[nextLine]) { return false; }
-
-  firstCh = state.src.charCodeAt(pos++);
-  if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false; }
-
-  if (pos >= state.eMarks[nextLine]) { return false; }
-
-  secondCh = state.src.charCodeAt(pos++);
-  if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !isSpace(secondCh)) {
-    return false;
-  }
-
-  // if first character is '-', then second character must not be a space
-  // (due to parsing ambiguity with list)
-  if (firstCh === 0x2D/* - */ && isSpace(secondCh)) { return false; }
-
-  while (pos < state.eMarks[nextLine]) {
-    ch = state.src.charCodeAt(pos);
-
-    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false; }
-
-    pos++;
-  }
-
-  lineText = getLine(state, startLine + 1);
-
-  columns = lineText.split('|');
-  aligns = [];
-  for (i = 0; i < columns.length; i++) {
-    t = columns[i].trim();
-    if (!t) {
-      // allow empty columns before and after table, but not in between columns;
-      // e.g. allow ` |---| `, disallow ` ---||--- `
-      if (i === 0 || i === columns.length - 1) {
-        continue;
-      } else {
-        return false;
-      }
-    }
-
-    if (!/^:?-+:?$/.test(t)) { return false; }
-    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {
-      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right');
-    } else if (t.charCodeAt(0) === 0x3A/* : */) {
-      aligns.push('left');
-    } else {
-      aligns.push('');
-    }
-  }
-
-  lineText = getLine(state, startLine).trim();
-  if (lineText.indexOf('|') === -1) { return false; }
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }
-  columns = escapedSplit(lineText);
-  if (columns.length && columns[0] === '') columns.shift();
-  if (columns.length && columns[columns.length - 1] === '') columns.pop();
-
-  // header row will define an amount of columns in the entire table,
-  // and align row should be exactly the same (the rest of the rows can differ)
-  columnCount = columns.length;
-  if (columnCount === 0 || columnCount !== aligns.length) { return false; }
-
-  if (silent) { return true; }
-
-  oldParentType = state.parentType;
-  state.parentType = 'table';
-
-  // use 'blockquote' lists for termination because it's
-  // the most similar to tables
-  terminatorRules = state.md.block.ruler.getRules('blockquote');
-
-  token     = state.push('table_open', 'table', 1);
-  token.map = tableLines = [ startLine, 0 ];
-
-  token     = state.push('thead_open', 'thead', 1);
-  token.map = [ startLine, startLine + 1 ];
-
-  token     = state.push('tr_open', 'tr', 1);
-  token.map = [ startLine, startLine + 1 ];
-
-  for (i = 0; i < columns.length; i++) {
-    token          = state.push('th_open', 'th', 1);
-    if (aligns[i]) {
-      token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];
-    }
-
-    token          = state.push('inline', '', 0);
-    token.content  = columns[i].trim();
-    token.children = [];
-
-    token          = state.push('th_close', 'th', -1);
-  }
-
-  token     = state.push('tr_close', 'tr', -1);
-  token     = state.push('thead_close', 'thead', -1);
-
-  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
-    if (state.sCount[nextLine] < state.blkIndent) { break; }
-
-    terminate = false;
-    for (i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true;
-        break;
-      }
-    }
-
-    if (terminate) { break; }
-    lineText = getLine(state, nextLine).trim();
-    if (!lineText) { break; }
-    if (state.sCount[nextLine] - state.blkIndent >= 4) { break; }
-    columns = escapedSplit(lineText);
-    if (columns.length && columns[0] === '') columns.shift();
-    if (columns.length && columns[columns.length - 1] === '') columns.pop();
-
-    if (nextLine === startLine + 2) {
-      token     = state.push('tbody_open', 'tbody', 1);
-      token.map = tbodyLines = [ startLine + 2, 0 ];
-    }
-
-    token     = state.push('tr_open', 'tr', 1);
-    token.map = [ nextLine, nextLine + 1 ];
-
-    for (i = 0; i < columnCount; i++) {
-      token          = state.push('td_open', 'td', 1);
-      if (aligns[i]) {
-        token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];
-      }
-
-      token          = state.push('inline', '', 0);
-      token.content  = columns[i] ? columns[i].trim() : '';
-      token.children = [];
-
-      token          = state.push('td_close', 'td', -1);
-    }
-    token = state.push('tr_close', 'tr', -1);
-  }
-
-  if (tbodyLines) {
-    token = state.push('tbody_close', 'tbody', -1);
-    tbodyLines[1] = nextLine;
-  }
-
-  token = state.push('table_close', 'table', -1);
-  tableLines[1] = nextLine;
-
-  state.parentType = oldParentType;
-  state.line = nextLine;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 898:
-/***/ ((module) => {
-
-"use strict";
-
-
-
-module.exports = function block(state) {
-  var token;
-
-  if (state.inlineMode) {
-    token          = new state.Token('inline', '', 0);
-    token.content  = state.src;
-    token.map      = [ 0, 1 ];
-    token.children = [];
-    state.tokens.push(token);
-  } else {
-    state.md.block.parse(state.src, state.md, state.env, state.tokens);
-  }
-};
-
-
-/***/ }),
-
-/***/ 9827:
-/***/ ((module) => {
-
-"use strict";
-
-
-module.exports = function inline(state) {
-  var tokens = state.tokens, tok, i, l;
-
-  // Parse inlines
-  for (i = 0, l = tokens.length; i < l; i++) {
-    tok = tokens[i];
-    if (tok.type === 'inline') {
-      state.md.inline.parse(tok.content, state.md, state.env, tok.children);
-    }
-  }
-};
-
-
-/***/ }),
-
-/***/ 7830:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Replace link-like texts with link nodes.
-//
-// Currently restricted by `md.validateLink()` to http/https/ftp
-//
-
-
-
-var arrayReplaceAt = (__webpack_require__(7022).arrayReplaceAt);
-
-
-function isLinkOpen(str) {
-  return /^<a[>\s]/i.test(str);
-}
-function isLinkClose(str) {
-  return /^<\/a\s*>/i.test(str);
-}
-
-
-module.exports = function linkify(state) {
-  var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos,
-      level, htmlLinkLevel, url, fullUrl, urlText,
-      blockTokens = state.tokens,
-      links;
-
-  if (!state.md.options.linkify) { return; }
-
-  for (j = 0, l = blockTokens.length; j < l; j++) {
-    if (blockTokens[j].type !== 'inline' ||
-        !state.md.linkify.pretest(blockTokens[j].content)) {
-      continue;
-    }
-
-    tokens = blockTokens[j].children;
-
-    htmlLinkLevel = 0;
-
-    // We scan from the end, to keep position when new tags added.
-    // Use reversed logic in links start/end match
-    for (i = tokens.length - 1; i >= 0; i--) {
-      currentToken = tokens[i];
-
-      // Skip content of markdown links
-      if (currentToken.type === 'link_close') {
-        i--;
-        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
-          i--;
-        }
-        continue;
-      }
-
-      // Skip content of html tag links
-      if (currentToken.type === 'html_inline') {
-        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
-          htmlLinkLevel--;
-        }
-        if (isLinkClose(currentToken.content)) {
-          htmlLinkLevel++;
-        }
-      }
-      if (htmlLinkLevel > 0) { continue; }
-
-      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
-
-        text = currentToken.content;
-        links = state.md.linkify.match(text);
-
-        // Now split string to nodes
-        nodes = [];
-        level = currentToken.level;
-        lastPos = 0;
-
-        // forbid escape sequence at the start of the string,
-        // this avoids http\://example.com/ from being linkified as
-        // http:<a href="//example.com/">//example.com/</a>
-        if (links.length > 0 &&
-            links[0].index === 0 &&
-            i > 0 &&
-            tokens[i - 1].type === 'text_special') {
-          links = links.slice(1);
-        }
-
-        for (ln = 0; ln < links.length; ln++) {
-          url = links[ln].url;
-          fullUrl = state.md.normalizeLink(url);
-          if (!state.md.validateLink(fullUrl)) { continue; }
-
-          urlText = links[ln].text;
-
-          // Linkifier might send raw hostnames like "example.com", where url
-          // starts with domain name. So we prepend http:// in those cases,
-          // and remove it afterwards.
-          //
-          if (!links[ln].schema) {
-            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '');
-          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
-            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');
-          } else {
-            urlText = state.md.normalizeLinkText(urlText);
-          }
-
-          pos = links[ln].index;
-
-          if (pos > lastPos) {
-            token         = new state.Token('text', '', 0);
-            token.content = text.slice(lastPos, pos);
-            token.level   = level;
-            nodes.push(token);
-          }
-
-          token         = new state.Token('link_open', 'a', 1);
-          token.attrs   = [ [ 'href', fullUrl ] ];
-          token.level   = level++;
-          token.markup  = 'linkify';
-          token.info    = 'auto';
-          nodes.push(token);
-
-          token         = new state.Token('text', '', 0);
-          token.content = urlText;
-          token.level   = level;
-          nodes.push(token);
-
-          token         = new state.Token('link_close', 'a', -1);
-          token.level   = --level;
-          token.markup  = 'linkify';
-          token.info    = 'auto';
-          nodes.push(token);
-
-          lastPos = links[ln].lastIndex;
-        }
-        if (lastPos < text.length) {
-          token         = new state.Token('text', '', 0);
-          token.content = text.slice(lastPos);
-          token.level   = level;
-          nodes.push(token);
-        }
-
-        // replace current node
-        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
-      }
-    }
-  }
-};
-
-
-/***/ }),
-
-/***/ 4129:
-/***/ ((module) => {
-
-"use strict";
-// Normalize input string
-
-
-
-
-// https://spec.commonmark.org/0.29/#line-ending
-var NEWLINES_RE  = /\r\n?|\n/g;
-var NULL_RE      = /\0/g;
-
-
-module.exports = function normalize(state) {
-  var str;
-
-  // Normalize newlines
-  str = state.src.replace(NEWLINES_RE, '\n');
-
-  // Replace NULL characters
-  str = str.replace(NULL_RE, '\uFFFD');
-
-  state.src = str;
-};
-
-
-/***/ }),
-
-/***/ 2834:
-/***/ ((module) => {
-
-"use strict";
-// Simple typographic replacements
-//
-// (c) (C) → ©
-// (tm) (TM) → ™
-// (r) (R) → ®
-// +- → ±
-// (p) (P) -> §
-// ... → … (also ?.... → ?.., !.... → !..)
-// ???????? → ???, !!!!! → !!!, `,,` → `,`
-// -- → &ndash;, --- → &mdash;
-//
-
-
-// TODO:
-// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
-// - multiplications 2 x 4 -> 2 × 4
-
-var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
-
-// Workaround for phantomjs - need regex without /g flag,
-// or root check will fail every second time
-var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
-
-var SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
-var SCOPED_ABBR = {
-  c: '©',
-  r: '®',
-  tm: '™'
-};
-
-function replaceFn(match, name) {
-  return SCOPED_ABBR[name.toLowerCase()];
-}
-
-function replace_scoped(inlineTokens) {
-  var i, token, inside_autolink = 0;
-
-  for (i = inlineTokens.length - 1; i >= 0; i--) {
-    token = inlineTokens[i];
-
-    if (token.type === 'text' && !inside_autolink) {
-      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
-    }
-
-    if (token.type === 'link_open' && token.info === 'auto') {
-      inside_autolink--;
-    }
-
-    if (token.type === 'link_close' && token.info === 'auto') {
-      inside_autolink++;
-    }
-  }
-}
-
-function replace_rare(inlineTokens) {
-  var i, token, inside_autolink = 0;
-
-  for (i = inlineTokens.length - 1; i >= 0; i--) {
-    token = inlineTokens[i];
-
-    if (token.type === 'text' && !inside_autolink) {
-      if (RARE_RE.test(token.content)) {
-        token.content = token.content
-          .replace(/\+-/g, '±')
-          // .., ..., ....... -> …
-          // but ?..... & !..... -> ?.. & !..
-          .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..')
-          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')
-          // em-dash
-          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\u2014')
-          // en-dash
-          .replace(/(^|\s)--(?=\s|$)/mg, '$1\u2013')
-          .replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, '$1\u2013');
-      }
-    }
-
-    if (token.type === 'link_open' && token.info === 'auto') {
-      inside_autolink--;
-    }
-
-    if (token.type === 'link_close' && token.info === 'auto') {
-      inside_autolink++;
-    }
-  }
-}
-
-
-module.exports = function replace(state) {
-  var blkIdx;
-
-  if (!state.md.options.typographer) { return; }
-
-  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-
-    if (state.tokens[blkIdx].type !== 'inline') { continue; }
-
-    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
-      replace_scoped(state.tokens[blkIdx].children);
-    }
-
-    if (RARE_RE.test(state.tokens[blkIdx].content)) {
-      replace_rare(state.tokens[blkIdx].children);
-    }
-
-  }
-};
-
-
-/***/ }),
-
-/***/ 8450:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Convert straight quotation marks to typographic ones
-//
-
-
-
-var isWhiteSpace   = (__webpack_require__(7022).isWhiteSpace);
-var isPunctChar    = (__webpack_require__(7022).isPunctChar);
-var isMdAsciiPunct = (__webpack_require__(7022).isMdAsciiPunct);
-
-var QUOTE_TEST_RE = /['"]/;
-var QUOTE_RE = /['"]/g;
-var APOSTROPHE = '\u2019'; /* ’ */
-
-
-function replaceAt(str, index, ch) {
-  return str.slice(0, index) + ch + str.slice(index + 1);
-}
-
-function process_inlines(tokens, state) {
-  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar,
-      isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace,
-      canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;
-
-  stack = [];
-
-  for (i = 0; i < tokens.length; i++) {
-    token = tokens[i];
-
-    thisLevel = tokens[i].level;
-
-    for (j = stack.length - 1; j >= 0; j--) {
-      if (stack[j].level <= thisLevel) { break; }
-    }
-    stack.length = j + 1;
-
-    if (token.type !== 'text') { continue; }
-
-    text = token.content;
-    pos = 0;
-    max = text.length;
-
-    /*eslint no-labels:0,block-scoped-var:0*/
-    OUTER:
-    while (pos < max) {
-      QUOTE_RE.lastIndex = pos;
-      t = QUOTE_RE.exec(text);
-      if (!t) { break; }
-
-      canOpen = canClose = true;
-      pos = t.index + 1;
-      isSingle = (t[0] === "'");
-
-      // Find previous character,
-      // default to space if it's the beginning of the line
-      //
-      lastChar = 0x20;
-
-      if (t.index - 1 >= 0) {
-        lastChar = text.charCodeAt(t.index - 1);
-      } else {
-        for (j = i - 1; j >= 0; j--) {
-          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20
-          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'
-
-          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
-          break;
-        }
-      }
-
-      // Find next character,
-      // default to space if it's the end of the line
-      //
-      nextChar = 0x20;
-
-      if (pos < max) {
-        nextChar = text.charCodeAt(pos);
-      } else {
-        for (j = i + 1; j < tokens.length; j++) {
-          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20
-          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'
-
-          nextChar = tokens[j].content.charCodeAt(0);
-          break;
-        }
-      }
-
-      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
-
-      isLastWhiteSpace = isWhiteSpace(lastChar);
-      isNextWhiteSpace = isWhiteSpace(nextChar);
-
-      if (isNextWhiteSpace) {
-        canOpen = false;
-      } else if (isNextPunctChar) {
-        if (!(isLastWhiteSpace || isLastPunctChar)) {
-          canOpen = false;
-        }
-      }
-
-      if (isLastWhiteSpace) {
-        canClose = false;
-      } else if (isLastPunctChar) {
-        if (!(isNextWhiteSpace || isNextPunctChar)) {
-          canClose = false;
-        }
-      }
-
-      if (nextChar === 0x22 /* " */ && t[0] === '"') {
-        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {
-          // special case: 1"" - count first quote as an inch
-          canClose = canOpen = false;
-        }
-      }
-
-      if (canOpen && canClose) {
-        // Replace quotes in the middle of punctuation sequence, but not
-        // in the middle of the words, i.e.:
-        //
-        // 1. foo " bar " baz - not replaced
-        // 2. foo-"-bar-"-baz - replaced
-        // 3. foo"bar"baz     - not replaced
-        //
-        canOpen = isLastPunctChar;
-        canClose = isNextPunctChar;
-      }
-
-      if (!canOpen && !canClose) {
-        // middle of word
-        if (isSingle) {
-          token.content = replaceAt(token.content, t.index, APOSTROPHE);
-        }
-        continue;
-      }
-
-      if (canClose) {
-        // this could be a closing quote, rewind the stack to get a match
-        for (j = stack.length - 1; j >= 0; j--) {
-          item = stack[j];
-          if (stack[j].level < thisLevel) { break; }
-          if (item.single === isSingle && stack[j].level === thisLevel) {
-            item = stack[j];
-
-            if (isSingle) {
-              openQuote = state.md.options.quotes[2];
-              closeQuote = state.md.options.quotes[3];
-            } else {
-              openQuote = state.md.options.quotes[0];
-              closeQuote = state.md.options.quotes[1];
-            }
-
-            // replace token.content *before* tokens[item.token].content,
-            // because, if they are pointing at the same token, replaceAt
-            // could mess up indices when quote length != 1
-            token.content = replaceAt(token.content, t.index, closeQuote);
-            tokens[item.token].content = replaceAt(
-              tokens[item.token].content, item.pos, openQuote);
-
-            pos += closeQuote.length - 1;
-            if (item.token === i) { pos += openQuote.length - 1; }
-
-            text = token.content;
-            max = text.length;
-
-            stack.length = j;
-            continue OUTER;
-          }
-        }
-      }
-
-      if (canOpen) {
-        stack.push({
-          token: i,
-          pos: t.index,
-          single: isSingle,
-          level: thisLevel
-        });
-      } else if (canClose && isSingle) {
-        token.content = replaceAt(token.content, t.index, APOSTROPHE);
-      }
-    }
-  }
-}
-
-
-module.exports = function smartquotes(state) {
-  /*eslint max-depth:0*/
-  var blkIdx;
-
-  if (!state.md.options.typographer) { return; }
-
-  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-
-    if (state.tokens[blkIdx].type !== 'inline' ||
-        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
-      continue;
-    }
-
-    process_inlines(state.tokens[blkIdx].children, state);
-  }
-};
-
-
-/***/ }),
-
-/***/ 6480:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Core state object
-//
-
-
-var Token = __webpack_require__(5872);
-
-
-function StateCore(src, md, env) {
-  this.src = src;
-  this.env = env;
-  this.tokens = [];
-  this.inlineMode = false;
-  this.md = md; // link to parser instance
-}
-
-// re-export Token class to use in core rules
-StateCore.prototype.Token = Token;
-
-
-module.exports = StateCore;
-
-
-/***/ }),
-
-/***/ 6633:
-/***/ ((module) => {
-
-"use strict";
-// Join raw text tokens with the rest of the text
-//
-// This is set as a separate rule to provide an opportunity for plugins
-// to run text replacements after text join, but before escape join.
-//
-// For example, `\:)` shouldn't be replaced with an emoji.
-//
-
-
-
-module.exports = function text_join(state) {
-  var j, l, tokens, curr, max, last,
-      blockTokens = state.tokens;
-
-  for (j = 0, l = blockTokens.length; j < l; j++) {
-    if (blockTokens[j].type !== 'inline') continue;
-
-    tokens = blockTokens[j].children;
-    max = tokens.length;
-
-    for (curr = 0; curr < max; curr++) {
-      if (tokens[curr].type === 'text_special') {
-        tokens[curr].type = 'text';
-      }
-    }
-
-    for (curr = last = 0; curr < max; curr++) {
-      if (tokens[curr].type === 'text' &&
-          curr + 1 < max &&
-          tokens[curr + 1].type === 'text') {
-
-        // collapse two adjacent text nodes
-        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
-      } else {
-        if (curr !== last) { tokens[last] = tokens[curr]; }
-
-        last++;
-      }
-    }
-
-    if (curr !== last) {
-      tokens.length = last;
-    }
-  }
-};
-
-
-/***/ }),
-
-/***/ 3420:
-/***/ ((module) => {
-
-"use strict";
-// Process autolinks '<protocol:...>'
-
-
-
-
-/*eslint max-len:0*/
-var EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
-var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$/;
-
-
-module.exports = function autolink(state, silent) {
-  var url, fullUrl, token, ch, start, max,
-      pos = state.pos;
-
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }
-
-  start = state.pos;
-  max = state.posMax;
-
-  for (;;) {
-    if (++pos >= max) return false;
-
-    ch = state.src.charCodeAt(pos);
-
-    if (ch === 0x3C /* < */) return false;
-    if (ch === 0x3E /* > */) break;
-  }
-
-  url = state.src.slice(start + 1, pos);
-
-  if (AUTOLINK_RE.test(url)) {
-    fullUrl = state.md.normalizeLink(url);
-    if (!state.md.validateLink(fullUrl)) { return false; }
-
-    if (!silent) {
-      token         = state.push('link_open', 'a', 1);
-      token.attrs   = [ [ 'href', fullUrl ] ];
-      token.markup  = 'autolink';
-      token.info    = 'auto';
-
-      token         = state.push('text', '', 0);
-      token.content = state.md.normalizeLinkText(url);
-
-      token         = state.push('link_close', 'a', -1);
-      token.markup  = 'autolink';
-      token.info    = 'auto';
-    }
-
-    state.pos += url.length + 2;
-    return true;
-  }
-
-  if (EMAIL_RE.test(url)) {
-    fullUrl = state.md.normalizeLink('mailto:' + url);
-    if (!state.md.validateLink(fullUrl)) { return false; }
-
-    if (!silent) {
-      token         = state.push('link_open', 'a', 1);
-      token.attrs   = [ [ 'href', fullUrl ] ];
-      token.markup  = 'autolink';
-      token.info    = 'auto';
-
-      token         = state.push('text', '', 0);
-      token.content = state.md.normalizeLinkText(url);
-
-      token         = state.push('link_close', 'a', -1);
-      token.markup  = 'autolink';
-      token.info    = 'auto';
-    }
-
-    state.pos += url.length + 2;
-    return true;
-  }
-
-  return false;
-};
-
-
-/***/ }),
-
-/***/ 40:
-/***/ ((module) => {
-
-"use strict";
-// Parse backticks
-
-
-
-
-module.exports = function backtick(state, silent) {
-  var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength,
-      pos = state.pos,
-      ch = state.src.charCodeAt(pos);
-
-  if (ch !== 0x60/* ` */) { return false; }
-
-  start = pos;
-  pos++;
-  max = state.posMax;
-
-  // scan marker length
-  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }
-
-  marker = state.src.slice(start, pos);
-  openerLength = marker.length;
-
-  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
-    if (!silent) state.pending += marker;
-    state.pos += openerLength;
-    return true;
-  }
-
-  matchStart = matchEnd = pos;
-
-  // Nothing found in the cache, scan until the end of the line (or until marker is found)
-  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
-    matchEnd = matchStart + 1;
-
-    // scan marker length
-    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }
-
-    closerLength = matchEnd - matchStart;
-
-    if (closerLength === openerLength) {
-      // Found matching closer length.
-      if (!silent) {
-        token     = state.push('code_inline', 'code', 0);
-        token.markup  = marker;
-        token.content = state.src.slice(pos, matchStart)
-          .replace(/\n/g, ' ')
-          .replace(/^ (.+) $/, '$1');
-      }
-      state.pos = matchEnd;
-      return true;
-    }
-
-    // Some different length found, put it in cache as upper limit of where closer can be found
-    state.backticks[closerLength] = matchStart;
-  }
-
-  // Scanned through the end, didn't find anything
-  state.backticksScanned = true;
-
-  if (!silent) state.pending += marker;
-  state.pos += openerLength;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 9354:
-/***/ ((module) => {
-
-"use strict";
-// For each opening emphasis-like marker find a matching closing one
-//
-
-
-
-function processDelimiters(state, delimiters) {
-  var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx,
-      isOddMatch, lastJump,
-      openersBottom = {},
-      max = delimiters.length;
-
-  if (!max) return;
-
-  // headerIdx is the first delimiter of the current (where closer is) delimiter run
-  var headerIdx = 0;
-  var lastTokenIdx = -2; // needs any value lower than -1
-  var jumps = [];
-
-  for (closerIdx = 0; closerIdx < max; closerIdx++) {
-    closer = delimiters[closerIdx];
-
-    jumps.push(0);
-
-    // markers belong to same delimiter run if:
-    //  - they have adjacent tokens
-    //  - AND markers are the same
-    //
-    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
-      headerIdx = closerIdx;
-    }
-
-    lastTokenIdx = closer.token;
-
-    // Length is only used for emphasis-specific "rule of 3",
-    // if it's not defined (in strikethrough or 3rd party plugins),
-    // we can default it to 0 to disable those checks.
-    //
-    closer.length = closer.length || 0;
-
-    if (!closer.close) continue;
-
-    // Previously calculated lower bounds (previous fails)
-    // for each marker, each delimiter length modulo 3,
-    // and for whether this closer can be an opener;
-    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
-    if (!openersBottom.hasOwnProperty(closer.marker)) {
-      openersBottom[closer.marker] = [ -1, -1, -1, -1, -1, -1 ];
-    }
-
-    minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)];
-
-    openerIdx = headerIdx - jumps[headerIdx] - 1;
-
-    newMinOpenerIdx = openerIdx;
-
-    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
-      opener = delimiters[openerIdx];
-
-      if (opener.marker !== closer.marker) continue;
-
-      if (opener.open && opener.end < 0) {
-
-        isOddMatch = false;
-
-        // from spec:
-        //
-        // If one of the delimiters can both open and close emphasis, then the
-        // sum of the lengths of the delimiter runs containing the opening and
-        // closing delimiters must not be a multiple of 3 unless both lengths
-        // are multiples of 3.
-        //
-        if (opener.close || closer.open) {
-          if ((opener.length + closer.length) % 3 === 0) {
-            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
-              isOddMatch = true;
-            }
-          }
-        }
-
-        if (!isOddMatch) {
-          // If previous delimiter cannot be an opener, we can safely skip
-          // the entire sequence in future checks. This is required to make
-          // sure algorithm has linear complexity (see *_*_*_*_*_... case).
-          //
-          lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ?
-            jumps[openerIdx - 1] + 1 :
-            0;
-
-          jumps[closerIdx] = closerIdx - openerIdx + lastJump;
-          jumps[openerIdx] = lastJump;
-
-          closer.open  = false;
-          opener.end   = closerIdx;
-          opener.close = false;
-          newMinOpenerIdx = -1;
-          // treat next token as start of run,
-          // it optimizes skips in **<...>**a**<...>** pathological case
-          lastTokenIdx = -2;
-          break;
-        }
-      }
-    }
-
-    if (newMinOpenerIdx !== -1) {
-      // If match for this delimiter run failed, we want to set lower bound for
-      // future lookups. This is required to make sure algorithm has linear
-      // complexity.
-      //
-      // See details here:
-      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
-      //
-      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx;
-    }
-  }
-}
-
-
-module.exports = function link_pairs(state) {
-  var curr,
-      tokens_meta = state.tokens_meta,
-      max = state.tokens_meta.length;
-
-  processDelimiters(state, state.delimiters);
-
-  for (curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      processDelimiters(state, tokens_meta[curr].delimiters);
-    }
-  }
-};
-
-
-/***/ }),
-
-/***/ 7894:
-/***/ ((module) => {
-
-"use strict";
-// Process *this* and _that_
-//
-
-
-
-// Insert each marker as a separate text token, and add it to delimiter list
-//
-module.exports.w = function emphasis(state, silent) {
-  var i, scanned, token,
-      start = state.pos,
-      marker = state.src.charCodeAt(start);
-
-  if (silent) { return false; }
-
-  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false; }
-
-  scanned = state.scanDelims(state.pos, marker === 0x2A);
-
-  for (i = 0; i < scanned.length; i++) {
-    token         = state.push('text', '', 0);
-    token.content = String.fromCharCode(marker);
-
-    state.delimiters.push({
-      // Char code of the starting marker (number).
-      //
-      marker: marker,
-
-      // Total length of these series of delimiters.
-      //
-      length: scanned.length,
-
-      // A position of the token this delimiter corresponds to.
-      //
-      token:  state.tokens.length - 1,
-
-      // If this delimiter is matched as a valid opener, `end` will be
-      // equal to its position, otherwise it's `-1`.
-      //
-      end:    -1,
-
-      // Boolean flags that determine if this delimiter could open or close
-      // an emphasis.
-      //
-      open:   scanned.can_open,
-      close:  scanned.can_close
-    });
-  }
-
-  state.pos += scanned.length;
-
-  return true;
-};
-
-
-function postProcess(state, delimiters) {
-  var i,
-      startDelim,
-      endDelim,
-      token,
-      ch,
-      isStrong,
-      max = delimiters.length;
-
-  for (i = max - 1; i >= 0; i--) {
-    startDelim = delimiters[i];
-
-    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {
-      continue;
-    }
-
-    // Process only opening markers
-    if (startDelim.end === -1) {
-      continue;
-    }
-
-    endDelim = delimiters[startDelim.end];
-
-    // If the previous delimiter has the same marker and is adjacent to this one,
-    // merge those into one strong delimiter.
-    //
-    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
-    //
-    isStrong = i > 0 &&
-               delimiters[i - 1].end === startDelim.end + 1 &&
-               // check that first two markers match and adjacent
-               delimiters[i - 1].marker === startDelim.marker &&
-               delimiters[i - 1].token === startDelim.token - 1 &&
-               // check that last two markers are adjacent (we can safely assume they match)
-               delimiters[startDelim.end + 1].token === endDelim.token + 1;
-
-    ch = String.fromCharCode(startDelim.marker);
-
-    token         = state.tokens[startDelim.token];
-    token.type    = isStrong ? 'strong_open' : 'em_open';
-    token.tag     = isStrong ? 'strong' : 'em';
-    token.nesting = 1;
-    token.markup  = isStrong ? ch + ch : ch;
-    token.content = '';
-
-    token         = state.tokens[endDelim.token];
-    token.type    = isStrong ? 'strong_close' : 'em_close';
-    token.tag     = isStrong ? 'strong' : 'em';
-    token.nesting = -1;
-    token.markup  = isStrong ? ch + ch : ch;
-    token.content = '';
-
-    if (isStrong) {
-      state.tokens[delimiters[i - 1].token].content = '';
-      state.tokens[delimiters[startDelim.end + 1].token].content = '';
-      i--;
-    }
-  }
-}
-
-
-// Walk through delimiter list and replace text tokens with tags
-//
-module.exports.g = function emphasis(state) {
-  var curr,
-      tokens_meta = state.tokens_meta,
-      max = state.tokens_meta.length;
-
-  postProcess(state, state.delimiters);
-
-  for (curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      postProcess(state, tokens_meta[curr].delimiters);
-    }
-  }
-};
-
-
-/***/ }),
-
-/***/ 9391:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Process html entity - &#123;, &#xAF;, &quot;, ...
-
-
-
-var entities          = __webpack_require__(6233);
-var has               = (__webpack_require__(7022).has);
-var isValidEntityCode = (__webpack_require__(7022).isValidEntityCode);
-var fromCodePoint     = (__webpack_require__(7022).fromCodePoint);
-
-
-var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
-var NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;
-
-
-module.exports = function entity(state, silent) {
-  var ch, code, match, token, pos = state.pos, max = state.posMax;
-
-  if (state.src.charCodeAt(pos) !== 0x26/* & */) return false;
-
-  if (pos + 1 >= max) return false;
-
-  ch = state.src.charCodeAt(pos + 1);
-
-  if (ch === 0x23 /* # */) {
-    match = state.src.slice(pos).match(DIGITAL_RE);
-    if (match) {
-      if (!silent) {
-        code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
-
-        token         = state.push('text_special', '', 0);
-        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);
-        token.markup  = match[0];
-        token.info    = 'entity';
-      }
-      state.pos += match[0].length;
-      return true;
-    }
-  } else {
-    match = state.src.slice(pos).match(NAMED_RE);
-    if (match) {
-      if (has(entities, match[1])) {
-        if (!silent) {
-          token         = state.push('text_special', '', 0);
-          token.content = entities[match[1]];
-          token.markup  = match[0];
-          token.info    = 'entity';
-        }
-        state.pos += match[0].length;
-        return true;
-      }
-    }
-  }
-
-  return false;
-};
-
-
-/***/ }),
-
-/***/ 1917:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Process escaped chars and hardbreaks
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-var ESCAPED = [];
-
-for (var i = 0; i < 256; i++) { ESCAPED.push(0); }
-
-'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'
-  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });
-
-
-module.exports = function escape(state, silent) {
-  var ch1, ch2, origStr, escapedStr, token, pos = state.pos, max = state.posMax;
-
-  if (state.src.charCodeAt(pos) !== 0x5C/* \ */) return false;
-  pos++;
-
-  // '\' at the end of the inline block
-  if (pos >= max) return false;
-
-  ch1 = state.src.charCodeAt(pos);
-
-  if (ch1 === 0x0A) {
-    if (!silent) {
-      state.push('hardbreak', 'br', 0);
-    }
-
-    pos++;
-    // skip leading whitespaces from next line
-    while (pos < max) {
-      ch1 = state.src.charCodeAt(pos);
-      if (!isSpace(ch1)) break;
-      pos++;
-    }
-
-    state.pos = pos;
-    return true;
-  }
-
-  escapedStr = state.src[pos];
-
-  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
-    ch2 = state.src.charCodeAt(pos + 1);
-
-    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
-      escapedStr += state.src[pos + 1];
-      pos++;
-    }
-  }
-
-  origStr = '\\' + escapedStr;
-
-  if (!silent) {
-    token = state.push('text_special', '', 0);
-
-    if (ch1 < 256 && ESCAPED[ch1] !== 0) {
-      token.content = escapedStr;
-    } else {
-      token.content = origStr;
-    }
-
-    token.markup = origStr;
-    token.info   = 'escape';
-  }
-
-  state.pos = pos + 1;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 9969:
-/***/ ((module) => {
-
-"use strict";
-// Clean up tokens after emphasis and strikethrough postprocessing:
-// merge adjacent text nodes into one and re-calculate all token levels
-//
-// This is necessary because initially emphasis delimiter markers (*, _, ~)
-// are treated as their own separate text tokens. Then emphasis rule either
-// leaves them as text (needed to merge with adjacent text) or turns them
-// into opening/closing tags (which messes up levels inside).
-//
-
-
-
-module.exports = function fragments_join(state) {
-  var curr, last,
-      level = 0,
-      tokens = state.tokens,
-      max = state.tokens.length;
-
-  for (curr = last = 0; curr < max; curr++) {
-    // re-calculate levels after emphasis/strikethrough turns some text nodes
-    // into opening/closing tags
-    if (tokens[curr].nesting < 0) level--; // closing tag
-    tokens[curr].level = level;
-    if (tokens[curr].nesting > 0) level++; // opening tag
-
-    if (tokens[curr].type === 'text' &&
-        curr + 1 < max &&
-        tokens[curr + 1].type === 'text') {
-
-      // collapse two adjacent text nodes
-      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
-    } else {
-      if (curr !== last) { tokens[last] = tokens[curr]; }
-
-      last++;
-    }
-  }
-
-  if (curr !== last) {
-    tokens.length = last;
-  }
-};
-
-
-/***/ }),
-
-/***/ 1779:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Process html tags
-
-
-
-
-var HTML_TAG_RE = (__webpack_require__(1947)/* .HTML_TAG_RE */ .n);
-
-
-function isLinkOpen(str) {
-  return /^<a[>\s]/i.test(str);
-}
-function isLinkClose(str) {
-  return /^<\/a\s*>/i.test(str);
-}
-
-
-function isLetter(ch) {
-  /*eslint no-bitwise:0*/
-  var lc = ch | 0x20; // to lower case
-  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);
-}
-
-
-module.exports = function html_inline(state, silent) {
-  var ch, match, max, token,
-      pos = state.pos;
-
-  if (!state.md.options.html) { return false; }
-
-  // Check start
-  max = state.posMax;
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||
-      pos + 2 >= max) {
-    return false;
-  }
-
-  // Quick fail on second char
-  ch = state.src.charCodeAt(pos + 1);
-  if (ch !== 0x21/* ! */ &&
-      ch !== 0x3F/* ? */ &&
-      ch !== 0x2F/* / */ &&
-      !isLetter(ch)) {
-    return false;
-  }
-
-  match = state.src.slice(pos).match(HTML_TAG_RE);
-  if (!match) { return false; }
-
-  if (!silent) {
-    token         = state.push('html_inline', '', 0);
-    token.content = state.src.slice(pos, pos + match[0].length);
-
-    if (isLinkOpen(token.content))  state.linkLevel++;
-    if (isLinkClose(token.content)) state.linkLevel--;
-  }
-  state.pos += match[0].length;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 3006:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Process ![image](<src> "title")
-
-
-
-var normalizeReference   = (__webpack_require__(7022).normalizeReference);
-var isSpace              = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function image(state, silent) {
-  var attrs,
-      code,
-      content,
-      label,
-      labelEnd,
-      labelStart,
-      pos,
-      ref,
-      res,
-      title,
-      token,
-      tokens,
-      start,
-      href = '',
-      oldPos = state.pos,
-      max = state.posMax;
-
-  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false; }
-  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false; }
-
-  labelStart = state.pos + 2;
-  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
-
-  // parser failed to find ']', so it's not a valid link
-  if (labelEnd < 0) { return false; }
-
-  pos = labelEnd + 1;
-  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
-    //
-    // Inline link
-    //
-
-    // [link](  <href>  "title"  )
-    //        ^^ skipping these spaces
-    pos++;
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos);
-      if (!isSpace(code) && code !== 0x0A) { break; }
-    }
-    if (pos >= max) { return false; }
-
-    // [link](  <href>  "title"  )
-    //          ^^^^^^ parsing link destination
-    start = pos;
-    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
-    if (res.ok) {
-      href = state.md.normalizeLink(res.str);
-      if (state.md.validateLink(href)) {
-        pos = res.pos;
-      } else {
-        href = '';
-      }
-    }
-
-    // [link](  <href>  "title"  )
-    //                ^^ skipping these spaces
-    start = pos;
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos);
-      if (!isSpace(code) && code !== 0x0A) { break; }
-    }
-
-    // [link](  <href>  "title"  )
-    //                  ^^^^^^^ parsing link title
-    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
-    if (pos < max && start !== pos && res.ok) {
-      title = res.str;
-      pos = res.pos;
-
-      // [link](  <href>  "title"  )
-      //                         ^^ skipping these spaces
-      for (; pos < max; pos++) {
-        code = state.src.charCodeAt(pos);
-        if (!isSpace(code) && code !== 0x0A) { break; }
-      }
-    } else {
-      title = '';
-    }
-
-    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
-      state.pos = oldPos;
-      return false;
-    }
-    pos++;
-  } else {
-    //
-    // Link reference
-    //
-    if (typeof state.env.references === 'undefined') { return false; }
-
-    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
-      start = pos + 1;
-      pos = state.md.helpers.parseLinkLabel(state, pos);
-      if (pos >= 0) {
-        label = state.src.slice(start, pos++);
-      } else {
-        pos = labelEnd + 1;
-      }
-    } else {
-      pos = labelEnd + 1;
-    }
-
-    // covers label === '' and label === undefined
-    // (collapsed reference link and shortcut reference link respectively)
-    if (!label) { label = state.src.slice(labelStart, labelEnd); }
-
-    ref = state.env.references[normalizeReference(label)];
-    if (!ref) {
-      state.pos = oldPos;
-      return false;
-    }
-    href = ref.href;
-    title = ref.title;
-  }
-
-  //
-  // We found the end of the link, and know for a fact it's a valid link;
-  // so all that's left to do is to call tokenizer.
-  //
-  if (!silent) {
-    content = state.src.slice(labelStart, labelEnd);
-
-    state.md.inline.parse(
-      content,
-      state.md,
-      state.env,
-      tokens = []
-    );
-
-    token          = state.push('image', 'img', 0);
-    token.attrs    = attrs = [ [ 'src', href ], [ 'alt', '' ] ];
-    token.children = tokens;
-    token.content  = content;
-
-    if (title) {
-      attrs.push([ 'title', title ]);
-    }
-  }
-
-  state.pos = pos;
-  state.posMax = max;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 1727:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Process [link](<to> "stuff")
-
-
-
-var normalizeReference   = (__webpack_require__(7022).normalizeReference);
-var isSpace              = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function link(state, silent) {
-  var attrs,
-      code,
-      label,
-      labelEnd,
-      labelStart,
-      pos,
-      res,
-      ref,
-      token,
-      href = '',
-      title = '',
-      oldPos = state.pos,
-      max = state.posMax,
-      start = state.pos,
-      parseReference = true;
-
-  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false; }
-
-  labelStart = state.pos + 1;
-  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
-
-  // parser failed to find ']', so it's not a valid link
-  if (labelEnd < 0) { return false; }
-
-  pos = labelEnd + 1;
-  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
-    //
-    // Inline link
-    //
-
-    // might have found a valid shortcut link, disable reference parsing
-    parseReference = false;
-
-    // [link](  <href>  "title"  )
-    //        ^^ skipping these spaces
-    pos++;
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos);
-      if (!isSpace(code) && code !== 0x0A) { break; }
-    }
-    if (pos >= max) { return false; }
-
-    // [link](  <href>  "title"  )
-    //          ^^^^^^ parsing link destination
-    start = pos;
-    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
-    if (res.ok) {
-      href = state.md.normalizeLink(res.str);
-      if (state.md.validateLink(href)) {
-        pos = res.pos;
-      } else {
-        href = '';
-      }
-
-      // [link](  <href>  "title"  )
-      //                ^^ skipping these spaces
-      start = pos;
-      for (; pos < max; pos++) {
-        code = state.src.charCodeAt(pos);
-        if (!isSpace(code) && code !== 0x0A) { break; }
-      }
-
-      // [link](  <href>  "title"  )
-      //                  ^^^^^^^ parsing link title
-      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
-      if (pos < max && start !== pos && res.ok) {
-        title = res.str;
-        pos = res.pos;
-
-        // [link](  <href>  "title"  )
-        //                         ^^ skipping these spaces
-        for (; pos < max; pos++) {
-          code = state.src.charCodeAt(pos);
-          if (!isSpace(code) && code !== 0x0A) { break; }
-        }
-      }
-    }
-
-    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
-      // parsing a valid shortcut link failed, fallback to reference
-      parseReference = true;
-    }
-    pos++;
-  }
-
-  if (parseReference) {
-    //
-    // Link reference
-    //
-    if (typeof state.env.references === 'undefined') { return false; }
-
-    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
-      start = pos + 1;
-      pos = state.md.helpers.parseLinkLabel(state, pos);
-      if (pos >= 0) {
-        label = state.src.slice(start, pos++);
-      } else {
-        pos = labelEnd + 1;
-      }
-    } else {
-      pos = labelEnd + 1;
-    }
-
-    // covers label === '' and label === undefined
-    // (collapsed reference link and shortcut reference link respectively)
-    if (!label) { label = state.src.slice(labelStart, labelEnd); }
-
-    ref = state.env.references[normalizeReference(label)];
-    if (!ref) {
-      state.pos = oldPos;
-      return false;
-    }
-    href = ref.href;
-    title = ref.title;
-  }
-
-  //
-  // We found the end of the link, and know for a fact it's a valid link;
-  // so all that's left to do is to call tokenizer.
-  //
-  if (!silent) {
-    state.pos = labelStart;
-    state.posMax = labelEnd;
-
-    token        = state.push('link_open', 'a', 1);
-    token.attrs  = attrs = [ [ 'href', href ] ];
-    if (title) {
-      attrs.push([ 'title', title ]);
-    }
-
-    state.linkLevel++;
-    state.md.inline.tokenize(state);
-    state.linkLevel--;
-
-    token        = state.push('link_close', 'a', -1);
-  }
-
-  state.pos = pos;
-  state.posMax = max;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 2906:
-/***/ ((module) => {
-
-"use strict";
-// Process links like https://example.org/
-
-
-
-
-// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
-
-
-module.exports = function linkify(state, silent) {
-  var pos, max, match, proto, link, url, fullUrl, token;
-
-  if (!state.md.options.linkify) return false;
-  if (state.linkLevel > 0) return false;
-
-  pos = state.pos;
-  max = state.posMax;
-
-  if (pos + 3 > max) return false;
-  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false;
-  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false;
-  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false;
-
-  match = state.pending.match(SCHEME_RE);
-  if (!match) return false;
-
-  proto = match[1];
-
-  link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
-  if (!link) return false;
-
-  url = link.url;
-
-  // disallow '*' at the end of the link (conflicts with emphasis)
-  url = url.replace(/\*+$/, '');
-
-  fullUrl = state.md.normalizeLink(url);
-  if (!state.md.validateLink(fullUrl)) return false;
-
-  if (!silent) {
-    state.pending = state.pending.slice(0, -proto.length);
-
-    token         = state.push('link_open', 'a', 1);
-    token.attrs   = [ [ 'href', fullUrl ] ];
-    token.markup  = 'linkify';
-    token.info    = 'auto';
-
-    token         = state.push('text', '', 0);
-    token.content = state.md.normalizeLinkText(url);
-
-    token         = state.push('link_close', 'a', -1);
-    token.markup  = 'linkify';
-    token.info    = 'auto';
-  }
-
-  state.pos += url.length - proto.length;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 3905:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Proceess '\n'
-
-
-
-var isSpace = (__webpack_require__(7022).isSpace);
-
-
-module.exports = function newline(state, silent) {
-  var pmax, max, ws, pos = state.pos;
-
-  if (state.src.charCodeAt(pos) !== 0x0A/* \n */) { return false; }
-
-  pmax = state.pending.length - 1;
-  max = state.posMax;
-
-  // '  \n' -> hardbreak
-  // Lookup in pending chars is bad practice! Don't copy to other rules!
-  // Pending string is stored in concat mode, indexed lookups will cause
-  // convertion to flat mode.
-  if (!silent) {
-    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
-      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
-        // Find whitespaces tail of pending chars.
-        ws = pmax - 1;
-        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--;
-
-        state.pending = state.pending.slice(0, ws);
-        state.push('hardbreak', 'br', 0);
-      } else {
-        state.pending = state.pending.slice(0, -1);
-        state.push('softbreak', 'br', 0);
-      }
-
-    } else {
-      state.push('softbreak', 'br', 0);
-    }
-  }
-
-  pos++;
-
-  // skip heading spaces for next line
-  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++; }
-
-  state.pos = pos;
-  return true;
-};
-
-
-/***/ }),
-
-/***/ 670:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-// Inline parser state
-
-
-
-
-var Token          = __webpack_require__(5872);
-var isWhiteSpace   = (__webpack_require__(7022).isWhiteSpace);
-var isPunctChar    = (__webpack_require__(7022).isPunctChar);
-var isMdAsciiPunct = (__webpack_require__(7022).isMdAsciiPunct);
-
-
-function StateInline(src, md, env, outTokens) {
-  this.src = src;
-  this.env = env;
-  this.md = md;
-  this.tokens = outTokens;
-  this.tokens_meta = Array(outTokens.length);
-
-  this.pos = 0;
-  this.posMax = this.src.length;
-  this.level = 0;
-  this.pending = '';
-  this.pendingLevel = 0;
-
-  // Stores { start: end } pairs. Useful for backtrack
-  // optimization of pairs parse (emphasis, strikes).
-  this.cache = {};
-
-  // List of emphasis-like delimiters for current tag
-  this.delimiters = [];
-
-  // Stack of delimiter lists for upper level tags
-  this._prev_delimiters = [];
-
-  // backtick length => last seen position
-  this.backticks = {};
-  this.backticksScanned = false;
-
-  // Counter used to disable inline linkify-it execution
-  // inside <a> and markdown links
-  this.linkLevel = 0;
-}
-
-
-// Flush pending text
-//
-StateInline.prototype.pushPending = function () {
-  var token = new Token('text', '', 0);
-  token.content = this.pending;
-  token.level = this.pendingLevel;
-  this.tokens.push(token);
-  this.pending = '';
-  return token;
-};
-
-
-// Push new token to "stream".
-// If pending text exists - flush it as text token
-//
-StateInline.prototype.push = function (type, tag, nesting) {
-  if (this.pending) {
-    this.pushPending();
+/**
+ * new MarkdownIt([presetName, options])
+ * - presetName (String): optional, `commonmark` / `zero`
+ * - options (Object)
+ *
+ * Creates parser instanse with given config. Can be called without `new`.
+ *
+ * ##### presetName
+ *
+ * MarkdownIt provides named presets as a convenience to quickly
+ * enable/disable active syntax rules and options for common use cases.
+ *
+ * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -
+ *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
+ * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -
+ *   similar to GFM, used when no preset name given. Enables all available rules,
+ *   but still without html, typographer & autolinker.
+ * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -
+ *   all rules disabled. Useful to quickly setup your config via `.enable()`.
+ *   For example, when you need only `bold` and `italic` markup and nothing else.
+ *
+ * ##### options:
+ *
+ * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
+ *   That's not safe! You may need external sanitizer to protect output from XSS.
+ *   It's better to extend features via plugins, instead of enabling HTML.
+ * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
+ *   (`<br />`). This is needed only for full CommonMark compatibility. In real
+ *   world you will need HTML output.
+ * - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
+ * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
+ *   Can be useful for external highlighters.
+ * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
+ * - __typographer__  - `false`. Set `true` to enable [some language-neutral
+ *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +
+ *   quotes beautification (smartquotes).
+ * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
+ *   pairs, when typographer enabled and smartquotes on. For example, you can
+ *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and
+ *   `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
+ * - __highlight__ - `null`. Highlighter function for fenced code blocks.
+ *   Highlighter `function (str, lang)` should return escaped HTML. It can also
+ *   return empty string if the source was not changed and should be escaped
+ *   externaly. If result starts with <pre... internal wrapper is skipped.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * // commonmark mode
+ * var md = require('markdown-it')('commonmark');
+ *
+ * // default mode
+ * var md = require('markdown-it')();
+ *
+ * // enable everything
+ * var md = require('markdown-it')({
+ *   html: true,
+ *   linkify: true,
+ *   typographer: true
+ * });
+ * ```
+ *
+ * ##### Syntax highlighting
+ *
+ * ```js
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;
+ *       } catch (__) {}
+ *     }
+ *
+ *     return ''; // use external default escaping
+ *   }
+ * });
+ * ```
+ *
+ * Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):
+ *
+ * ```javascript
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * // Actual default values
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return '<pre><code class="hljs">' +
+ *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
+ *                '</code></pre>';
+ *       } catch (__) {}
+ *     }
+ *
+ *     return '<pre><code class="hljs">' + md.utils.escapeHtml(str) + '</code></pre>';
+ *   }
+ * });
+ * ```
+ *
+ **/
+function MarkdownIt(presetName, options) {
+  if (!(this instanceof MarkdownIt)) {
+    return new MarkdownIt(presetName, options);
   }
-
-  var token = new Token(type, tag, nesting);
-  var token_meta = null;
-
-  if (nesting < 0) {
-    // closing tag
-    this.level--;
-    this.delimiters = this._prev_delimiters.pop();
+  if (!options) {
+    if (!isString(presetName)) {
+      options = presetName || {};
+      presetName = 'default';
+    }
   }
 
-  token.level = this.level;
-
-  if (nesting > 0) {
-    // opening tag
-    this.level++;
-    this._prev_delimiters.push(this.delimiters);
-    this.delimiters = [];
-    token_meta = { delimiters: this.delimiters };
-  }
+  /**
+   * MarkdownIt#inline -> ParserInline
+   *
+   * Instance of [[ParserInline]]. You may need it to add new rules when
+   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
+   * [[MarkdownIt.enable]].
+   **/
+  this.inline = new ParserInline();
 
-  this.pendingLevel = this.level;
-  this.tokens.push(token);
-  this.tokens_meta.push(token_meta);
-  return token;
-};
+  /**
+   * MarkdownIt#block -> ParserBlock
+   *
+   * Instance of [[ParserBlock]]. You may need it to add new rules when
+   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
+   * [[MarkdownIt.enable]].
+   **/
+  this.block = new ParserBlock();
 
+  /**
+   * MarkdownIt#core -> Core
+   *
+   * Instance of [[Core]] chain executor. You may need it to add new rules when
+   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
+   * [[MarkdownIt.enable]].
+   **/
+  this.core = new Core();
 
-// Scan a sequence of emphasis-like markers, and determine whether
-// it can start an emphasis sequence or end an emphasis sequence.
-//
-//  - start - position to scan from (it should point at a valid marker);
-//  - canSplitWord - determine if these markers can be found inside a word
-//
-StateInline.prototype.scanDelims = function (start, canSplitWord) {
-  var pos = start, lastChar, nextChar, count, can_open, can_close,
-      isLastWhiteSpace, isLastPunctChar,
-      isNextWhiteSpace, isNextPunctChar,
-      left_flanking = true,
-      right_flanking = true,
-      max = this.posMax,
-      marker = this.src.charCodeAt(start);
+  /**
+   * MarkdownIt#renderer -> Renderer
+   *
+   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
+   * rules for new token types, generated by plugins.
+   *
+   * ##### Example
+   *
+   * ```javascript
+   * var md = require('markdown-it')();
+   *
+   * function myToken(tokens, idx, options, env, self) {
+   *   //...
+   *   return result;
+   * };
+   *
+   * md.renderer.rules['my_token'] = myToken
+   * ```
+   *
+   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
+   **/
+  this.renderer = new Renderer();
 
-  // treat beginning of the line as a whitespace
-  lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;
+  /**
+   * MarkdownIt#linkify -> LinkifyIt
+   *
+   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
+   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)
+   * rule.
+   **/
+  this.linkify = new LinkifyIt();
 
-  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++; }
+  /**
+   * MarkdownIt#validateLink(url) -> Boolean
+   *
+   * Link validation function. CommonMark allows too much in links. By default
+   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
+   * except some embedded image types.
+   *
+   * You can change this behaviour:
+   *
+   * ```javascript
+   * var md = require('markdown-it')();
+   * // enable everything
+   * md.validateLink = function () { return true; }
+   * ```
+   **/
+  this.validateLink = validateLink;
 
-  count = pos - start;
+  /**
+   * MarkdownIt#normalizeLink(url) -> String
+   *
+   * Function used to encode link url to a machine-readable format,
+   * which includes url-encoding, punycode, etc.
+   **/
+  this.normalizeLink = normalizeLink;
 
-  // treat end of the line as a whitespace
-  nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;
+  /**
+   * MarkdownIt#normalizeLinkText(url) -> String
+   *
+   * Function used to decode link url to a human-readable format`
+   **/
+  this.normalizeLinkText = normalizeLinkText;
 
-  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+  // Expose utils & helpers for easy acces from plugins
 
-  isLastWhiteSpace = isWhiteSpace(lastChar);
-  isNextWhiteSpace = isWhiteSpace(nextChar);
+  /**
+   * MarkdownIt#utils -> utils
+   *
+   * Assorted utility functions, useful to write plugins. See details
+   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).
+   **/
+  this.utils = utils;
 
-  if (isNextWhiteSpace) {
-    left_flanking = false;
-  } else if (isNextPunctChar) {
-    if (!(isLastWhiteSpace || isLastPunctChar)) {
-      left_flanking = false;
-    }
+  /**
+   * MarkdownIt#helpers -> helpers
+   *
+   * Link components parser functions, useful to write plugins. See details
+   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
+   **/
+  this.helpers = assign({}, helpers);
+  this.options = {};
+  this.configure(presetName);
+  if (options) {
+    this.set(options);
   }
+}
+
+/** chainable
+ * MarkdownIt.set(options)
+ *
+ * Set parser options (in the same format as in constructor). Probably, you
+ * will never need it, but you can change options after constructor call.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')()
+ *             .set({ html: true, breaks: true })
+ *             .set({ typographer, true });
+ * ```
+ *
+ * __Note:__ To achieve the best possible performance, don't modify a
+ * `markdown-it` instance options on the fly. If you need multiple configurations
+ * it's best to create multiple instances and initialize each with separate
+ * config.
+ **/
+MarkdownIt.prototype.set = function (options) {
+  assign(this.options, options);
+  return this;
+};
 
-  if (isLastWhiteSpace) {
-    right_flanking = false;
-  } else if (isLastPunctChar) {
-    if (!(isNextWhiteSpace || isNextPunctChar)) {
-      right_flanking = false;
+/** chainable, internal
+ * MarkdownIt.configure(presets)
+ *
+ * Batch load of all options and compenent settings. This is internal method,
+ * and you probably will not need it. But if you will - see available presets
+ * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
+ *
+ * We strongly recommend to use presets instead of direct config loads. That
+ * will give better compatibility with next versions.
+ **/
+MarkdownIt.prototype.configure = function (presets) {
+  const self = this;
+  if (isString(presets)) {
+    const presetName = presets;
+    presets = config[presetName];
+    if (!presets) {
+      throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
     }
   }
-
-  if (!canSplitWord) {
-    can_open  = left_flanking  && (!right_flanking || isLastPunctChar);
-    can_close = right_flanking && (!left_flanking  || isNextPunctChar);
-  } else {
-    can_open  = left_flanking;
-    can_close = right_flanking;
+  if (!presets) {
+    throw new Error('Wrong `markdown-it` preset, can\'t be empty');
   }
-
-  return {
-    can_open:  can_open,
-    can_close: can_close,
-    length:    count
-  };
-};
-
-
-// re-export Token class to use in block rules
-StateInline.prototype.Token = Token;
-
-
-module.exports = StateInline;
-
-
-/***/ }),
-
-/***/ 4814:
-/***/ ((module) => {
-
-"use strict";
-// ~~strike through~~
-//
-
-
-
-// Insert each marker as a separate text token, and add it to delimiter list
-//
-module.exports.w = function strikethrough(state, silent) {
-  var i, scanned, token, len, ch,
-      start = state.pos,
-      marker = state.src.charCodeAt(start);
-
-  if (silent) { return false; }
-
-  if (marker !== 0x7E/* ~ */) { return false; }
-
-  scanned = state.scanDelims(state.pos, true);
-  len = scanned.length;
-  ch = String.fromCharCode(marker);
-
-  if (len < 2) { return false; }
-
-  if (len % 2) {
-    token         = state.push('text', '', 0);
-    token.content = ch;
-    len--;
+  if (presets.options) {
+    self.set(presets.options);
   }
-
-  for (i = 0; i < len; i += 2) {
-    token         = state.push('text', '', 0);
-    token.content = ch + ch;
-
-    state.delimiters.push({
-      marker: marker,
-      length: 0,     // disable "rule of 3" length checks meant for emphasis
-      token:  state.tokens.length - 1,
-      end:    -1,
-      open:   scanned.can_open,
-      close:  scanned.can_close
+  if (presets.components) {
+    Object.keys(presets.components).forEach(function (name) {
+      if (presets.components[name].rules) {
+        self[name].ruler.enableOnly(presets.components[name].rules);
+      }
+      if (presets.components[name].rules2) {
+        self[name].ruler2.enableOnly(presets.components[name].rules2);
+      }
     });
   }
-
-  state.pos += scanned.length;
-
-  return true;
+  return this;
 };
 
-
-function postProcess(state, delimiters) {
-  var i, j,
-      startDelim,
-      endDelim,
-      token,
-      loneMarkers = [],
-      max = delimiters.length;
-
-  for (i = 0; i < max; i++) {
-    startDelim = delimiters[i];
-
-    if (startDelim.marker !== 0x7E/* ~ */) {
-      continue;
-    }
-
-    if (startDelim.end === -1) {
-      continue;
-    }
-
-    endDelim = delimiters[startDelim.end];
-
-    token         = state.tokens[startDelim.token];
-    token.type    = 's_open';
-    token.tag     = 's';
-    token.nesting = 1;
-    token.markup  = '~~';
-    token.content = '';
-
-    token         = state.tokens[endDelim.token];
-    token.type    = 's_close';
-    token.tag     = 's';
-    token.nesting = -1;
-    token.markup  = '~~';
-    token.content = '';
-
-    if (state.tokens[endDelim.token - 1].type === 'text' &&
-        state.tokens[endDelim.token - 1].content === '~') {
-
-      loneMarkers.push(endDelim.token - 1);
-    }
+/** chainable
+ * MarkdownIt.enable(list, ignoreInvalid)
+ * - list (String|Array): rule name or list of rule names to enable
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * Enable list or rules. It will automatically find appropriate components,
+ * containing rules with given names. If rule not found, and `ignoreInvalid`
+ * not set - throws exception.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')()
+ *             .enable(['sub', 'sup'])
+ *             .disable('smartquotes');
+ * ```
+ **/
+MarkdownIt.prototype.enable = function (list, ignoreInvalid) {
+  let result = [];
+  if (!Array.isArray(list)) {
+    list = [list];
   }
+  ['core', 'block', 'inline'].forEach(function (chain) {
+    result = result.concat(this[chain].ruler.enable(list, true));
+  }, this);
+  result = result.concat(this.inline.ruler2.enable(list, true));
+  const missed = list.filter(function (name) {
+    return result.indexOf(name) < 0;
+  });
+  if (missed.length && !ignoreInvalid) {
+    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);
+  }
+  return this;
+};
 
-  // If a marker sequence has an odd number of characters, it's splitted
-  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
-  // start of the sequence.
-  //
-  // So, we have to move all those markers after subsequent s_close tags.
-  //
-  while (loneMarkers.length) {
-    i = loneMarkers.pop();
-    j = i + 1;
-
-    while (j < state.tokens.length && state.tokens[j].type === 's_close') {
-      j++;
-    }
+/** chainable
+ * MarkdownIt.disable(list, ignoreInvalid)
+ * - list (String|Array): rule name or list of rule names to disable.
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * The same as [[MarkdownIt.enable]], but turn specified rules off.
+ **/
+MarkdownIt.prototype.disable = function (list, ignoreInvalid) {
+  let result = [];
+  if (!Array.isArray(list)) {
+    list = [list];
+  }
+  ['core', 'block', 'inline'].forEach(function (chain) {
+    result = result.concat(this[chain].ruler.disable(list, true));
+  }, this);
+  result = result.concat(this.inline.ruler2.disable(list, true));
+  const missed = list.filter(function (name) {
+    return result.indexOf(name) < 0;
+  });
+  if (missed.length && !ignoreInvalid) {
+    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);
+  }
+  return this;
+};
 
-    j--;
+/** chainable
+ * MarkdownIt.use(plugin, params)
+ *
+ * Load specified plugin with given params into current parser instance.
+ * It's just a sugar to call `plugin(md, params)` with curring.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var iterator = require('markdown-it-for-inline');
+ * var md = require('markdown-it')()
+ *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
+ *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
+ *             });
+ * ```
+ **/
+MarkdownIt.prototype.use = function (plugin /*, params, ... */) {
+  const args = [this].concat(Array.prototype.slice.call(arguments, 1));
+  plugin.apply(plugin, args);
+  return this;
+};
 
-    if (i !== j) {
-      token = state.tokens[j];
-      state.tokens[j] = state.tokens[i];
-      state.tokens[i] = token;
-    }
+/** internal
+ * MarkdownIt.parse(src, env) -> Array
+ * - src (String): source string
+ * - env (Object): environment sandbox
+ *
+ * Parse input string and return list of block tokens (special token type
+ * "inline" will contain list of inline tokens). You should not call this
+ * method directly, until you write custom renderer (for example, to produce
+ * AST).
+ *
+ * `env` is used to pass data between "distributed" rules and return additional
+ * metadata like reference info, needed for the renderer. It also can be used to
+ * inject data in specific cases. Usually, you will be ok to pass `{}`,
+ * and then pass updated object to renderer.
+ **/
+MarkdownIt.prototype.parse = function (src, env) {
+  if (typeof src !== 'string') {
+    throw new Error('Input data should be a String');
   }
-}
-
+  const state = new this.core.State(src, this, env);
+  this.core.process(state);
+  return state.tokens;
+};
 
-// Walk through delimiter list and replace text tokens with tags
-//
-module.exports.g = function strikethrough(state) {
-  var curr,
-      tokens_meta = state.tokens_meta,
-      max = state.tokens_meta.length;
+/**
+ * MarkdownIt.render(src [, env]) -> String
+ * - src (String): source string
+ * - env (Object): environment sandbox
+ *
+ * Render markdown string into html. It does all magic for you :).
+ *
+ * `env` can be used to inject additional metadata (`{}` by default).
+ * But you will not need it with high probability. See also comment
+ * in [[MarkdownIt.parse]].
+ **/
+MarkdownIt.prototype.render = function (src, env) {
+  env = env || {};
+  return this.renderer.render(this.parse(src, env), this.options, env);
+};
 
-  postProcess(state, state.delimiters);
+/** internal
+ * MarkdownIt.parseInline(src, env) -> Array
+ * - src (String): source string
+ * - env (Object): environment sandbox
+ *
+ * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
+ * block tokens list with the single `inline` element, containing parsed inline
+ * tokens in `children` property. Also updates `env` object.
+ **/
+MarkdownIt.prototype.parseInline = function (src, env) {
+  const state = new this.core.State(src, this, env);
+  state.inlineMode = true;
+  this.core.process(state);
+  return state.tokens;
+};
 
-  for (curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      postProcess(state, tokens_meta[curr].delimiters);
-    }
-  }
+/**
+ * MarkdownIt.renderInline(src [, env]) -> String
+ * - src (String): source string
+ * - env (Object): environment sandbox
+ *
+ * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
+ * will NOT be wrapped into `<p>` tags.
+ **/
+MarkdownIt.prototype.renderInline = function (src, env) {
+  env = env || {};
+  return this.renderer.render(this.parseInline(src, env), this.options, env);
 };
 
+module.exports = MarkdownIt;
+
 
 /***/ }),
 
-/***/ 9941:
-/***/ ((module) => {
+/***/ 5778:
+/***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
-// Skip text characters for text token, place those to pending buffer
-// and increment current pos
 
 
+/* eslint-disable no-bitwise */
 
+const decodeCache = {};
 
-// Rule to skip pure text
-// '{}$%@~+=:' reserved for extentions
+function getDecodeCache (exclude) {
+  let cache = decodeCache[exclude];
+  if (cache) { return cache }
 
-// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
+  cache = decodeCache[exclude] = [];
 
-// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
-// http://spec.commonmark.org/0.15/#ascii-punctuation-character
-function isTerminatorChar(ch) {
-  switch (ch) {
-    case 0x0A/* \n */:
-    case 0x21/* ! */:
-    case 0x23/* # */:
-    case 0x24/* $ */:
-    case 0x25/* % */:
-    case 0x26/* & */:
-    case 0x2A/* * */:
-    case 0x2B/* + */:
-    case 0x2D/* - */:
-    case 0x3A/* : */:
-    case 0x3C/* < */:
-    case 0x3D/* = */:
-    case 0x3E/* > */:
-    case 0x40/* @ */:
-    case 0x5B/* [ */:
-    case 0x5C/* \ */:
-    case 0x5D/* ] */:
-    case 0x5E/* ^ */:
-    case 0x5F/* _ */:
-    case 0x60/* ` */:
-    case 0x7B/* { */:
-    case 0x7D/* } */:
-    case 0x7E/* ~ */:
-      return true;
-    default:
-      return false;
+  for (let i = 0; i < 128; i++) {
+    const ch = String.fromCharCode(i);
+    cache.push(ch);
   }
-}
-
-module.exports = function text(state, silent) {
-  var pos = state.pos;
 
-  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
-    pos++;
+  for (let i = 0; i < exclude.length; i++) {
+    const ch = exclude.charCodeAt(i);
+    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);
   }
 
-  if (pos === state.pos) { return false; }
-
-  if (!silent) { state.pending += state.src.slice(state.pos, pos); }
-
-  state.pos = pos;
-
-  return true;
-};
+  return cache
+}
 
-// Alternative implementation, for memory.
+// Decode percent-encoded string.
 //
-// It costs 10% of performance, but allows extend terminators list, if place it
-// to `ParcerInline` property. Probably, will switch to it sometime, such
-// flexibility required.
-
-/*
-var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;
-
-module.exports = function text(state, silent) {
-  var pos = state.pos,
-      idx = state.src.slice(pos).search(TERMINATOR_RE);
-
-  // first char is terminator -> empty text
-  if (idx === 0) { return false; }
-
-  // no terminator -> text till end of string
-  if (idx < 0) {
-    if (!silent) { state.pending += state.src.slice(pos); }
-    state.pos = state.src.length;
-    return true;
+function decode (string, exclude) {
+  if (typeof exclude !== 'string') {
+    exclude = decode.defaultChars;
   }
 
-  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }
-
-  state.pos += idx;
-
-  return true;
-};*/
-
-
-/***/ }),
-
-/***/ 5872:
-/***/ ((module) => {
-
-"use strict";
-// Token class
-
-
+  const cache = getDecodeCache(exclude);
 
+  return string.replace(/(%[a-f0-9]{2})+/gi, function (seq) {
+    let result = '';
 
-/**
- * class Token
- **/
-
-/**
- * new Token(type, tag, nesting)
- *
- * Create new token and fill passed properties.
- **/
-function Token(type, tag, nesting) {
-  /**
-   * Token#type -> String
-   *
-   * Type of the token (string, e.g. "paragraph_open")
-   **/
-  this.type     = type;
-
-  /**
-   * Token#tag -> String
-   *
-   * html tag name, e.g. "p"
-   **/
-  this.tag      = tag;
+    for (let i = 0, l = seq.length; i < l; i += 3) {
+      const b1 = parseInt(seq.slice(i + 1, i + 3), 16);
 
-  /**
-   * Token#attrs -> Array
-   *
-   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
-   **/
-  this.attrs    = null;
+      if (b1 < 0x80) {
+        result += cache[b1];
+        continue
+      }
 
-  /**
-   * Token#map -> Array
-   *
-   * Source map info. Format: `[ line_begin, line_end ]`
-   **/
-  this.map      = null;
+      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {
+        // 110xxxxx 10xxxxxx
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
 
-  /**
-   * Token#nesting -> Number
-   *
-   * Level change (number in {-1, 0, 1} set), where:
-   *
-   * -  `1` means the tag is opening
-   * -  `0` means the tag is self-closing
-   * - `-1` means the tag is closing
-   **/
-  this.nesting  = nesting;
+        if ((b2 & 0xC0) === 0x80) {
+          const chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);
 
-  /**
-   * Token#level -> Number
-   *
-   * nesting level, the same as `state.level`
-   **/
-  this.level    = 0;
+          if (chr < 0x80) {
+            result += '\ufffd\ufffd';
+          } else {
+            result += String.fromCharCode(chr);
+          }
 
-  /**
-   * Token#children -> Array
-   *
-   * An array of child nodes (inline and img tokens)
-   **/
-  this.children = null;
+          i += 3;
+          continue
+        }
+      }
 
-  /**
-   * Token#content -> String
-   *
-   * In a case of self-closing tag (code, html, fence, etc.),
-   * it has contents of this tag.
-   **/
-  this.content  = '';
+      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {
+        // 1110xxxx 10xxxxxx 10xxxxxx
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
+        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
 
-  /**
-   * Token#markup -> String
-   *
-   * '*' or '_' for emphasis, fence string for fence, etc.
-   **/
-  this.markup   = '';
+        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
+          const chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);
 
-  /**
-   * Token#info -> String
-   *
-   * Additional information:
-   *
-   * - Info string for "fence" tokens
-   * - The value "auto" for autolink "link_open" and "link_close" tokens
-   * - The string value of the item marker for ordered-list "list_item_open" tokens
-   **/
-  this.info     = '';
+          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {
+            result += '\ufffd\ufffd\ufffd';
+          } else {
+            result += String.fromCharCode(chr);
+          }
 
-  /**
-   * Token#meta -> Object
-   *
-   * A place for plugins to store an arbitrary data
-   **/
-  this.meta     = null;
+          i += 6;
+          continue
+        }
+      }
 
-  /**
-   * Token#block -> Boolean
-   *
-   * True for block-level tokens, false for inline tokens.
-   * Used in renderer to calculate line breaks
-   **/
-  this.block    = false;
+      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {
+        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
+        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
+        const b4 = parseInt(seq.slice(i + 10, i + 12), 16);
 
-  /**
-   * Token#hidden -> Boolean
-   *
-   * If it's true, ignore this element when rendering. Used for tight lists
-   * to hide paragraphs.
-   **/
-  this.hidden   = false;
-}
+        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {
+          let chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);
 
+          if (chr < 0x10000 || chr > 0x10FFFF) {
+            result += '\ufffd\ufffd\ufffd\ufffd';
+          } else {
+            chr -= 0x10000;
+            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));
+          }
 
-/**
- * Token.attrIndex(name) -> Number
- *
- * Search attribute index by name.
- **/
-Token.prototype.attrIndex = function attrIndex(name) {
-  var attrs, i, len;
+          i += 9;
+          continue
+        }
+      }
 
-  if (!this.attrs) { return -1; }
+      result += '\ufffd';
+    }
 
-  attrs = this.attrs;
+    return result
+  })
+}
 
-  for (i = 0, len = attrs.length; i < len; i++) {
-    if (attrs[i][0] === name) { return i; }
-  }
-  return -1;
-};
+decode.defaultChars = ';/?:@&=+$,#';
+decode.componentChars = '';
 
+const encodeCache = {};
 
-/**
- * Token.attrPush(attrData)
- *
- * Add `[ name, value ]` attribute to list. Init attrs if necessary
- **/
-Token.prototype.attrPush = function attrPush(attrData) {
-  if (this.attrs) {
-    this.attrs.push(attrData);
-  } else {
-    this.attrs = [ attrData ];
-  }
-};
+// Create a lookup array where anything but characters in `chars` string
+// and alphanumeric chars is percent-encoded.
+//
+function getEncodeCache (exclude) {
+  let cache = encodeCache[exclude];
+  if (cache) { return cache }
 
+  cache = encodeCache[exclude] = [];
 
-/**
- * Token.attrSet(name, value)
- *
- * Set `name` attribute to `value`. Override old value if exists.
- **/
-Token.prototype.attrSet = function attrSet(name, value) {
-  var idx = this.attrIndex(name),
-      attrData = [ name, value ];
+  for (let i = 0; i < 128; i++) {
+    const ch = String.fromCharCode(i);
 
-  if (idx < 0) {
-    this.attrPush(attrData);
-  } else {
-    this.attrs[idx] = attrData;
+    if (/^[0-9a-z]$/i.test(ch)) {
+      // always allow unencoded alphanumeric characters
+      cache.push(ch);
+    } else {
+      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));
+    }
   }
-};
 
-
-/**
- * Token.attrGet(name)
- *
- * Get the value of attribute `name`, or null if it does not exist.
- **/
-Token.prototype.attrGet = function attrGet(name) {
-  var idx = this.attrIndex(name), value = null;
-  if (idx >= 0) {
-    value = this.attrs[idx][1];
+  for (let i = 0; i < exclude.length; i++) {
+    cache[exclude.charCodeAt(i)] = exclude[i];
   }
-  return value;
-};
 
+  return cache
+}
 
-/**
- * Token.attrJoin(name, value)
- *
- * Join value to existing attribute via space. Or create new attribute if not
- * exists. Useful to operate with token classes.
- **/
-Token.prototype.attrJoin = function attrJoin(name, value) {
-  var idx = this.attrIndex(name);
+// Encode unsafe characters with percent-encoding, skipping already
+// encoded sequences.
+//
+//  - string       - string to encode
+//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
+//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
+//
+function encode (string, exclude, keepEscaped) {
+  if (typeof exclude !== 'string') {
+    // encode(string, keepEscaped)
+    keepEscaped = exclude;
+    exclude = encode.defaultChars;
+  }
 
-  if (idx < 0) {
-    this.attrPush([ name, value ]);
-  } else {
-    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;
+  if (typeof keepEscaped === 'undefined') {
+    keepEscaped = true;
   }
-};
 
+  const cache = getEncodeCache(exclude);
+  let result = '';
 
-module.exports = Token;
+  for (let i = 0, l = string.length; i < l; i++) {
+    const code = string.charCodeAt(i);
 
+    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {
+      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
+        result += string.slice(i, i + 3);
+        i += 2;
+        continue
+      }
+    }
 
-/***/ }),
+    if (code < 128) {
+      result += cache[code];
+      continue
+    }
 
-/***/ 3122:
-/***/ ((module) => {
+    if (code >= 0xD800 && code <= 0xDFFF) {
+      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
+        const nextCode = string.charCodeAt(i + 1);
+        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
+          result += encodeURIComponent(string[i] + string[i + 1]);
+          i++;
+          continue
+        }
+      }
+      result += '%EF%BF%BD';
+      continue
+    }
 
-"use strict";
+    result += encodeURIComponent(string[i]);
+  }
 
+  return result
+}
 
+encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
+encode.componentChars = "-_.!~*'()";
 
+function format (url) {
+  let result = '';
 
-/* eslint-disable no-bitwise */
+  result += url.protocol || '';
+  result += url.slashes ? '//' : '';
+  result += url.auth ? url.auth + '@' : '';
 
-var decodeCache = {};
+  if (url.hostname && url.hostname.indexOf(':') !== -1) {
+    // ipv6 address
+    result += '[' + url.hostname + ']';
+  } else {
+    result += url.hostname || '';
+  }
 
-function getDecodeCache(exclude) {
-  var i, ch, cache = decodeCache[exclude];
-  if (cache) { return cache; }
+  result += url.port ? ':' + url.port : '';
+  result += url.pathname || '';
+  result += url.search || '';
+  result += url.hash || '';
 
-  cache = decodeCache[exclude] = [];
+  return result
+}
 
-  for (i = 0; i < 128; i++) {
-    ch = String.fromCharCode(i);
-    cache.push(ch);
-  }
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-  for (i = 0; i < exclude.length; i++) {
-    ch = exclude.charCodeAt(i);
-    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);
-  }
+//
+// Changes from joyent/node:
+//
+// 1. No leading slash in paths,
+//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`
+//
+// 2. Backslashes are not replaced with slashes,
+//    so `http:\\example.org\` is treated like a relative path
+//
+// 3. Trailing colon is treated like a part of the path,
+//    i.e. in `http://example.org:foo` pathname is `:foo`
+//
+// 4. Nothing is URL-encoded in the resulting object,
+//    (in joyent/node some chars in auth and paths are encoded)
+//
+// 5. `url.parse()` does not have `parseQueryString` argument
+//
+// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
+//    which can be constructed using other parts of the url.
+//
 
-  return cache;
+function Url () {
+  this.protocol = null;
+  this.slashes = null;
+  this.auth = null;
+  this.port = null;
+  this.hostname = null;
+  this.hash = null;
+  this.search = null;
+  this.pathname = null;
 }
 
+// Reference: RFC 3986, RFC 1808, RFC 2396
 
-// Decode percent-encoded string.
-//
-function decode(string, exclude) {
-  var cache;
+// define these here so at least they only have to be
+// compiled once on the first module load.
+const protocolPattern = /^([a-z0-9.+-]+:)/i;
+const portPattern = /:[0-9]*$/;
+
+// Special case for a simple path URL
+/* eslint-disable-next-line no-useless-escape */
+const simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
+
+// RFC 2396: characters reserved for delimiting URLs.
+// We actually just auto-escape these.
+const delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'];
+
+// RFC 2396: characters not allowed for various reasons.
+const unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims);
+
+// Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+const autoEscape = ['\''].concat(unwise);
+// Characters that are never ever allowed in a hostname.
+// Note that any invalid chars are also handled, but these
+// are the ones that are *expected* to be seen, so we fast-path
+// them.
+const nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape);
+const hostEndingChars = ['/', '?', '#'];
+const hostnameMaxLen = 255;
+const hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
+const hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
+// protocols that can allow "unsafe" and "unwise" chars.
+// protocols that never have a hostname.
+const hostlessProtocol = {
+  javascript: true,
+  'javascript:': true
+};
+// protocols that always contain a // bit.
+const slashedProtocol = {
+  http: true,
+  https: true,
+  ftp: true,
+  gopher: true,
+  file: true,
+  'http:': true,
+  'https:': true,
+  'ftp:': true,
+  'gopher:': true,
+  'file:': true
+};
+
+function urlParse (url, slashesDenoteHost) {
+  if (url && url instanceof Url) return url
+
+  const u = new Url();
+  u.parse(url, slashesDenoteHost);
+  return u
+}
+
+Url.prototype.parse = function (url, slashesDenoteHost) {
+  let lowerProto, hec, slashes;
+  let rest = url;
+
+  // trim before proceeding.
+  // This is to support parse stuff like "  http://foo.com  \n"
+  rest = rest.trim();
+
+  if (!slashesDenoteHost && url.split('#').length === 1) {
+    // Try fast path regexp
+    const simplePath = simplePathPattern.exec(rest);
+    if (simplePath) {
+      this.pathname = simplePath[1];
+      if (simplePath[2]) {
+        this.search = simplePath[2];
+      }
+      return this
+    }
+  }
 
-  if (typeof exclude !== 'string') {
-    exclude = decode.defaultChars;
+  let proto = protocolPattern.exec(rest);
+  if (proto) {
+    proto = proto[0];
+    lowerProto = proto.toLowerCase();
+    this.protocol = proto;
+    rest = rest.substr(proto.length);
   }
 
-  cache = getDecodeCache(exclude);
+  // figure out if it's got a host
+  // user@server is *always* interpreted as a hostname, and url
+  // resolution will treat //foo/bar as host=foo,path=bar because that's
+  // how the browser resolves relative URLs.
+  /* eslint-disable-next-line no-useless-escape */
+  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+    slashes = rest.substr(0, 2) === '//';
+    if (slashes && !(proto && hostlessProtocol[proto])) {
+      rest = rest.substr(2);
+      this.slashes = true;
+    }
+  }
 
-  return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
-    var i, l, b1, b2, b3, b4, chr,
-        result = '';
+  if (!hostlessProtocol[proto] &&
+      (slashes || (proto && !slashedProtocol[proto]))) {
+    // there's a hostname.
+    // the first instance of /, ?, ;, or # ends the host.
+    //
+    // If there is an @ in the hostname, then non-host chars *are* allowed
+    // to the left of the last @ sign, unless some host-ending character
+    // comes *before* the @-sign.
+    // URLs are obnoxious.
+    //
+    // ex:
+    // http://a@b@c/ => user:a@b host:c
+    // http://a@b?@c => user:a host:c path:/?@c
 
-    for (i = 0, l = seq.length; i < l; i += 3) {
-      b1 = parseInt(seq.slice(i + 1, i + 3), 16);
+    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+    // Review our test case against browsers more comprehensively.
 
-      if (b1 < 0x80) {
-        result += cache[b1];
-        continue;
+    // find the first instance of any hostEndingChars
+    let hostEnd = -1;
+    for (let i = 0; i < hostEndingChars.length; i++) {
+      hec = rest.indexOf(hostEndingChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
+        hostEnd = hec;
       }
+    }
 
-      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {
-        // 110xxxxx 10xxxxxx
-        b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-
-        if ((b2 & 0xC0) === 0x80) {
-          chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);
+    // at this point, either we have an explicit point where the
+    // auth portion cannot go past, or the last @ char is the decider.
+    let auth, atSign;
+    if (hostEnd === -1) {
+      // atSign can be anywhere.
+      atSign = rest.lastIndexOf('@');
+    } else {
+      // atSign must be in auth portion.
+      // http://a@b/c@d => host:b auth:a path:/c@d
+      atSign = rest.lastIndexOf('@', hostEnd);
+    }
 
-          if (chr < 0x80) {
-            result += '\ufffd\ufffd';
-          } else {
-            result += String.fromCharCode(chr);
-          }
+    // Now we have a portion which is definitely the auth.
+    // Pull that off.
+    if (atSign !== -1) {
+      auth = rest.slice(0, atSign);
+      rest = rest.slice(atSign + 1);
+      this.auth = auth;
+    }
 
-          i += 3;
-          continue;
-        }
+    // the host is the remaining to the left of the first non-host char
+    hostEnd = -1;
+    for (let i = 0; i < nonHostChars.length; i++) {
+      hec = rest.indexOf(nonHostChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
+        hostEnd = hec;
       }
+    }
+    // if we still have not hit it, then the entire thing is a host.
+    if (hostEnd === -1) {
+      hostEnd = rest.length;
+    }
 
-      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {
-        // 1110xxxx 10xxxxxx 10xxxxxx
-        b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-        b3 = parseInt(seq.slice(i + 7, i + 9), 16);
-
-        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
-          chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);
-
-          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {
-            result += '\ufffd\ufffd\ufffd';
-          } else {
-            result += String.fromCharCode(chr);
-          }
+    if (rest[hostEnd - 1] === ':') { hostEnd--; }
+    const host = rest.slice(0, hostEnd);
+    rest = rest.slice(hostEnd);
 
-          i += 6;
-          continue;
-        }
-      }
+    // pull out port.
+    this.parseHost(host);
 
-      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {
-        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx
-        b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-        b3 = parseInt(seq.slice(i + 7, i + 9), 16);
-        b4 = parseInt(seq.slice(i + 10, i + 12), 16);
+    // we've indicated that there is a hostname,
+    // so even if it's empty, it has to be present.
+    this.hostname = this.hostname || '';
 
-        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {
-          chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);
+    // if hostname begins with [ and ends with ]
+    // assume that it's an IPv6 address.
+    const ipv6Hostname = this.hostname[0] === '[' &&
+        this.hostname[this.hostname.length - 1] === ']';
 
-          if (chr < 0x10000 || chr > 0x10FFFF) {
-            result += '\ufffd\ufffd\ufffd\ufffd';
-          } else {
-            chr -= 0x10000;
-            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));
+    // validate a little.
+    if (!ipv6Hostname) {
+      const hostparts = this.hostname.split(/\./);
+      for (let i = 0, l = hostparts.length; i < l; i++) {
+        const part = hostparts[i];
+        if (!part) { continue }
+        if (!part.match(hostnamePartPattern)) {
+          let newpart = '';
+          for (let j = 0, k = part.length; j < k; j++) {
+            if (part.charCodeAt(j) > 127) {
+              // we replace non-ASCII char with a temporary placeholder
+              // we need this to make sure size of hostname is not
+              // broken by replacing non-ASCII by nothing
+              newpart += 'x';
+            } else {
+              newpart += part[j];
+            }
+          }
+          // we test again with ASCII char only
+          if (!newpart.match(hostnamePartPattern)) {
+            const validParts = hostparts.slice(0, i);
+            const notHost = hostparts.slice(i + 1);
+            const bit = part.match(hostnamePartStart);
+            if (bit) {
+              validParts.push(bit[1]);
+              notHost.unshift(bit[2]);
+            }
+            if (notHost.length) {
+              rest = notHost.join('.') + rest;
+            }
+            this.hostname = validParts.join('.');
+            break
           }
-
-          i += 9;
-          continue;
         }
       }
+    }
 
-      result += '\ufffd';
+    if (this.hostname.length > hostnameMaxLen) {
+      this.hostname = '';
     }
 
-    return result;
-  });
-}
+    // strip [ and ] from the hostname
+    // the host field still retains them, though
+    if (ipv6Hostname) {
+      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+    }
+  }
 
+  // chop off from the tail first.
+  const hash = rest.indexOf('#');
+  if (hash !== -1) {
+    // got a fragment string.
+    this.hash = rest.substr(hash);
+    rest = rest.slice(0, hash);
+  }
+  const qm = rest.indexOf('?');
+  if (qm !== -1) {
+    this.search = rest.substr(qm);
+    rest = rest.slice(0, qm);
+  }
+  if (rest) { this.pathname = rest; }
+  if (slashedProtocol[lowerProto] &&
+      this.hostname && !this.pathname) {
+    this.pathname = '';
+  }
 
-decode.defaultChars   = ';/?:@&=+$,#';
-decode.componentChars = '';
+  return this
+};
 
+Url.prototype.parseHost = function (host) {
+  let port = portPattern.exec(host);
+  if (port) {
+    port = port[0];
+    if (port !== ':') {
+      this.port = port.substr(1);
+    }
+    host = host.substr(0, host.length - port.length);
+  }
+  if (host) { this.hostname = host; }
+};
 
-module.exports = decode;
+exports.decode = decode;
+exports.encode = encode;
+exports.format = format;
+exports.parse = urlParse;
 
 
 /***/ }),
 
-/***/ 729:
-/***/ ((module) => {
-
-"use strict";
-
-
-
-
-var encodeCache = {};
+/***/ 6878:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aggregator_exports = {};
+__export(aggregator_exports, {
+  Aggregator: () => Aggregator
+});
+module.exports = __toCommonJS(aggregator_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+class Aggregator {
+  #pipeline;
+  #options;
+  constructor(pipeline, options) {
+    this.#pipeline = pipeline;
+    this.#options = (0, import_core.initOptions)(options);
+  }
+  /**
+   * Returns an {@link Iterator} for lazy evaluation of the pipeline.
+   *
+   * @param {*} collection An array or iterator object
+   * @returns {Iterator} an iterator object
+   */
+  stream(collection, options) {
+    let iterator = (0, import_lazy.Lazy)(collection);
+    const opts = options ?? this.#options;
+    const mode = opts.processingMode;
+    if (mode == import_core.ProcessingMode.CLONE_ALL || mode == import_core.ProcessingMode.CLONE_INPUT) {
+      iterator.map(import_util.cloneDeep);
+    }
+    const stages = new Array();
+    if (!(0, import_util.isEmpty)(this.#pipeline)) {
+      for (const operator of this.#pipeline) {
+        const operatorKeys = Object.keys(operator);
+        const opName = operatorKeys[0];
+        const call = (0, import_core.getOperator)("pipeline", opName, opts);
+        (0, import_util.assert)(
+          operatorKeys.length === 1 && !!call,
+          `invalid pipeline operator ${opName}`
+        );
+        stages.push(opName);
+        iterator = call(iterator, operator[opName], opts);
+      }
+    }
+    if (mode == import_core.ProcessingMode.CLONE_OUTPUT || mode == import_core.ProcessingMode.CLONE_ALL && !!(0, import_util.intersection)([["$group", "$unwind"], stages]).length) {
+      iterator.map(import_util.cloneDeep);
+    }
+    return iterator;
+  }
+  /**
+   * Return the results of the aggregation as an array.
+   *
+   * @param collection
+   */
+  run(collection, options) {
+    return this.stream(collection, options).value();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-// Create a lookup array where anything but characters in `chars` string
-// and alphanumeric chars is percent-encoded.
-//
-function getEncodeCache(exclude) {
-  var i, ch, cache = encodeCache[exclude];
-  if (cache) { return cache; }
 
-  cache = encodeCache[exclude] = [];
+/***/ }),
 
-  for (i = 0; i < 128; i++) {
-    ch = String.fromCharCode(i);
+/***/ 2760:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-    if (/^[0-9a-z]$/i.test(ch)) {
-      // always allow unencoded alphanumeric characters
-      cache.push(ch);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  ComputeOptions: () => ComputeOptions,
+  Context: () => Context,
+  OperatorType: () => OperatorType,
+  ProcessingMode: () => ProcessingMode,
+  computeValue: () => computeValue,
+  getOperator: () => getOperator,
+  initOptions: () => initOptions,
+  redact: () => redact,
+  useOperators: () => useOperators
+});
+module.exports = __toCommonJS(core_exports);
+var import_util = __webpack_require__(7839);
+var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
+  ProcessingMode2["CLONE_ALL"] = "CLONE_ALL";
+  ProcessingMode2["CLONE_INPUT"] = "CLONE_INPUT";
+  ProcessingMode2["CLONE_OUTPUT"] = "CLONE_OUTPUT";
+  ProcessingMode2["CLONE_OFF"] = "CLONE_OFF";
+  return ProcessingMode2;
+})(ProcessingMode || {});
+class ComputeOptions {
+  #options;
+  /** Reference to the root object when processing subgraphs of the object. */
+  #root;
+  #local;
+  constructor(options, root, local) {
+    this.#options = options;
+    this.update(root, local);
+  }
+  /**
+   * Initialize new ComputeOptions.
+   *
+   * @param options
+   * @param root
+   * @param local
+   * @returns {ComputeOptions}
+   */
+  static init(options, root, local) {
+    return options instanceof ComputeOptions ? new ComputeOptions(options.#options, options.root ?? root, {
+      ...options.#local,
+      ...local,
+      // retain existing variables
+      variables: Object.assign(
+        {},
+        options.#local?.variables,
+        local?.variables
+      )
+    }) : new ComputeOptions(options, root, local);
+  }
+  /**
+   * Updates the internal state.
+   *
+   * @param root The new root context for this object.
+   * @param local The new local state to merge into current if it exists.
+   * @returns
+   */
+  update(root, local) {
+    this.#root = root;
+    const variables = Object.assign(
+      {},
+      this.#local?.variables,
+      local?.variables
+    );
+    if (Object.keys(variables).length) {
+      this.#local = { ...local, variables };
     } else {
-      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));
+      this.#local = local ?? {};
+    }
+    return this;
+  }
+  getOptions() {
+    return Object.freeze({
+      ...this.#options,
+      context: Context.from(this.#options.context)
+    });
+  }
+  get root() {
+    return this.#root;
+  }
+  get local() {
+    return this.#local;
+  }
+  get idKey() {
+    return this.#options.idKey;
+  }
+  get collation() {
+    return this.#options?.collation;
+  }
+  get processingMode() {
+    return this.#options?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+  }
+  get useStrictMode() {
+    return this.#options?.useStrictMode;
+  }
+  get scriptEnabled() {
+    return this.#options?.scriptEnabled;
+  }
+  get useGlobalContext() {
+    return this.#options?.useGlobalContext;
+  }
+  get hashFunction() {
+    return this.#options?.hashFunction;
+  }
+  get collectionResolver() {
+    return this.#options?.collectionResolver;
+  }
+  get jsonSchemaValidator() {
+    return this.#options?.jsonSchemaValidator;
+  }
+  get variables() {
+    return this.#options?.variables;
+  }
+  get context() {
+    return this.#options?.context;
+  }
+}
+function initOptions(options) {
+  return options instanceof ComputeOptions ? options.getOptions() : Object.freeze({
+    idKey: "_id",
+    scriptEnabled: true,
+    useStrictMode: true,
+    useGlobalContext: true,
+    processingMode: "CLONE_OFF" /* CLONE_OFF */,
+    ...options,
+    context: options?.context ? Context.from(options?.context) : Context.init()
+  });
+}
+var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+  OperatorType2["ACCUMULATOR"] = "accumulator";
+  OperatorType2["EXPRESSION"] = "expression";
+  OperatorType2["PIPELINE"] = "pipeline";
+  OperatorType2["PROJECTION"] = "projection";
+  OperatorType2["QUERY"] = "query";
+  OperatorType2["WINDOW"] = "window";
+  return OperatorType2;
+})(OperatorType || {});
+class Context {
+  #operators = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static init() {
+    return new Context();
+  }
+  static from(ctx) {
+    const instance = Context.init();
+    if ((0, import_util.isNil)(ctx)) return instance;
+    ctx.#operators.forEach((v, k) => instance.addOperators(k, v));
+    return instance;
+  }
+  addOperators(type, operators) {
+    if (!this.#operators.has(type)) this.#operators.set(type, {});
+    for (const [name, fn] of Object.entries(operators)) {
+      if (!this.getOperator(type, name)) {
+        this.#operators.get(type)[name] = fn;
+      }
     }
+    return this;
   }
-
-  for (i = 0; i < exclude.length; i++) {
-    cache[exclude.charCodeAt(i)] = exclude[i];
+  getOperator(type, name) {
+    const ops = this.#operators.get(type) ?? {};
+    return ops[name] ?? null;
+  }
+  addAccumulatorOps(ops) {
+    return this.addOperators("accumulator", ops);
+  }
+  addExpressionOps(ops) {
+    return this.addOperators("expression", ops);
+  }
+  addQueryOps(ops) {
+    return this.addOperators("query", ops);
+  }
+  addPipelineOps(ops) {
+    return this.addOperators("pipeline", ops);
+  }
+  addProjectionOps(ops) {
+    return this.addOperators("projection", ops);
+  }
+  addWindowOps(ops) {
+    return this.addOperators("window", ops);
   }
-
-  return cache;
 }
-
-
-// Encode unsafe characters with percent-encoding, skipping already
-// encoded sequences.
-//
-//  - string       - string to encode
-//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
-//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
-//
-function encode(string, exclude, keepEscaped) {
-  var i, l, code, nextCode, cache,
-      result = '';
-
-  if (typeof exclude !== 'string') {
-    // encode(string, keepEscaped)
-    keepEscaped  = exclude;
-    exclude = encode.defaultChars;
+const GLOBAL_CONTEXT = Context.init();
+function useOperators(type, operators) {
+  for (const [name, fn] of Object.entries(operators)) {
+    (0, import_util.assert)(
+      (0, import_util.isFunction)(fn) && (0, import_util.isOperator)(name),
+      `'${name}' is not a valid operator`
+    );
+    const currentFn = getOperator(type, name, null);
+    (0, import_util.assert)(
+      !currentFn || fn === currentFn,
+      `${name} already exists for '${type}' operators. Cannot change operator function once registered.`
+    );
   }
-
-  if (typeof keepEscaped === 'undefined') {
-    keepEscaped = true;
+  switch (type) {
+    case "accumulator":
+      GLOBAL_CONTEXT.addAccumulatorOps(operators);
+      break;
+    case "expression":
+      GLOBAL_CONTEXT.addExpressionOps(operators);
+      break;
+    case "pipeline":
+      GLOBAL_CONTEXT.addPipelineOps(operators);
+      break;
+    case "projection":
+      GLOBAL_CONTEXT.addProjectionOps(operators);
+      break;
+    case "query":
+      GLOBAL_CONTEXT.addQueryOps(operators);
+      break;
+    case "window":
+      GLOBAL_CONTEXT.addWindowOps(operators);
+      break;
   }
-
-  cache = getEncodeCache(exclude);
-
-  for (i = 0, l = string.length; i < l; i++) {
-    code = string.charCodeAt(i);
-
-    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {
-      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
-        result += string.slice(i, i + 3);
-        i += 2;
-        continue;
+}
+function getOperator(type, name, options) {
+  const { context: ctx, useGlobalContext: fallback } = options || {};
+  const fn = ctx ? ctx.getOperator(type, name) : null;
+  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, name) : fn;
+}
+function computeValue(obj, expr, operator, options) {
+  const copts = ComputeOptions.init(options, obj);
+  return !!operator && (0, import_util.isOperator)(operator) ? computeOperator(obj, expr, operator, copts) : computeExpression(obj, expr, copts);
+}
+const SYSTEM_VARS = ["$$ROOT", "$$CURRENT", "$$REMOVE", "$$NOW"];
+function computeExpression(obj, expr, options) {
+  if ((0, import_util.isString)(expr) && expr.length > 0 && expr[0] === "$") {
+    if (REDACT_ACTIONS.includes(expr)) return expr;
+    let ctx = options.root;
+    const arr = expr.split(".");
+    if (SYSTEM_VARS.includes(arr[0])) {
+      switch (arr[0]) {
+        case "$$ROOT":
+          break;
+        case "$$CURRENT":
+          ctx = obj;
+          break;
+        case "$$REMOVE":
+          ctx = void 0;
+          break;
+        case "$$NOW":
+          ctx = /* @__PURE__ */ new Date();
+          break;
       }
+      expr = expr.slice(arr[0].length + 1);
+    } else if (arr[0].slice(0, 2) === "$$") {
+      ctx = Object.assign(
+        {},
+        // global vars
+        options.variables,
+        // current item is added before local variables because the binding may be changed.
+        { this: obj },
+        // local vars
+        options?.local?.variables
+      );
+      const name = arr[0].slice(2);
+      (0, import_util.assert)((0, import_util.has)(ctx, name), `Use of undefined variable: ${name}`);
+      expr = expr.slice(2);
+    } else {
+      expr = expr.slice(1);
     }
-
-    if (code < 128) {
-      result += cache[code];
-      continue;
+    return expr === "" ? ctx : (0, import_util.resolve)(ctx, expr);
+  }
+  if ((0, import_util.isArray)(expr)) {
+    return expr.map((item) => computeExpression(obj, item, options));
+  }
+  if ((0, import_util.isObject)(expr)) {
+    const result = {};
+    const elems = Object.entries(expr);
+    for (const [key, val] of elems) {
+      if ((0, import_util.isOperator)(key)) {
+        (0, import_util.assert)(elems.length == 1, "expression must have single operator.");
+        return computeOperator(obj, val, key, options);
+      }
+      result[key] = computeExpression(obj, val, options);
     }
-
-    if (code >= 0xD800 && code <= 0xDFFF) {
-      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
-        nextCode = string.charCodeAt(i + 1);
-        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
-          result += encodeURIComponent(string[i] + string[i + 1]);
-          i++;
-          continue;
+    return result;
+  }
+  return expr;
+}
+function computeOperator(obj, expr, operator, options) {
+  const callExpression = getOperator(
+    "expression",
+    operator,
+    options
+  );
+  if (callExpression) return callExpression(obj, expr, options);
+  const callAccumulator = getOperator(
+    "accumulator",
+    operator,
+    options
+  );
+  (0, import_util.assert)(!!callAccumulator, `accumulator '${operator}' is not registered.`);
+  if (!(0, import_util.isArray)(obj)) {
+    obj = computeExpression(obj, expr, options);
+    expr = null;
+  }
+  (0, import_util.assert)((0, import_util.isArray)(obj), `arguments must resolve to array for ${operator}.`);
+  return callAccumulator(
+    obj,
+    expr,
+    options.update(null, options.local)
+    // reset the root object.
+  );
+}
+const REDACT_ACTIONS = ["$$KEEP", "$$PRUNE", "$$DESCEND"];
+function redact(obj, expr, options) {
+  const action = computeValue(obj, expr, null, options);
+  switch (action) {
+    case "$$KEEP":
+      return obj;
+    case "$$PRUNE":
+      return void 0;
+    case "$$DESCEND": {
+      if (!(0, import_util.has)(expr, "$cond")) return obj;
+      const output = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if ((0, import_util.isArray)(value)) {
+          const res = new Array();
+          for (let elem of value) {
+            if ((0, import_util.isObject)(elem)) {
+              elem = redact(elem, expr, options.update(elem));
+            }
+            if (!(0, import_util.isNil)(elem)) res.push(elem);
+          }
+          output[key] = res;
+        } else if ((0, import_util.isObject)(value)) {
+          const res = redact(
+            value,
+            expr,
+            options.update(value)
+          );
+          if (!(0, import_util.isNil)(res)) output[key] = res;
+        } else {
+          output[key] = value;
         }
       }
-      result += '%EF%BF%BD';
-      continue;
+      return output;
     }
-
-    result += encodeURIComponent(string[i]);
+    default:
+      return action;
   }
-
-  return result;
 }
-
-encode.defaultChars   = ";/?:@&=+$,-_.!~*'()#";
-encode.componentChars = "-_.!~*'()";
-
-
-module.exports = encode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2201:
-/***/ ((module) => {
-
-"use strict";
-
-
-
-
-module.exports = function format(url) {
-  var result = '';
-
-  result += url.protocol || '';
-  result += url.slashes ? '//' : '';
-  result += url.auth ? url.auth + '@' : '';
+/***/ 4529:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-  if (url.hostname && url.hostname.indexOf(':') !== -1) {
-    // ipv6 address
-    result += '[' + url.hostname + ']';
-  } else {
-    result += url.hostname || '';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-
-  result += url.port ? ':' + url.port : '';
-  result += url.pathname || '';
-  result += url.search || '';
-  result += url.hash || '';
-
-  return result;
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cursor_exports = {};
+__export(cursor_exports, {
+  Cursor: () => Cursor
+});
+module.exports = __toCommonJS(cursor_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+class Cursor {
+  #source;
+  #predicate;
+  #projection;
+  #options;
+  #operators = [];
+  #result = null;
+  #buffer = [];
+  constructor(source, predicate, projection, options) {
+    this.#source = source;
+    this.#predicate = predicate;
+    this.#projection = projection;
+    this.#options = options;
+  }
+  /** Returns the iterator from running the query */
+  fetch() {
+    if (this.#result) return this.#result;
+    if ((0, import_util.isObject)(this.#projection)) {
+      this.#operators.push({ $project: this.#projection });
+    }
+    this.#result = (0, import_lazy.Lazy)(this.#source).filter(this.#predicate);
+    if (this.#operators.length > 0) {
+      this.#result = new import_aggregator.Aggregator(this.#operators, this.#options).stream(
+        this.#result
+      );
+    }
+    return this.#result;
+  }
+  /** Returns an iterator with the buffered data included */
+  fetchAll() {
+    const buffered = (0, import_lazy.Lazy)([...this.#buffer]);
+    this.#buffer = [];
+    return (0, import_lazy.concat)(buffered, this.fetch());
+  }
+  /**
+   * Return remaining objects in the cursor as an array. This method exhausts the cursor
+   * @returns {Array}
+   */
+  all() {
+    return this.fetchAll().value();
+  }
+  /**
+   * Returns the number of objects return in the cursor. This method exhausts the cursor
+   * @returns {Number}
+   */
+  count() {
+    return this.all().length;
+  }
+  /**
+   * Returns a cursor that begins returning results only after passing or skipping a number of documents.
+   * @param {Number} n the number of results to skip.
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  skip(n) {
+    this.#operators.push({ $skip: n });
+    return this;
+  }
+  /**
+   * Constrains the size of a cursor's result set.
+   * @param {Number} n the number of results to limit to.
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  limit(n) {
+    this.#operators.push({ $limit: n });
+    return this;
+  }
+  /**
+   * Returns results ordered according to a sort specification.
+   * @param {AnyObject} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  sort(modifier) {
+    this.#operators.push({ $sort: modifier });
+    return this;
+  }
+  /**
+   * Specifies the collation for the cursor returned by the `mingo.Query.find`
+   * @param {*} spec
+   */
+  collation(spec) {
+    this.#options = { ...this.#options, collation: spec };
+    return this;
+  }
+  /**
+   * Returns the next document in a cursor.
+   * @returns {AnyObject | Boolean}
+   */
+  next() {
+    if (this.#buffer.length > 0) {
+      return this.#buffer.pop();
+    }
+    const o = this.fetch().next();
+    if (o.done) return;
+    return o.value;
+  }
+  /**
+   * Returns true if the cursor has documents and can be iterated.
+   * @returns {boolean}
+   */
+  hasNext() {
+    if (this.#buffer.length > 0) return true;
+    const o = this.fetch().next();
+    if (o.done) return false;
+    this.#buffer.push(o.value);
+    return true;
+  }
+  /**
+   * Applies a function to each document in a cursor and collects the return values in an array.
+   * @param fn
+   * @returns {Array}
+   */
+  map(fn) {
+    return this.all().map(fn);
+  }
+  /**
+   * Applies a JavaScript function for every document in a cursor.
+   * @param fn
+   */
+  forEach(fn) {
+    this.all().forEach(fn);
+  }
+  [Symbol.iterator]() {
+    return this.fetchAll();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8765:
+/***/ 8543:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
-
-
-
-module.exports.encode = __webpack_require__(729);
-module.exports.decode = __webpack_require__(3122);
-module.exports.format = __webpack_require__(2201);
-module.exports.parse = __webpack_require__(9553);
-
-
-/***/ }),
-
-/***/ 9553:
-/***/ ((module) => {
-
-"use strict";
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-
-//
-// Changes from joyent/node:
-//
-// 1. No leading slash in paths,
-//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`
-//
-// 2. Backslashes are not replaced with slashes,
-//    so `http:\\example.org\` is treated like a relative path
-//
-// 3. Trailing colon is treated like a part of the path,
-//    i.e. in `http://example.org:foo` pathname is `:foo`
-//
-// 4. Nothing is URL-encoded in the resulting object,
-//    (in joyent/node some chars in auth and paths are encoded)
-//
-// 5. `url.parse()` does not have `parseQueryString` argument
-//
-// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
-//    which can be constructed using other parts of the url.
-//
-
-
-function Url() {
-  this.protocol = null;
-  this.slashes = null;
-  this.auth = null;
-  this.port = null;
-  this.hostname = null;
-  this.hash = null;
-  this.search = null;
-  this.pathname = null;
-}
-
-// Reference: RFC 3986, RFC 1808, RFC 2396
-
-// define these here so at least they only have to be
-// compiled once on the first module load.
-var protocolPattern = /^([a-z0-9.+-]+:)/i,
-    portPattern = /:[0-9]*$/,
-
-    // Special case for a simple path URL
-    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
-
-    // RFC 2396: characters reserved for delimiting URLs.
-    // We actually just auto-escape these.
-    delims = [ '<', '>', '"', '`', ' ', '\r', '\n', '\t' ],
-
-    // RFC 2396: characters not allowed for various reasons.
-    unwise = [ '{', '}', '|', '\\', '^', '`' ].concat(delims),
-
-    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
-    autoEscape = [ '\'' ].concat(unwise),
-    // Characters that are never ever allowed in a hostname.
-    // Note that any invalid chars are also handled, but these
-    // are the ones that are *expected* to be seen, so we fast-path
-    // them.
-    nonHostChars = [ '%', '/', '?', ';', '#' ].concat(autoEscape),
-    hostEndingChars = [ '/', '?', '#' ],
-    hostnameMaxLen = 255,
-    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
-    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
-    // protocols that can allow "unsafe" and "unwise" chars.
-    /* eslint-disable no-script-url */
-    // protocols that never have a hostname.
-    hostlessProtocol = {
-      'javascript': true,
-      'javascript:': true
-    },
-    // protocols that always contain a // bit.
-    slashedProtocol = {
-      'http': true,
-      'https': true,
-      'ftp': true,
-      'gopher': true,
-      'file': true,
-      'http:': true,
-      'https:': true,
-      'ftp:': true,
-      'gopher:': true,
-      'file:': true
-    };
-    /* eslint-enable no-script-url */
-
-function urlParse(url, slashesDenoteHost) {
-  if (url && url instanceof Url) { return url; }
-
-  var u = new Url();
-  u.parse(url, slashesDenoteHost);
-  return u;
-}
-
-Url.prototype.parse = function(url, slashesDenoteHost) {
-  var i, l, lowerProto, hec, slashes,
-      rest = url;
-
-  // trim before proceeding.
-  // This is to support parse stuff like "  http://foo.com  \n"
-  rest = rest.trim();
-
-  if (!slashesDenoteHost && url.split('#').length === 1) {
-    // Try fast path regexp
-    var simplePath = simplePathPattern.exec(rest);
-    if (simplePath) {
-      this.pathname = simplePath[1];
-      if (simplePath[2]) {
-        this.search = simplePath[2];
-      }
-      return this;
-    }
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Aggregator: () => import_aggregator2.Aggregator,
+  Query: () => import_query2.Query,
+  aggregate: () => aggregate,
+  createUpdater: () => import_updater2.createUpdater,
+  default: () => src_default,
+  find: () => find,
+  remove: () => remove,
+  update: () => import_updater2.update
+});
+module.exports = __toCommonJS(src_exports);
+var import_basic = __webpack_require__(5864);
+var import_aggregator = __webpack_require__(6878);
+var import_query = __webpack_require__(6535);
+var import_updater = __webpack_require__(3550);
+var import_aggregator2 = __webpack_require__(6878);
+var import_query2 = __webpack_require__(6535);
+var import_updater2 = __webpack_require__(3550);
+function find(collection, criteria, projection, options) {
+  return new import_query.Query(criteria, options).find(collection, projection);
+}
+function remove(collection, criteria, options) {
+  return new import_query.Query(criteria, options).remove(collection);
+}
+function aggregate(collection, pipeline, options) {
+  return new import_aggregator.Aggregator(pipeline, options).run(collection);
+}
+var src_default = {
+  Aggregator: import_aggregator.Aggregator,
+  Query: import_query.Query,
+  aggregate,
+  createUpdater: import_updater.createUpdater,
+  find,
+  remove,
+  update: import_updater.update
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-  var proto = protocolPattern.exec(rest);
-  if (proto) {
-    proto = proto[0];
-    lowerProto = proto.toLowerCase();
-    this.protocol = proto;
-    rest = rest.substr(proto.length);
-  }
 
-  // figure out if it's got a host
-  // user@server is *always* interpreted as a hostname, and url
-  // resolution will treat //foo/bar as host=foo,path=bar because that's
-  // how the browser resolves relative URLs.
-  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
-    slashes = rest.substr(0, 2) === '//';
-    if (slashes && !(proto && hostlessProtocol[proto])) {
-      rest = rest.substr(2);
-      this.slashes = true;
-    }
+/***/ }),
+
+/***/ 5864:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_core = __webpack_require__(2760);
+var booleanOperators = __toESM(__webpack_require__(1703));
+var comparisonOperators = __toESM(__webpack_require__(3336));
+var import_pipeline = __webpack_require__(6936);
+var projectionOperators = __toESM(__webpack_require__(4487));
+var queryOperators = __toESM(__webpack_require__(8510));
+(0, import_core.useOperators)("expression", {
+  ...booleanOperators,
+  ...comparisonOperators
+});
+(0, import_core.useOperators)("pipeline", {
+  $project: import_pipeline.$project,
+  $skip: import_pipeline.$skip,
+  $limit: import_pipeline.$limit,
+  $sort: import_pipeline.$sort
+});
+(0, import_core.useOperators)("projection", projectionOperators);
+(0, import_core.useOperators)("query", queryOperators);
 
-  if (!hostlessProtocol[proto] &&
-      (slashes || (proto && !slashedProtocol[proto]))) {
 
-    // there's a hostname.
-    // the first instance of /, ?, ;, or # ends the host.
-    //
-    // If there is an @ in the hostname, then non-host chars *are* allowed
-    // to the left of the last @ sign, unless some host-ending character
-    // comes *before* the @-sign.
-    // URLs are obnoxious.
-    //
-    // ex:
-    // http://a@b@c/ => user:a@b host:c
-    // http://a@b?@c => user:a host:c path:/?@c
+/***/ }),
 
-    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
-    // Review our test case against browsers more comprehensively.
+/***/ 8625:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-    // find the first instance of any hostEndingChars
-    var hostEnd = -1;
-    for (i = 0; i < hostEndingChars.length; i++) {
-      hec = rest.indexOf(hostEndingChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazy_exports = {};
+__export(lazy_exports, {
+  Iterator: () => Iterator,
+  Lazy: () => Lazy,
+  concat: () => concat
+});
+module.exports = __toCommonJS(lazy_exports);
+var import_util = __webpack_require__(7839);
+function Lazy(source) {
+  return source instanceof Iterator ? source : new Iterator(source);
+}
+function concat(...iterators) {
+  let index = 0;
+  return Lazy(() => {
+    while (index < iterators.length) {
+      const o = iterators[index].next();
+      if (!o.done) return o;
+      index++;
+    }
+    return { done: true };
+  });
+}
+function isGenerator(o) {
+  return !!o && typeof o === "object" && o?.next instanceof Function;
+}
+function dropItem(array, i) {
+  const rest = array.slice(i + 1);
+  array.splice(i);
+  Array.prototype.push.apply(array, rest);
+}
+const DONE = new Error();
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2[Action2["MAP"] = 0] = "MAP";
+  Action2[Action2["FILTER"] = 1] = "FILTER";
+  Action2[Action2["TAKE"] = 2] = "TAKE";
+  Action2[Action2["DROP"] = 3] = "DROP";
+  return Action2;
+})(Action || {});
+function createCallback(nextFn, iteratees, buffer) {
+  let done = false;
+  let index = -1;
+  let bufferIndex = 0;
+  return function(storeResult) {
+    try {
+      outer: while (!done) {
+        let o = nextFn();
+        index++;
+        let i = -1;
+        const size = iteratees.length;
+        let innerDone = false;
+        while (++i < size) {
+          const r = iteratees[i];
+          switch (r.action) {
+            case 0 /* MAP */:
+              o = r.func(o, index);
+              break;
+            case 1 /* FILTER */:
+              if (!r.func(o, index)) continue outer;
+              break;
+            case 2 /* TAKE */:
+              --r.count;
+              if (!r.count) innerDone = true;
+              break;
+            case 3 /* DROP */:
+              --r.count;
+              if (!r.count) dropItem(iteratees, i);
+              continue outer;
+            default:
+              break outer;
+          }
+        }
+        done = innerDone;
+        if (storeResult) {
+          buffer[bufferIndex++] = o;
+        } else {
+          return { value: o, done: false };
+        }
       }
+    } catch (e) {
+      if (e !== DONE) throw e;
     }
-
-    // at this point, either we have an explicit point where the
-    // auth portion cannot go past, or the last @ char is the decider.
-    var auth, atSign;
-    if (hostEnd === -1) {
-      // atSign can be anywhere.
-      atSign = rest.lastIndexOf('@');
-    } else {
-      // atSign must be in auth portion.
-      // http://a@b/c@d => host:b auth:a path:/c@d
-      atSign = rest.lastIndexOf('@', hostEnd);
+    done = true;
+    return { done };
+  };
+}
+class Iterator {
+  /**
+   * @param {*} source An iterable object or function.
+   *    Array - return one element per cycle
+   *    Object{next:Function} - call next() for the next value (this also handles generator functions)
+   *    Function - call to return the next value
+   * @param {Function} fn An optional transformation function
+   */
+  constructor(source) {
+    this.#iteratees = [];
+    this.#yieldedValues = [];
+    this.isDone = false;
+    let nextVal;
+    if (source instanceof Function) {
+      source = { next: source };
+    }
+    if (isGenerator(source)) {
+      const src = source;
+      nextVal = () => {
+        const o = src.next();
+        if (o.done) throw DONE;
+        return o.value;
+      };
+    } else if ((0, import_util.isArray)(source)) {
+      const data = source;
+      const size = data.length;
+      let index = 0;
+      nextVal = () => {
+        if (index < size) return data[index++];
+        throw DONE;
+      };
+    } else if (!(source instanceof Function)) {
+      throw new import_util.MingoError(
+        `Lazy must be initialized with an array, generator, or function.`
+      );
     }
-
-    // Now we have a portion which is definitely the auth.
-    // Pull that off.
-    if (atSign !== -1) {
-      auth = rest.slice(0, atSign);
-      rest = rest.slice(atSign + 1);
-      this.auth = auth;
+    this.#getNext = createCallback(
+      nextVal,
+      this.#iteratees,
+      this.#yieldedValues
+    );
+  }
+  #iteratees;
+  #yieldedValues;
+  #getNext;
+  /**
+   * Add an iteratee to this lazy sequence
+   */
+  push(action, value) {
+    if (typeof value === "function") {
+      this.#iteratees.push({ action, func: value });
+    } else if (typeof value === "number") {
+      this.#iteratees.push({ action, count: value });
     }
-
-    // the host is the remaining to the left of the first non-host char
-    hostEnd = -1;
-    for (i = 0; i < nonHostChars.length; i++) {
-      hec = rest.indexOf(nonHostChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec;
+    return this;
+  }
+  next() {
+    return this.#getNext();
+  }
+  // Iteratees methods
+  /**
+   * Transform each item in the sequence to a new value
+   * @param {Function} f
+   */
+  map(f) {
+    return this.push(0 /* MAP */, f);
+  }
+  /**
+   * Select only items matching the given predicate
+   * @param {Function} pred
+   */
+  filter(predicate) {
+    return this.push(1 /* FILTER */, predicate);
+  }
+  /**
+   * Take given numbe for values from sequence
+   * @param {Number} n A number greater than 0
+   */
+  take(n) {
+    return n > 0 ? this.push(2 /* TAKE */, n) : this;
+  }
+  /**
+   * Drop a number of values from the sequence
+   * @param {Number} n Number of items to drop greater than 0
+   */
+  drop(n) {
+    return n > 0 ? this.push(3 /* DROP */, n) : this;
+  }
+  // Transformations
+  /**
+   * Returns a new lazy object with results of the transformation
+   * The entire sequence is realized.
+   *
+   * @param {Callback<Source, Any[]>} fn Tranform function of type (Array) => (Any)
+   */
+  transform(fn) {
+    const self = this;
+    let iter;
+    return Lazy(() => {
+      if (!iter) {
+        iter = Lazy(fn(self.value()));
       }
+      return iter.next();
+    });
+  }
+  // Terminal methods
+  /**
+   * Returns the fully realized values of the iterators.
+   * The return value will be an array unless `lazy.first()` was used.
+   * The realized values are cached for subsequent calls.
+   */
+  value() {
+    if (!this.isDone) {
+      this.isDone = this.#getNext(true).done;
     }
-    // if we still have not hit it, then the entire thing is a host.
-    if (hostEnd === -1) {
-      hostEnd = rest.length;
+    return this.#yieldedValues;
+  }
+  /**
+   * Execute the funcion for each value. Will stop when an execution returns false.
+   * @param {Function} f
+   * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true
+   */
+  each(f) {
+    for (; ; ) {
+      const o = this.next();
+      if (o.done) break;
+      if (f(o.value) === false) return false;
     }
+    return true;
+  }
+  /**
+   * Returns the reduction of sequence according the reducing function
+   *
+   * @param {*} f a reducing function
+   * @param {*} initialValue
+   */
+  reduce(f, initialValue) {
+    let o = this.next();
+    if (initialValue === void 0 && !o.done) {
+      initialValue = o.value;
+      o = this.next();
+    }
+    while (!o.done) {
+      initialValue = f(initialValue, o.value);
+      o = this.next();
+    }
+    return initialValue;
+  }
+  /**
+   * Returns the number of matched items in the sequence
+   */
+  size() {
+    return this.reduce(
+      (acc, _) => ++acc,
+      0
+    );
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-    if (rest[hostEnd - 1] === ':') { hostEnd--; }
-    var host = rest.slice(0, hostEnd);
-    rest = rest.slice(hostEnd);
-
-    // pull out port.
-    this.parseHost(host);
 
-    // we've indicated that there is a hostname,
-    // so even if it's empty, it has to be present.
-    this.hostname = this.hostname || '';
+/***/ }),
 
-    // if hostname begins with [ and ends with ]
-    // assume that it's an IPv6 address.
-    var ipv6Hostname = this.hostname[0] === '[' &&
-        this.hostname[this.hostname.length - 1] === ']';
+/***/ 4330:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-    // validate a little.
-    if (!ipv6Hostname) {
-      var hostparts = this.hostname.split(/\./);
-      for (i = 0, l = hostparts.length; i < l; i++) {
-        var part = hostparts[i];
-        if (!part) { continue; }
-        if (!part.match(hostnamePartPattern)) {
-          var newpart = '';
-          for (var j = 0, k = part.length; j < k; j++) {
-            if (part.charCodeAt(j) > 127) {
-              // we replace non-ASCII char with a temporary placeholder
-              // we need this to make sure size of hostname is not
-              // broken by replacing non-ASCII by nothing
-              newpart += 'x';
-            } else {
-              newpart += part[j];
-            }
-          }
-          // we test again with ASCII char only
-          if (!newpart.match(hostnamePartPattern)) {
-            var validParts = hostparts.slice(0, i);
-            var notHost = hostparts.slice(i + 1);
-            var bit = part.match(hostnamePartStart);
-            if (bit) {
-              validParts.push(bit[1]);
-              notHost.unshift(bit[2]);
-            }
-            if (notHost.length) {
-              rest = notHost.join('.') + rest;
-            }
-            this.hostname = validParts.join('.');
-            break;
-          }
-        }
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var predicates_exports = {};
+__export(predicates_exports, {
+  $all: () => $all,
+  $elemMatch: () => $elemMatch,
+  $eq: () => $eq,
+  $exists: () => $exists,
+  $gt: () => $gt,
+  $gte: () => $gte,
+  $in: () => $in,
+  $lt: () => $lt,
+  $lte: () => $lte,
+  $mod: () => $mod,
+  $ne: () => $ne,
+  $nin: () => $nin,
+  $regex: () => $regex,
+  $size: () => $size,
+  $type: () => $type,
+  createExpressionOperator: () => createExpressionOperator,
+  createQueryOperator: () => createQueryOperator
+});
+module.exports = __toCommonJS(predicates_exports);
+var import_core = __webpack_require__(2760);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+function createQueryOperator(predicate) {
+  const f = (selector, value, options) => {
+    const opts = { unwrapArray: true };
+    const depth = Math.max(1, selector.split(".").length - 1);
+    return (obj) => {
+      const lhs = (0, import_util.resolve)(obj, selector, opts);
+      return predicate(lhs, value, { ...options, depth });
+    };
+  };
+  f.op = "query";
+  return f;
+}
+function createExpressionOperator(predicate) {
+  return (obj, expr, options) => {
+    const args = (0, import_core.computeValue)(obj, expr, null, options);
+    return predicate(...args);
+  };
+}
+function $eq(a, b, options) {
+  if ((0, import_util.isEqual)(a, b)) return true;
+  if ((0, import_util.isNil)(a) && (0, import_util.isNil)(b)) return true;
+  if ((0, import_util.isArray)(a)) {
+    return a.some((v) => (0, import_util.isEqual)(v, b)) || (0, import_util.flatten)(a, options?.depth).some((v) => (0, import_util.isEqual)(v, b));
+  }
+  return false;
+}
+function $ne(a, b, options) {
+  return !$eq(a, b, options);
+}
+function $in(a, b, options) {
+  if ((0, import_util.isNil)(a)) return b.some((v) => v === null);
+  return (0, import_util.intersection)([(0, import_util.ensureArray)(a), b], options?.hashFunction).length > 0;
+}
+function $nin(a, b, options) {
+  return !$in(a, b, options);
+}
+function $lt(a, b, _options) {
+  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) < 0);
+}
+function $lte(a, b, _options) {
+  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) <= 0);
+}
+function $gt(a, b, _options) {
+  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) > 0);
+}
+function $gte(a, b, _options) {
+  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) >= 0);
+}
+function $mod(a, b, _options) {
+  return (0, import_util.ensureArray)(a).some(
+    (x) => b.length === 2 && x % b[0] === b[1]
+  );
+}
+function $regex(a, b, options) {
+  const lhs = (0, import_util.ensureArray)(a);
+  const match = (x) => (0, import_util.isString)(x) && (0, import_util.truthy)(b.exec(x), options?.useStrictMode);
+  return lhs.some(match) || (0, import_util.flatten)(lhs, 1).some(match);
+}
+function $exists(a, b, _options) {
+  return (b === false || b === 0) && a === void 0 || (b === true || b === 1) && a !== void 0;
+}
+function $all(values, queries, options) {
+  if (!(0, import_util.isArray)(values) || !(0, import_util.isArray)(queries) || !values.length || !queries.length) {
+    return false;
+  }
+  let matched = true;
+  for (const query of queries) {
+    if (!matched) break;
+    if ((0, import_util.isObject)(query) && Object.keys(query).includes("$elemMatch")) {
+      matched = $elemMatch(values, query["$elemMatch"], options);
+    } else if ((0, import_util.isRegExp)(query)) {
+      matched = values.some((s) => typeof s === "string" && query.test(s));
+    } else {
+      matched = values.some((v) => (0, import_util.isEqual)(query, v));
+    }
+  }
+  return matched;
+}
+function $size(a, b, _options) {
+  return Array.isArray(a) && a.length === b;
+}
+function isNonBooleanOperator(name) {
+  return (0, import_util.isOperator)(name) && ["$and", "$or", "$nor"].indexOf(name) === -1;
+}
+function $elemMatch(a, b, options) {
+  if ((0, import_util.isArray)(a) && !(0, import_util.isEmpty)(a)) {
+    let format = (x) => x;
+    let criteria = b;
+    if (Object.keys(b).every(isNonBooleanOperator)) {
+      criteria = { temp: b };
+      format = (x) => ({ temp: x });
+    }
+    const query = new import_query.Query(criteria, options);
+    for (let i = 0, len = a.length; i < len; i++) {
+      if (query.test(format(a[i]))) {
+        return true;
       }
     }
+  }
+  return false;
+}
+const isNull = (a) => a === null;
+const compareFuncs = {
+  array: import_util.isArray,
+  boolean: import_util.isBoolean,
+  date: import_util.isDate,
+  number: import_util.isNumber,
+  null: isNull,
+  object: import_util.isObject,
+  regex: import_util.isRegExp,
+  string: import_util.isString,
+  // added for completeness
+  undefined: import_util.isNil,
+  // deprecated
+  function: (_) => {
+    throw new import_util.MingoError("unsupported type key `function`.");
+  },
+  // Mongo identifiers
+  1: import_util.isNumber,
+  //double
+  2: import_util.isString,
+  3: import_util.isObject,
+  4: import_util.isArray,
+  6: import_util.isNil,
+  // deprecated
+  8: import_util.isBoolean,
+  9: import_util.isDate,
+  10: isNull,
+  11: import_util.isRegExp,
+  16: import_util.isNumber,
+  18: import_util.isNumber,
+  19: import_util.isNumber
+  //decimal
+};
+function compareType(a, b, _) {
+  const f = compareFuncs[b];
+  return f ? f(a) : false;
+}
+function $type(a, b, options) {
+  return (0, import_util.isArray)(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);
+}
+function compare(a, b, f) {
+  return (0, import_util.ensureArray)(a).some((x) => (0, import_util.typeOf)(x) === (0, import_util.typeOf)(b) && f(x, b));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-    if (this.hostname.length > hostnameMaxLen) {
-      this.hostname = '';
-    }
 
-    // strip [ and ] from the hostname
-    // the host field still retains them, though
-    if (ipv6Hostname) {
-      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
-    }
-  }
+/***/ }),
+
+/***/ 1424:
+/***/ ((module) => {
 
-  // chop off from the tail first.
-  var hash = rest.indexOf('#');
-  if (hash !== -1) {
-    // got a fragment string.
-    this.hash = rest.substr(hash);
-    rest = rest.slice(0, hash);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  var qm = rest.indexOf('?');
-  if (qm !== -1) {
-    this.search = rest.substr(qm);
-    rest = rest.slice(0, qm);
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  covariance: () => covariance,
+  stddev: () => stddev
+});
+module.exports = __toCommonJS(internal_exports);
+function stddev(data, sampled = true) {
+  const sum = data.reduce((acc, n) => acc + n, 0);
+  const N = data.length || 1;
+  const avg = sum / N;
+  return Math.sqrt(
+    data.reduce((acc, n) => acc + Math.pow(n - avg, 2), 0) / (N - Number(sampled))
+  );
+}
+function covariance(dataset, sampled = true) {
+  if (!dataset) return null;
+  if (dataset.length < 2) return sampled ? null : 0;
+  let meanX = 0;
+  let meanY = 0;
+  for (const [x, y] of dataset) {
+    meanX += x;
+    meanY += y;
   }
-  if (rest) { this.pathname = rest; }
-  if (slashedProtocol[lowerProto] &&
-      this.hostname && !this.pathname) {
-    this.pathname = '';
+  meanX /= dataset.length;
+  meanY /= dataset.length;
+  let result = 0;
+  for (const [x, y] of dataset) {
+    result += (x - meanX) * (y - meanY);
   }
+  return result / (dataset.length - Number(sampled));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-  return this;
+
+/***/ }),
+
+/***/ 4426:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accumulator_exports = {};
+__export(accumulator_exports, {
+  $accumulator: () => $accumulator
+});
+module.exports = __toCommonJS(accumulator_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $accumulator = (collection, expr, options) => {
+  (0, import_util.assert)(
+    !!options && options.scriptEnabled,
+    "$accumulator operator requires 'scriptEnabled' option to be true"
+  );
+  if (collection.length == 0) return expr.initArgs;
+  const copts = import_core.ComputeOptions.init(options);
+  const initArgs = (0, import_core.computeValue)(
+    {},
+    expr.initArgs || [],
+    null,
+    copts.update(copts?.local?.groupId || {})
+  );
+  let state = expr.init.call(null, ...initArgs);
+  for (const doc of collection) {
+    const args = (0, import_core.computeValue)(
+      doc,
+      expr.accumulateArgs,
+      null,
+      copts.update(doc)
+    );
+    state = expr.accumulate.call(null, ...[state, ...args]);
+  }
+  return expr.finalize ? expr.finalize.call(null, state) : state;
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Url.prototype.parseHost = function(host) {
-  var port = portPattern.exec(host);
-  if (port) {
-    port = port[0];
-    if (port !== ':') {
-      this.port = port.substr(1);
-    }
-    host = host.substr(0, host.length - port.length);
+
+/***/ }),
+
+/***/ 320:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  if (host) { this.hostname = host; }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addToSet_exports = {};
+__export(addToSet_exports, {
+  $addToSet: () => $addToSet
+});
+module.exports = __toCommonJS(addToSet_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $addToSet = (collection, expr, options) => {
+  return (0, import_util.unique)(
+    (0, import_push.$push)(collection, expr, options),
+    options?.hashFunction
+  );
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
 
-module.exports = urlParse;
+/***/ }),
+
+/***/ 9000:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var avg_exports = {};
+__export(avg_exports, {
+  $avg: () => $avg
+});
+module.exports = __toCommonJS(avg_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $avg = (collection, expr, options) => {
+  const data = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);
+  const sum = data.reduce((acc, n) => acc + n, 0);
+  return sum / (data.length || 1);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7268:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 5045:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bottom_exports = {};
+__export(bottom_exports, {
+  $bottom: () => $bottom
+});
+module.exports = __toCommonJS(bottom_exports);
+var import_bottomN = __webpack_require__(4683);
+const $bottom = (collection, expr, options) => (0, import_bottomN.$bottomN)(collection, { ...expr, n: 1 }, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Aggregator = void 0;
-const core_1 = __webpack_require__(9587);
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Provides functionality for the mongoDB aggregation pipeline
- *
- * @param pipeline an Array of pipeline operators
- * @param options An optional Options to pass the aggregator
- * @constructor
- */
-class Aggregator {
-    constructor(pipeline, options) {
-        this.pipeline = pipeline;
-        this.options = (0, core_1.initOptions)(options);
-    }
-    /**
-     * Returns an `Lazy` iterator for processing results of pipeline
-     *
-     * @param {*} collection An array or iterator object
-     * @returns {Iterator} an iterator object
-     */
-    stream(collection) {
-        let iterator = (0, lazy_1.Lazy)(collection);
-        const mode = this.options.processingMode;
-        if (mode == core_1.ProcessingMode.CLONE_ALL ||
-            mode == core_1.ProcessingMode.CLONE_INPUT) {
-            iterator.map(util_1.cloneDeep);
-        }
-        const pipelineOperators = new Array();
-        if (!(0, util_1.isEmpty)(this.pipeline)) {
-            // run aggregation pipeline
-            for (const operator of this.pipeline) {
-                const operatorKeys = Object.keys(operator);
-                const opName = operatorKeys[0];
-                const call = (0, core_1.getOperator)(core_1.OperatorType.PIPELINE, opName, this.options);
-                (0, util_1.assert)(operatorKeys.length === 1 && !!call, `invalid pipeline operator ${opName}`);
-                pipelineOperators.push(opName);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                iterator = call(iterator, operator[opName], this.options);
-            }
-        }
-        // operators that may share object graphs of inputs.
-        // we only need to clone the output for these since the objects will already be distinct for other operators.
-        if (mode == core_1.ProcessingMode.CLONE_OUTPUT ||
-            (mode == core_1.ProcessingMode.CLONE_ALL &&
-                !!(0, util_1.intersection)([["$group", "$unwind"], pipelineOperators]).length)) {
-            iterator.map(util_1.cloneDeep);
-        }
-        return iterator;
-    }
-    /**
-     * Return the results of the aggregation as an array.
-     *
-     * @param {*} collection
-     * @param {*} query
-     */
-    run(collection) {
-        return this.stream(collection).value();
-    }
-}
-exports.Aggregator = Aggregator;
+
+/***/ }),
+
+/***/ 4683:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bottomN_exports = {};
+__export(bottomN_exports, {
+  $bottomN: () => $bottomN
+});
+module.exports = __toCommonJS(bottomN_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+var import_push = __webpack_require__(4518);
+const $bottomN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const { n, sortBy } = (0, import_core.computeValue)(
+    copts.local.groupId,
+    expr,
+    null,
+    copts
+  );
+  const result = new import_aggregator.Aggregator([{ $sort: sortBy }], copts).run(collection);
+  const m = result.length;
+  const p = n;
+  return (0, import_push.$push)(m <= p ? result : result.slice(m - p), expr.output, copts);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9587:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 6995:
+/***/ ((module) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var count_exports = {};
+__export(count_exports, {
+  $count: () => $count
+});
+module.exports = __toCommonJS(count_exports);
+const $count = (collection, _expr, _options) => collection.length;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.redact = exports.computeValue = exports.getOperator = exports.useOperators = exports.Context = exports.OperatorType = exports.initOptions = exports.ComputeOptions = exports.ProcessingMode = void 0;
-const util_1 = __webpack_require__(7216);
-/**
- * This controls how input and output documents are processed to meet different application needs.
- * Each mode has different trade offs for; immutability, reference sharing, and performance.
- */
-var ProcessingMode;
-(function (ProcessingMode) {
-    /**
-     * Clone inputs prior to processing, and the outputs if some objects graphs may be shared.
-     * Use this option to keep input collection immutable and to get distinct output objects.
-     *
-     * Note: This option is expensive and reduces performance.
-     */
-    ProcessingMode["CLONE_ALL"] = "CLONE_ALL";
-    /**
-     * Clones inputs prior to processing.
-     * This option will return output objects with shared graphs in their path if specific operators are used.
-     * Use this option to keep the input collection immutable.
-     *
-     */
-    ProcessingMode["CLONE_INPUT"] = "CLONE_INPUT";
-    /**
-     * Clones the output to return distinct objects with no shared paths.
-     * This option modifies the input collection and during processing.
-     */
-    ProcessingMode["CLONE_OUTPUT"] = "CLONE_OUTPUT";
-    /**
-     * Turn off cloning and modifies the input collection as needed.
-     * This option will also return output objects with shared paths in their graph when specific operators are used.
-     * This option provides the greatest speedup for the biggest tradeoff.
-     * When using the aggregation pipeline, you can use the "$out" operator to collect immutable intermediate results.
-     *
-     * @default
-     */
-    ProcessingMode["CLONE_OFF"] = "CLONE_OFF";
-})(ProcessingMode = exports.ProcessingMode || (exports.ProcessingMode = {}));
-/** Custom type to facilitate type checking for global options */
-class ComputeOptions {
-    constructor(_opts, 
-    /** Reference to the root object when processing subgraphs of the object. */
-    _root, _local, 
-    /** The current time in milliseconds. Remains the same throughout all stages of the aggregation pipeline. */
-    timestamp = Date.now()) {
-        this._opts = _opts;
-        this._root = _root;
-        this._local = _local;
-        this.timestamp = timestamp;
-        this.update(_root, _local);
-    }
-    /**
-     * Initialize new ComputeOptions.
-     *
-     * @param options
-     * @param root
-     * @param local
-     * @returns {ComputeOptions}
-     */
-    static init(options, root, local) {
-        return options instanceof ComputeOptions
-            ? new ComputeOptions(options._opts, (0, util_1.isNil)(options.root) ? root : options.root, Object.assign({}, options.local, local))
-            : new ComputeOptions(options, root, local);
-    }
-    /** Updates the internal mutable state. */
-    update(root, local) {
-        var _a;
-        // NOTE: this is done for efficiency to avoid creating too many intermediate options objects.
-        this._root = root;
-        this._local = local
-            ? Object.assign({}, local, {
-                variables: Object.assign({}, (_a = this._local) === null || _a === void 0 ? void 0 : _a.variables, local === null || local === void 0 ? void 0 : local.variables)
-            })
-            : local;
-        return this;
-    }
-    getOptions() {
-        return Object.freeze(Object.assign(Object.assign({}, this._opts), { context: Context.from(this._opts.context) }));
-    }
-    get root() {
-        return this._root;
-    }
-    get local() {
-        return this._local;
-    }
-    get idKey() {
-        return this._opts.idKey;
-    }
-    get collation() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.collation;
-    }
-    get processingMode() {
-        var _a;
-        return ((_a = this._opts) === null || _a === void 0 ? void 0 : _a.processingMode) || ProcessingMode.CLONE_OFF;
-    }
-    get useStrictMode() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.useStrictMode;
-    }
-    get scriptEnabled() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.scriptEnabled;
-    }
-    get useGlobalContext() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.useGlobalContext;
-    }
-    get hashFunction() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.hashFunction;
-    }
-    get collectionResolver() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.collectionResolver;
-    }
-    get jsonSchemaValidator() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.jsonSchemaValidator;
-    }
-    get variables() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.variables;
-    }
-    get context() {
-        var _a;
-        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.context;
-    }
-}
-exports.ComputeOptions = ComputeOptions;
-/**
- * Creates an Option from another where required keys are initialized.
- * @param options Options
- */
-function initOptions(options) {
-    return options instanceof ComputeOptions
-        ? options.getOptions()
-        : Object.freeze(Object.assign(Object.assign({ idKey: "_id", scriptEnabled: true, useStrictMode: true, useGlobalContext: true, processingMode: ProcessingMode.CLONE_OFF }, options), { context: (options === null || options === void 0 ? void 0 : options.context)
-                ? Context.from(options === null || options === void 0 ? void 0 : options.context)
-                : Context.init({}) }));
-}
-exports.initOptions = initOptions;
-/**
- * The different groups of operators
- */
-var OperatorType;
-(function (OperatorType) {
-    OperatorType["ACCUMULATOR"] = "accumulator";
-    OperatorType["EXPRESSION"] = "expression";
-    OperatorType["PIPELINE"] = "pipeline";
-    OperatorType["PROJECTION"] = "projection";
-    OperatorType["QUERY"] = "query";
-    OperatorType["WINDOW"] = "window";
-})(OperatorType = exports.OperatorType || (exports.OperatorType = {}));
-class Context {
-    constructor(ops) {
-        this.operators = (0, util_1.cloneDeep)(ops);
-    }
-    static init(ops) {
-        return new Context((0, util_1.merge)({
-            [OperatorType.ACCUMULATOR]: {},
-            [OperatorType.EXPRESSION]: {},
-            [OperatorType.PIPELINE]: {},
-            [OperatorType.PROJECTION]: {},
-            [OperatorType.QUERY]: {},
-            [OperatorType.WINDOW]: {}
-        }, ops, { skipValidation: true }));
-    }
-    static from(ctx) {
-        return new Context(ctx.operators);
-    }
-    addOperators(type, ops) {
-        for (const [name, fn] of Object.entries(ops)) {
-            if (!this.getOperator(type, name)) {
-                this.operators[type][name] = fn;
-            }
-        }
-        return this;
-    }
-    // register
-    addAccumulatorOps(ops) {
-        return this.addOperators(OperatorType.ACCUMULATOR, ops);
-    }
-    addExpressionOps(ops) {
-        return this.addOperators(OperatorType.EXPRESSION, ops);
-    }
-    addQueryOps(ops) {
-        return this.addOperators(OperatorType.QUERY, ops);
-    }
-    addPipelineOps(ops) {
-        return this.addOperators(OperatorType.PIPELINE, ops);
-    }
-    addProjectionOps(ops) {
-        return this.addOperators(OperatorType.PROJECTION, ops);
-    }
-    addWindowOps(ops) {
-        return this.addOperators(OperatorType.WINDOW, ops);
-    }
-    // getters
-    getOperator(type, name) {
-        return type in this.operators ? this.operators[type][name] || null : null;
-    }
-}
-exports.Context = Context;
-// operator definitions
-const CONTEXT = Context.init({});
-/**
- * Register fully specified operators for the given operator class.
- *
- * @param type The operator type
- * @param operators Map of the operators
- */
-function useOperators(type, operators) {
-    for (const [name, fn] of Object.entries(operators)) {
-        (0, util_1.assert)((0, util_1.isFunction)(fn) && (0, util_1.isOperator)(name), `'${name}' is not a valid operator`);
-        const currentFn = getOperator(type, name, null);
-        (0, util_1.assert)(!currentFn || fn === currentFn, `${name} already exists for '${type}' operators. Cannot change operator function once registered.`);
-    }
-    // toss the operator salad :)
-    CONTEXT.addOperators(type, operators);
-}
-exports.useOperators = useOperators;
-/**
- * Returns the operator function or undefined if it is not found
- * @param type Type of operator
- * @param operator Name of the operator
- */
-function getOperator(type, operator, options) {
-    const { context: ctx, useGlobalContext: fallback } = options || {};
-    const fn = ctx ? ctx.getOperator(type, operator) : null;
-    return !fn && fallback ? CONTEXT.getOperator(type, operator) : fn;
-}
-exports.getOperator = getOperator;
-/* eslint-disable unused-imports/no-unused-vars-ts */
-/**
- * Implementation of system variables
- * @type {Object}
- */
-const systemVariables = {
-    $$ROOT(obj, expr, options) {
-        return options.root;
-    },
-    $$CURRENT(obj, expr, options) {
-        return obj;
-    },
-    $$REMOVE(obj, expr, options) {
-        return undefined;
-    },
-    $$NOW(obj, expr, options) {
-        return new Date(options.timestamp);
-    }
+
+/***/ }),
+
+/***/ 3516:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Implementation of $redact variables
- *
- * Each function accepts 3 arguments (obj, expr, options)
- *
- * @type {Object}
- */
-const redactVariables = {
-    $$KEEP(obj, expr, options) {
-        return obj;
-    },
-    $$PRUNE(obj, expr, options) {
-        return undefined;
-    },
-    $$DESCEND(obj, expr, options) {
-        // traverse nested documents iff there is a $cond
-        if (!(0, util_1.has)(expr, "$cond"))
-            return obj;
-        let result;
-        for (const [key, current] of Object.entries(obj)) {
-            if ((0, util_1.isObjectLike)(current)) {
-                if (current instanceof Array) {
-                    const array = [];
-                    for (let elem of current) {
-                        if ((0, util_1.isObject)(elem)) {
-                            elem = redact(elem, expr, options.update(elem));
-                        }
-                        if (!(0, util_1.isNil)(elem)) {
-                            array.push(elem);
-                        }
-                    }
-                    result = array;
-                }
-                else {
-                    result = redact(current, expr, options.update(current));
-                }
-                if ((0, util_1.isNil)(result)) {
-                    delete obj[key]; // pruned result
-                }
-                else {
-                    obj[key] = result;
-                }
-            }
-        }
-        return obj;
-    }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-/* eslint-enable unused-imports/no-unused-vars-ts */
-/**
- * Computes the value of the expression on the object for the given operator
- *
- * @param obj the current object from the collection
- * @param expr the expression for the given field
- * @param operator the operator to resolve the field with
- * @param options {Object} extra options
- * @returns {*}
- */
-function computeValue(obj, expr, operator, options) {
-    var _a;
-    // ensure valid options exist on first invocation
-    const copts = ComputeOptions.init(options, obj);
-    operator = operator || "";
-    if ((0, util_1.isOperator)(operator)) {
-        // if the field of the object is a valid operator
-        const callExpression = getOperator(OperatorType.EXPRESSION, operator, options);
-        if (callExpression)
-            return callExpression(obj, expr, copts);
-        // we also handle $group accumulator operators
-        const callAccumulator = getOperator(OperatorType.ACCUMULATOR, operator, options);
-        if (callAccumulator) {
-            // if object is not an array, first try to compute using the expression
-            if (!(obj instanceof Array)) {
-                obj = computeValue(obj, expr, null, copts);
-                expr = null;
-            }
-            // validate that we have an array
-            (0, util_1.assert)(obj instanceof Array, `'${operator}' target must be an array.`);
-            // for accumulators, we use the global options since the root is specific to each element within array.
-            return callAccumulator(obj, expr, 
-            // reset the root object for accumulators.
-            copts.update(null, copts.local));
-        }
-        // operator was not found
-        throw new Error(`operator '${operator}' is not registered`);
-    }
-    // if expr is a string and begins with "$$", then we have a variable.
-    //  this can be one of; redact variable, system variable, user-defined variable.
-    //  we check and process them in that order.
-    //
-    // if expr begins only a single "$", then it is a path to a field on the object.
-    if ((0, util_1.isString)(expr) && expr.length > 0 && expr[0] === "$") {
-        // we return redact variables as literals
-        if ((0, util_1.has)(redactVariables, expr)) {
-            return expr;
-        }
-        // default to root for resolving path.
-        let context = copts.root;
-        // handle selectors with explicit prefix
-        const arr = expr.split(".");
-        if ((0, util_1.has)(systemVariables, arr[0])) {
-            // set 'root' only the first time it is required to be used for all subsequent calls
-            // if it already available on the options, it will be used
-            context = systemVariables[arr[0]](obj, null, copts);
-            expr = expr.slice(arr[0].length + 1); //  +1 for '.'
-        }
-        else if (arr[0].slice(0, 2) === "$$") {
-            // handle user-defined variables
-            context = Object.assign({}, copts.variables, // global vars
-            // current item is added before local variables because the binding may be changed.
-            { this: obj }, (_a = copts.local) === null || _a === void 0 ? void 0 : _a.variables // local vars
-            );
-            const prefix = arr[0].slice(2);
-            (0, util_1.assert)((0, util_1.has)(context, prefix), `Use of undefined variable: ${prefix}`);
-            expr = expr.slice(2);
-        }
-        else {
-            // 'expr' is a path to a field on the object.
-            expr = expr.slice(1);
-        }
-        if (expr === "")
-            return context;
-        return (0, util_1.resolve)(context, expr);
-    }
-    // check and return value if already in a resolved state
-    if ((0, util_1.isArray)(expr)) {
-        return expr.map((item) => computeValue(obj, item, null, copts));
-    }
-    else if ((0, util_1.isObject)(expr)) {
-        const result = {};
-        for (const [key, val] of Object.entries(expr)) {
-            result[key] = computeValue(obj, val, key, copts);
-            // must run ONLY one aggregate operator per expression
-            // if so, return result of the computed value
-            if ([OperatorType.EXPRESSION, OperatorType.ACCUMULATOR].some(t => !!getOperator(t, key, options))) {
-                // there should be only one operator
-                (0, util_1.assert)(Object.keys(expr).length === 1, "Invalid aggregation expression '" + JSON.stringify(expr) + "'");
-                return result[key];
-            }
-        }
-        return result;
-    }
-    return expr;
-}
-exports.computeValue = computeValue;
-/**
- * Redact an object
- * @param  {Object} obj The object to redact
- * @param  {*} expr The redact expression
- * @param  {*} options  Options for value
- * @return {*} returns the result of the redacted object
- */
-function redact(obj, expr, options) {
-    const result = computeValue(obj, expr, null, options);
-    return (0, util_1.has)(redactVariables, result)
-        ? redactVariables[result](obj, expr, options)
-        : result;
-}
-exports.redact = redact;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var covariancePop_exports = {};
+__export(covariancePop_exports, {
+  $covariancePop: () => $covariancePop
+});
+module.exports = __toCommonJS(covariancePop_exports);
+var import_internal = __webpack_require__(1424);
+var import_push = __webpack_require__(4518);
+const $covariancePop = (collection, expr, options) => (0, import_internal.covariance)((0, import_push.$push)(collection, expr, options), false);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 4862:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var covarianceSamp_exports = {};
+__export(covarianceSamp_exports, {
+  $covarianceSamp: () => $covarianceSamp
+});
+module.exports = __toCommonJS(covarianceSamp_exports);
+var import_internal = __webpack_require__(1424);
+var import_push = __webpack_require__(4518);
+const $covarianceSamp = (collection, expr, options) => (0, import_internal.covariance)((0, import_push.$push)(collection, expr, options), true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3645:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 1058:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var first_exports = {};
+__export(first_exports, {
+  $first: () => $first
+});
+module.exports = __toCommonJS(first_exports);
+var import_core = __webpack_require__(2760);
+const $first = (collection, expr, options) => {
+  if (collection.length === 0) return void 0;
+  const copts = import_core.ComputeOptions.init(options).update(collection[0]);
+  return (0, import_core.computeValue)(collection[0], expr, null, copts);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Cursor = void 0;
-const aggregator_1 = __webpack_require__(7268);
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Cursor to iterate and perform filtering on matched objects.
- * This object must not be used directly. A cursor may be obtaine from calling `find()` on an instance of `Query`.
- *
- * @param collection The input source of the collection
- * @param predicate A predicate function to test documents
- * @param projection A projection criteria
- * @param options Options
- * @constructor
- */
-class Cursor {
-    constructor(source, predicate, projection, options) {
-        this.source = source;
-        this.predicate = predicate;
-        this.projection = projection;
-        this.options = options;
-        this.operators = [];
-        this.result = null;
-        this.buffer = [];
-    }
-    /** Returns the iterator from running the query */
-    fetch() {
-        if (this.result)
-            return this.result;
-        // add projection operator
-        if ((0, util_1.isObject)(this.projection)) {
-            this.operators.push({ $project: this.projection });
-        }
-        // filter collection
-        this.result = (0, lazy_1.Lazy)(this.source).filter(this.predicate);
-        if (this.operators.length > 0) {
-            this.result = new aggregator_1.Aggregator(this.operators, this.options).stream(this.result);
-        }
-        return this.result;
-    }
-    /** Returns an iterator with the buffered data included */
-    fetchAll() {
-        const buffered = (0, lazy_1.Lazy)([...this.buffer]);
-        this.buffer = [];
-        return (0, lazy_1.compose)(buffered, this.fetch());
-    }
-    /**
-     * Return remaining objects in the cursor as an array. This method exhausts the cursor
-     * @returns {Array}
-     */
-    all() {
-        return this.fetchAll().value();
-    }
-    /**
-     * Returns the number of objects return in the cursor. This method exhausts the cursor
-     * @returns {Number}
-     */
-    count() {
-        return this.all().length;
-    }
-    /**
-     * Returns a cursor that begins returning results only after passing or skipping a number of documents.
-     * @param {Number} n the number of results to skip.
-     * @return {Cursor} Returns the cursor, so you can chain this call.
-     */
-    skip(n) {
-        this.operators.push({ $skip: n });
-        return this;
-    }
-    /**
-     * Constrains the size of a cursor's result set.
-     * @param {Number} n the number of results to limit to.
-     * @return {Cursor} Returns the cursor, so you can chain this call.
-     */
-    limit(n) {
-        this.operators.push({ $limit: n });
-        return this;
-    }
-    /**
-     * Returns results ordered according to a sort specification.
-     * @param {Object} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
-     * @return {Cursor} Returns the cursor, so you can chain this call.
-     */
-    sort(modifier) {
-        this.operators.push({ $sort: modifier });
-        return this;
-    }
-    /**
-     * Specifies the collation for the cursor returned by the `mingo.Query.find`
-     * @param {*} spec
-     */
-    collation(spec) {
-        this.options = Object.assign(Object.assign({}, this.options), { collation: spec });
-        return this;
-    }
-    /**
-     * Returns the next document in a cursor.
-     * @returns {Object | Boolean}
-     */
-    next() {
-        // yield value obtains in hasNext()
-        if (this.buffer.length > 0) {
-            return this.buffer.pop();
-        }
-        const o = this.fetch().next();
-        if (o.done)
-            return;
-        return o.value;
-    }
-    /**
-     * Returns true if the cursor has documents and can be iterated.
-     * @returns {boolean}
-     */
-    hasNext() {
-        // there is a value in the buffer
-        if (this.buffer.length > 0)
-            return true;
-        const o = this.fetch().next();
-        if (o.done)
-            return false;
-        this.buffer.push(o.value);
-        return true;
-    }
-    /**
-     * Applies a function to each document in a cursor and collects the return values in an array.
-     * @param callback
-     * @returns {Array}
-     */
-    map(callback) {
-        return this.all().map(callback);
-    }
-    /**
-     * Applies a JavaScript function for every document in a cursor.
-     * @param callback
-     */
-    forEach(callback) {
-        this.all().forEach(callback);
-    }
-    [Symbol.iterator]() {
-        return this.fetchAll();
-    }
-}
-exports.Cursor = Cursor;
+
+/***/ }),
+
+/***/ 6550:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var firstN_exports = {};
+__export(firstN_exports, {
+  $firstN: () => $firstN
+});
+module.exports = __toCommonJS(firstN_exports);
+var import_core = __webpack_require__(2760);
+var import_push = __webpack_require__(4518);
+const $firstN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const m = collection.length;
+  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);
+  return (0, import_push.$push)(
+    m <= n ? collection : collection.slice(0, n),
+    expr.input,
+    options
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6090:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 1248:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accumulator_exports = {};
+module.exports = __toCommonJS(accumulator_exports);
+__reExport(accumulator_exports, __webpack_require__(4426), module.exports);
+__reExport(accumulator_exports, __webpack_require__(320), module.exports);
+__reExport(accumulator_exports, __webpack_require__(9000), module.exports);
+__reExport(accumulator_exports, __webpack_require__(5045), module.exports);
+__reExport(accumulator_exports, __webpack_require__(4683), module.exports);
+__reExport(accumulator_exports, __webpack_require__(6995), module.exports);
+__reExport(accumulator_exports, __webpack_require__(3516), module.exports);
+__reExport(accumulator_exports, __webpack_require__(4862), module.exports);
+__reExport(accumulator_exports, __webpack_require__(1058), module.exports);
+__reExport(accumulator_exports, __webpack_require__(6550), module.exports);
+__reExport(accumulator_exports, __webpack_require__(9666), module.exports);
+__reExport(accumulator_exports, __webpack_require__(3830), module.exports);
+__reExport(accumulator_exports, __webpack_require__(4674), module.exports);
+__reExport(accumulator_exports, __webpack_require__(6870), module.exports);
+__reExport(accumulator_exports, __webpack_require__(9524), module.exports);
+__reExport(accumulator_exports, __webpack_require__(8702), module.exports);
+__reExport(accumulator_exports, __webpack_require__(2908), module.exports);
+__reExport(accumulator_exports, __webpack_require__(2184), module.exports);
+__reExport(accumulator_exports, __webpack_require__(6393), module.exports);
+__reExport(accumulator_exports, __webpack_require__(4518), module.exports);
+__reExport(accumulator_exports, __webpack_require__(1779), module.exports);
+__reExport(accumulator_exports, __webpack_require__(9388), module.exports);
+__reExport(accumulator_exports, __webpack_require__(3295), module.exports);
+__reExport(accumulator_exports, __webpack_require__(7995), module.exports);
+__reExport(accumulator_exports, __webpack_require__(1977), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 9666:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.aggregate = exports.remove = exports.find = exports.Query = exports.Aggregator = void 0;
-// loads basic operators
-__webpack_require__(9207);
-const aggregator_1 = __webpack_require__(7268);
-const query_1 = __webpack_require__(809);
-var aggregator_2 = __webpack_require__(7268);
-Object.defineProperty(exports, "Aggregator", ({ enumerable: true, get: function () { return aggregator_2.Aggregator; } }));
-var query_2 = __webpack_require__(809);
-Object.defineProperty(exports, "Query", ({ enumerable: true, get: function () { return query_2.Query; } }));
-/**
- * Performs a query on a collection and returns a cursor object.
- * Shorthand for `Query(criteria).find(collection, projection)`
- *
- * @param collection Array of objects
- * @param criteria Query criteria
- * @param projection Projection criteria
- * @param options
- * @returns {Cursor} A cursor of results
- */
-function find(collection, criteria, projection, options) {
-    return new query_1.Query(criteria, options).find(collection, projection);
-}
-exports.find = find;
-/**
- * Returns a new array without objects which match the criteria
- *
- * @param collection Array of objects
- * @param criteria Query criteria of objects to remove
- * @param options
- * @returns {Array} New filtered array
- */
-function remove(collection, criteria, options) {
-    return new query_1.Query(criteria, options).remove(collection);
-}
-exports.remove = remove;
-/**
- * Return the result collection after running the aggregation pipeline for the given collection.
- * Shorthand for `(new Aggregator(pipeline, options)).run(collection)`
- *
- * @param collection array or stream of objects
- * @param pipeline The pipeline operators to use
- * @param options
- * @returns {Array} New array of results
- */
-function aggregate(collection, pipeline, options) {
-    return new aggregator_1.Aggregator(pipeline, options).run(collection);
-}
-exports.aggregate = aggregate;
-// default interface
-exports["default"] = {
-    Aggregator: aggregator_1.Aggregator,
-    Query: query_1.Query,
-    aggregate,
-    find,
-    remove
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var last_exports = {};
+__export(last_exports, {
+  $last: () => $last
+});
+module.exports = __toCommonJS(last_exports);
+var import_core = __webpack_require__(2760);
+const $last = (collection, expr, options) => {
+  if (collection.length === 0) return void 0;
+  const obj = collection[collection.length - 1];
+  const copts = import_core.ComputeOptions.init(options).update(obj);
+  return (0, import_core.computeValue)(obj, expr, null, copts);
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9207:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 3830:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lastN_exports = {};
+__export(lastN_exports, {
+  $lastN: () => $lastN
 });
-var __importStar = (this && this.__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;
+module.exports = __toCommonJS(lastN_exports);
+var import_core = __webpack_require__(2760);
+var import_push = __webpack_require__(4518);
+const $lastN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const m = collection.length;
+  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);
+  return (0, import_push.$push)(
+    m <= n ? collection : collection.slice(m - n),
+    expr.input,
+    options
+  );
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BASIC_CONTEXT = void 0;
-/**
- * Loads all Query and Projection operators
- */
-const core_1 = __webpack_require__(9587);
-const booleanOperators = __importStar(__webpack_require__(628));
-const comparisonOperators = __importStar(__webpack_require__(4591));
-const pipeline_1 = __webpack_require__(6582);
-const projectionOperators = __importStar(__webpack_require__(3791));
-const queryOperators = __importStar(__webpack_require__(5444));
-(0, core_1.useOperators)(core_1.OperatorType.EXPRESSION, Object.assign(Object.assign({}, booleanOperators), comparisonOperators));
-(0, core_1.useOperators)(core_1.OperatorType.PIPELINE, {
-    $project: pipeline_1.$project,
-    $skip: pipeline_1.$skip,
-    $limit: pipeline_1.$limit,
-    $sort: pipeline_1.$sort
-});
-(0, core_1.useOperators)(core_1.OperatorType.PROJECTION, projectionOperators);
-(0, core_1.useOperators)(core_1.OperatorType.QUERY, queryOperators);
-/** The basic context for queries. */
-exports.BASIC_CONTEXT = core_1.Context.init({
-    [core_1.OperatorType.EXPRESSION]: Object.assign(Object.assign({}, booleanOperators), comparisonOperators),
-    [core_1.OperatorType.PIPELINE]: {
-        $project: pipeline_1.$project,
-        $skip: pipeline_1.$skip,
-        $limit: pipeline_1.$limit,
-        $sort: pipeline_1.$sort
-    },
-    [core_1.OperatorType.PROJECTION]: projectionOperators,
-    [core_1.OperatorType.QUERY]: queryOperators
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 4674:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_exports = {};
+__export(max_exports, {
+  $max: () => $max
 });
+module.exports = __toCommonJS(max_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $max = (collection, expr, options) => {
+  const items = (0, import_push.$push)(collection, expr, options);
+  if ((0, import_util.isEmpty)(items)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(items), "$max: input must resolve to array");
+  let max = items[0];
+  for (const n of items) {
+    if ((0, import_util.isNil)(n) || isNaN(n)) continue;
+    if ((0, import_util.compare)(n, max) >= 0) max = n;
+  }
+  return max;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9176:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 6870:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var maxN_exports = {};
+__export(maxN_exports, {
+  $maxN: () => $maxN
+});
+module.exports = __toCommonJS(maxN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $maxN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const m = collection.length;
+  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);
+  const arr = (0, import_push.$push)(collection, expr.input, options).filter((o) => !(0, import_util.isNil)(o));
+  arr.sort((a, b) => -1 * (0, import_util.compare)(a, b));
+  return m <= n ? arr : arr.slice(0, n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Iterator = exports.compose = exports.Lazy = void 0;
-/**
- * Returns an iterator
- * @param {*} source An iterable source (Array, Function, Generator, or Iterator)
- */
-function Lazy(source) {
-    return source instanceof Iterator ? source : new Iterator(source);
-}
-exports.Lazy = Lazy;
-function compose(...iterators) {
-    let index = 0;
-    return Lazy(() => {
-        while (index < iterators.length) {
-            const o = iterators[index].next();
-            if (!o.done)
-                return o;
-            index++;
-        }
-        return { done: true };
-    });
-}
-exports.compose = compose;
-/**
- * Checks whether the given object is compatible with a generator i.e Object{next:Function}
- * @param {*} o An object
- */
-function isGenerator(o) {
-    return (!!o && typeof o === "object" && (o === null || o === void 0 ? void 0 : o.next) instanceof Function);
-}
-function dropItem(array, i) {
-    const rest = array.slice(i + 1);
-    array.splice(i);
-    Array.prototype.push.apply(array, rest);
-}
-// stop iteration error
-const DONE = new Error();
-// Lazy function actions
-var Action;
-(function (Action) {
-    Action[Action["MAP"] = 0] = "MAP";
-    Action[Action["FILTER"] = 1] = "FILTER";
-    Action[Action["TAKE"] = 2] = "TAKE";
-    Action[Action["DROP"] = 3] = "DROP";
-})(Action || (Action = {}));
-function createCallback(nextFn, iteratees, buffer) {
-    let done = false;
-    let index = -1;
-    let bufferIndex = 0; // index for the buffer
-    return function (storeResult) {
-        // special hack to collect all values into buffer
-        try {
-            outer: while (!done) {
-                let o = nextFn();
-                index++;
-                let i = -1;
-                const size = iteratees.length;
-                let innerDone = false;
-                while (++i < size) {
-                    const r = iteratees[i];
-                    switch (r.action) {
-                        case Action.MAP:
-                            o = r.func(o, index);
-                            break;
-                        case Action.FILTER:
-                            if (!r.func(o, index))
-                                continue outer;
-                            break;
-                        case Action.TAKE:
-                            --r.count;
-                            if (!r.count)
-                                innerDone = true;
-                            break;
-                        case Action.DROP:
-                            --r.count;
-                            if (!r.count)
-                                dropItem(iteratees, i);
-                            continue outer;
-                        default:
-                            break outer;
-                    }
-                }
-                done = innerDone;
-                if (storeResult) {
-                    buffer[bufferIndex++] = o;
-                }
-                else {
-                    return { value: o, done: false };
-                }
-            }
-        }
-        catch (e) {
-            if (e !== DONE)
-                throw e;
-        }
-        done = true;
-        return { done };
-    };
-}
-/**
- * A lazy collection iterator yields a single value at time upon request
- */
-class Iterator {
-    /**
-     * @param {*} source An iterable object or function.
-     *    Array - return one element per cycle
-     *    Object{next:Function} - call next() for the next value (this also handles generator functions)
-     *    Function - call to return the next value
-     * @param {Function} fn An optional transformation function
-     */
-    constructor(source) {
-        this.iteratees = [];
-        this.yieldedValues = [];
-        this.isDone = false;
-        let nextVal;
-        if (source instanceof Function) {
-            // make iterable
-            source = { next: source };
-        }
-        if (isGenerator(source)) {
-            const src = source;
-            nextVal = () => {
-                const o = src.next();
-                if (o.done)
-                    throw DONE;
-                return o.value;
-            };
-        }
-        else if (source instanceof Array) {
-            const data = source;
-            const size = data.length;
-            let index = 0;
-            nextVal = () => {
-                if (index < size)
-                    return data[index++];
-                throw DONE;
-            };
-        }
-        else if (!(source instanceof Function)) {
-            throw new Error(`Source is of type '${typeof source}'. Must be Array, Function, or Generator`);
-        }
-        // create next function
-        this.getNext = createCallback(nextVal, this.iteratees, this.yieldedValues);
-    }
-    /**
-     * Add an iteratee to this lazy sequence
-     */
-    push(action, value) {
-        if (typeof value === "function") {
-            this.iteratees.push({ action, func: value });
-        }
-        else if (typeof value === "number") {
-            this.iteratees.push({ action, count: value });
-        }
-        return this;
-    }
-    next() {
-        return this.getNext();
-    }
-    // Iteratees methods
-    /**
-     * Transform each item in the sequence to a new value
-     * @param {Function} f
-     */
-    map(f) {
-        return this.push(Action.MAP, f);
-    }
-    /**
-     * Select only items matching the given predicate
-     * @param {Function} pred
-     */
-    filter(predicate) {
-        return this.push(Action.FILTER, predicate);
-    }
-    /**
-     * Take given numbe for values from sequence
-     * @param {Number} n A number greater than 0
-     */
-    take(n) {
-        return n > 0 ? this.push(Action.TAKE, n) : this;
-    }
-    /**
-     * Drop a number of values from the sequence
-     * @param {Number} n Number of items to drop greater than 0
-     */
-    drop(n) {
-        return n > 0 ? this.push(Action.DROP, n) : this;
-    }
-    // Transformations
-    /**
-     * Returns a new lazy object with results of the transformation
-     * The entire sequence is realized.
-     *
-     * @param {Function} fn Tranform function of type (Array) => (Any)
-     */
-    transform(fn) {
-        const self = this;
-        let iter;
-        return Lazy(() => {
-            if (!iter) {
-                iter = Lazy(fn(self.value()));
-            }
-            return iter.next();
-        });
-    }
-    // Terminal methods
-    /**
-     * Returns the fully realized values of the iterators.
-     * The return value will be an array unless `lazy.first()` was used.
-     * The realized values are cached for subsequent calls
-     */
-    value() {
-        if (!this.isDone) {
-            this.isDone = this.getNext(true).done;
-        }
-        return this.yieldedValues;
-    }
-    /**
-     * Execute the funcion for each value. Will stop when an execution returns false.
-     * @param {Function} f
-     * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true
-     */
-    each(f) {
-        for (;;) {
-            const o = this.next();
-            if (o.done)
-                break;
-            if (f(o.value) === false)
-                return false;
-        }
-        return true;
-    }
-    /**
-     * Returns the reduction of sequence according the reducing function
-     *
-     * @param {*} f a reducing function
-     * @param {*} init
-     */
-    reduce(f, initialValue) {
-        let o = this.next();
-        if (initialValue === undefined && !o.done) {
-            initialValue = o.value;
-            o = this.next();
-        }
-        while (!o.done) {
-            initialValue = f(initialValue, o.value);
-            o = this.next();
-        }
-        return initialValue;
-    }
-    /**
-     * Returns the number of matched items in the sequence
-     */
-    size() {
-        return this.reduce(((acc, _) => ++acc), 0);
-    }
-    [Symbol.iterator]() {
-        /* eslint-disable @typescript-eslint/no-unsafe-return */
-        return this;
-    }
-}
-exports.Iterator = Iterator;
 
+/***/ }),
+
+/***/ 9524:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var median_exports = {};
+__export(median_exports, {
+  $median: () => $median
+});
+module.exports = __toCommonJS(median_exports);
+var import_percentile = __webpack_require__(6393);
+const $median = (collection, expr, options) => (0, import_percentile.$percentile)(collection, { ...expr, p: [0.5] }, options).pop();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-/***/ }),
 
-/***/ 4414:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ }),
 
-"use strict";
+/***/ 8702:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Predicates used for Query and Expression operators.
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$type = exports.$elemMatch = exports.$size = exports.$all = exports.$exists = exports.$regex = exports.$mod = exports.$gte = exports.$gt = exports.$lte = exports.$lt = exports.$nin = exports.$in = exports.$ne = exports.$eq = exports.createExpressionOperator = exports.createQueryOperator = void 0;
-const core_1 = __webpack_require__(9587);
-const query_1 = __webpack_require__(809);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a query operator created from the predicate
- *
- * @param predicate Predicate function
- */
-function createQueryOperator(predicate) {
-    const f = (selector, value, options) => {
-        const opts = { unwrapArray: true };
-        const depth = Math.max(1, selector.split(".").length - 1);
-        return (obj) => {
-            // value of field must be fully resolved.
-            const lhs = (0, util_1.resolve)(obj, selector, opts);
-            return predicate(lhs, value, Object.assign(Object.assign({}, options), { depth }));
-        };
-    };
-    f.op = "query";
-    return f; // as QueryOperator;
-}
-exports.createQueryOperator = createQueryOperator;
-/**
- * Returns an expression operator created from the predicate
- *
- * @param predicate Predicate function
- */
-function createExpressionOperator(predicate) {
-    return (obj, expr, options) => {
-        const args = (0, core_1.computeValue)(obj, expr, null, options);
-        return predicate(...args);
-    };
-}
-exports.createExpressionOperator = createExpressionOperator;
-/**
- * Checks that two values are equal.
- *
- * @param a         The lhs operand as resolved from the object by the given selector
- * @param b         The rhs operand provided by the user
- * @returns {*}
- */
-function $eq(a, b, options) {
-    // start with simple equality check
-    if ((0, util_1.isEqual)(a, b))
-        return true;
-    // https://docs.mongodb.com/manual/tutorial/query-for-null-fields/
-    if ((0, util_1.isNil)(a) && (0, util_1.isNil)(b))
-        return true;
-    // check
-    if (a instanceof Array) {
-        const eq = util_1.isEqual.bind(null, b);
-        return a.some(eq) || (0, util_1.flatten)(a, options === null || options === void 0 ? void 0 : options.depth).some(eq);
-    }
-    return false;
-}
-exports.$eq = $eq;
-/**
- * Matches all values that are not equal to the value specified in the query.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $ne(a, b, options) {
-    return !$eq(a, b, options);
-}
-exports.$ne = $ne;
-/**
- * Matches any of the values that exist in an array specified in the query.
- *
- * @param a
- * @param b
- * @returns {*}
- */
-function $in(a, b, options) {
-    // queries for null should be able to find undefined fields
-    if ((0, util_1.isNil)(a))
-        return b.some(v => v === null);
-    return (0, util_1.intersection)([(0, util_1.ensureArray)(a), b], options === null || options === void 0 ? void 0 : options.hashFunction).length > 0;
-}
-exports.$in = $in;
-/**
- * Matches values that do not exist in an array specified to the query.
- *
- * @param a
- * @param b
- * @returns {*|boolean}
- */
-function $nin(a, b, options) {
-    return !$in(a, b, options);
-}
-exports.$nin = $nin;
-/**
- * Matches values that are less than the value specified in the query.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $lt(a, b, options) {
-    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) < 0);
-}
-exports.$lt = $lt;
-/**
- * Matches values that are less than or equal to the value specified in the query.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $lte(a, b, options) {
-    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) <= 0);
-}
-exports.$lte = $lte;
-/**
- * Matches values that are greater than the value specified in the query.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $gt(a, b, options) {
-    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) > 0);
-}
-exports.$gt = $gt;
-/**
- * Matches values that are greater than or equal to the value specified in the query.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $gte(a, b, options) {
-    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) >= 0);
-}
-exports.$gte = $gte;
-/**
- * Performs a modulo operation on the value of a field and selects documents with a specified result.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $mod(a, b, options) {
-    return (0, util_1.ensureArray)(a).some(((x) => b.length === 2 && x % b[0] === b[1]));
-}
-exports.$mod = $mod;
-/**
- * Selects documents where values match a specified regular expression.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $regex(a, b, options) {
-    const lhs = (0, util_1.ensureArray)(a);
-    const match = (x) => (0, util_1.isString)(x) && (0, util_1.truthy)(b.exec(x), options === null || options === void 0 ? void 0 : options.useStrictMode);
-    return lhs.some(match) || (0, util_1.flatten)(lhs, 1).some(match);
-}
-exports.$regex = $regex;
-/**
- * Matches documents that have the specified field.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $exists(a, b, options) {
-    return (((b === false || b === 0) && a === undefined) ||
-        ((b === true || b === 1) && a !== undefined));
-}
-exports.$exists = $exists;
-/**
- * Matches arrays that contain all elements specified in the query.
- *
- * @param values
- * @param queries
- * @returns boolean
- */
-function $all(values, queries, options) {
-    if (!(0, util_1.isArray)(values) ||
-        !(0, util_1.isArray)(queries) ||
-        !values.length ||
-        !queries.length) {
-        return false;
-    }
-    let matched = true;
-    for (const query of queries) {
-        // no need to check all the queries.
-        if (!matched)
-            break;
-        if ((0, util_1.isObject)(query) && (0, util_1.inArray)(Object.keys(query), "$elemMatch")) {
-            matched = $elemMatch(values, query["$elemMatch"], options);
-        }
-        else if (query instanceof RegExp) {
-            matched = values.some(s => typeof s === "string" && query.test(s));
-        }
-        else {
-            matched = values.some(v => (0, util_1.isEqual)(query, v));
-        }
-    }
-    return matched;
-}
-exports.$all = $all;
-/**
- * Selects documents if the array field is a specified size.
- *
- * @param a
- * @param b
- * @returns {*|boolean}
- */
-function $size(a, b, options) {
-    return Array.isArray(a) && a.length === b;
-}
-exports.$size = $size;
-function isNonBooleanOperator(name) {
-    return (0, util_1.isOperator)(name) && ["$and", "$or", "$nor"].indexOf(name) === -1;
-}
-/**
- * Selects documents if element in the array field matches all the specified $elemMatch condition.
- *
- * @param a {Array} element to match against
- * @param b {Object} subquery
- */
-function $elemMatch(a, b, options) {
-    // should return false for non-matching input
-    if ((0, util_1.isArray)(a) && !(0, util_1.isEmpty)(a)) {
-        let format = (x) => x;
-        let criteria = b;
-        // If we find a boolean operator in the subquery, we fake a field to point to it. This is an
-        // attempt to ensure that it is a valid criteria. We cannot make this substitution for operators
-        // like $and/$or/$nor; as otherwise, this faking will break our query.
-        if (Object.keys(b).every(isNonBooleanOperator)) {
-            criteria = { temp: b };
-            format = x => ({ temp: x });
-        }
-        const query = new query_1.Query(criteria, options);
-        for (let i = 0, len = a.length; i < len; i++) {
-            if (query.test(format(a[i]))) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-exports.$elemMatch = $elemMatch;
-// helper functions
-const isNull = (a) => a === null;
-const isInt = (a) => (0, util_1.isNumber)(a) &&
-    a >= util_1.MIN_INT &&
-    a <= util_1.MAX_INT &&
-    a.toString().indexOf(".") === -1;
-const isLong = (a) => (0, util_1.isNumber)(a) &&
-    a >= util_1.MIN_LONG &&
-    a <= util_1.MAX_LONG &&
-    a.toString().indexOf(".") === -1;
-/** Mapping of type to predicate */
-const compareFuncs = {
-    array: util_1.isArray,
-    bool: util_1.isBoolean,
-    boolean: util_1.isBoolean,
-    date: util_1.isDate,
-    decimal: util_1.isNumber,
-    double: util_1.isNumber,
-    int: isInt,
-    long: isLong,
-    number: util_1.isNumber,
-    null: isNull,
-    object: util_1.isObject,
-    regex: util_1.isRegExp,
-    regexp: util_1.isRegExp,
-    string: util_1.isString,
-    // added for completeness
-    undefined: util_1.isNil,
-    function: (_) => {
-        throw new Error("unsupported type key `function`.");
-    },
-    // Mongo identifiers
-    1: util_1.isNumber,
-    2: util_1.isString,
-    3: util_1.isObject,
-    4: util_1.isArray,
-    6: util_1.isNil,
-    8: util_1.isBoolean,
-    9: util_1.isDate,
-    10: isNull,
-    11: util_1.isRegExp,
-    16: isInt,
-    18: isLong,
-    19: util_1.isNumber //decimal
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Selects documents if a field is of the specified type.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function compareType(a, b, _) {
-    const f = compareFuncs[b];
-    return f ? f(a) : false;
-}
-/**
- * Selects documents if a field is of the specified type.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-function $type(a, b, options) {
-    return Array.isArray(b)
-        ? b.findIndex(t => compareType(a, t, options)) >= 0
-        : compareType(a, b, options);
-}
-exports.$type = $type;
-function compare(a, b, f) {
-    return (0, util_1.ensureArray)(a).some(x => (0, util_1.getType)(x) === (0, util_1.getType)(b) && f(x, b));
-}
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeObjects_exports = {};
+__export(mergeObjects_exports, {
+  $mergeObjects: () => $mergeObjects
+});
+module.exports = __toCommonJS(mergeObjects_exports);
+var import_core = __webpack_require__(2760);
+var import_mergeObjects = __webpack_require__(4420);
+const $mergeObjects = (collection, expr, options) => {
+  const arr = (0, import_core.computeValue)(collection, expr, null, options);
+  return (0, import_mergeObjects.$mergeObjects)(null, arr, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8680:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 2908:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.covariance = exports.stddev = void 0;
-/**
- * Compute the standard deviation of the data set
- * @param {Array} array of numbers
- * @param {Boolean} if true calculates a sample standard deviation, otherwise calculates a population stddev
- * @return {Number}
- */
-function stddev(data, sampled = true) {
-    const sum = data.reduce((acc, n) => acc + n, 0);
-    const N = data.length || 1;
-    const avg = sum / N;
-    return Math.sqrt(data.reduce((acc, n) => acc + Math.pow(n - avg, 2), 0) /
-        (N - Number(sampled)));
-}
-exports.stddev = stddev;
-function covariance(dataset, sampled = true) {
-    if (!dataset)
-        return null;
-    if (dataset.length < 2)
-        return sampled ? null : 0;
-    let meanX = 0.0;
-    let meanY = 0.0;
-    for (const [x, y] of dataset) {
-        meanX += x;
-        meanY += y;
-    }
-    meanX /= dataset.length;
-    meanY /= dataset.length;
-    let result = 0;
-    for (const [x, y] of dataset) {
-        result += (x - meanX) * (y - meanY);
-    }
-    return result / (dataset.length - Number(sampled));
-}
-exports.covariance = covariance;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var min_exports = {};
+__export(min_exports, {
+  $min: () => $min
+});
+module.exports = __toCommonJS(min_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $min = (collection, expr, options) => {
+  const items = (0, import_push.$push)(collection, expr, options);
+  if ((0, import_util.isEmpty)(items)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(items), "$min: input must resolve to array");
+  let min = items[0];
+  for (const n of items) {
+    if ((0, import_util.isNil)(n) || isNaN(n)) continue;
+    if ((0, import_util.compare)(n, min) <= 0) min = n;
+  }
+  return min;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9329:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 2184:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var minN_exports = {};
+__export(minN_exports, {
+  $minN: () => $minN
+});
+module.exports = __toCommonJS(minN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $minN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const m = collection.length;
+  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);
+  const arr = (0, import_push.$push)(collection, expr.input, options).filter((o) => !(0, import_util.isNil)(o));
+  arr.sort(import_util.compare);
+  return m <= n ? arr : arr.slice(0, n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-// Custom Aggregation Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#custom-aggregation-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$accumulator = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Defines a custom accumulator function.
- *
- * @param {Array} collection The input array
- * @param {*} expr The expression for the operator
- * @param {Options} options Options
- */
-const $accumulator = (collection, expr, options) => {
-    var _a;
-    (0, util_1.assert)(!!options && options.scriptEnabled, "$accumulator operator requires 'scriptEnabled' option to be true");
-    if (collection.length == 0)
-        return expr.initArgs;
-    const copts = core_1.ComputeOptions.init(options);
-    const initArgs = (0, core_1.computeValue)({}, expr.initArgs || [], null, copts.update(((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId) || {}));
-    let state = expr.init.call(null, ...initArgs);
-    for (const doc of collection) {
-        // get arguments for document
-        const args = (0, core_1.computeValue)(doc, expr.accumulateArgs, null, copts.update(doc));
-        // update the state with each documents value
-        // eslint-disable-next-line
-        state = expr.accumulate.call(null, ...[state, ...args]);
+
+/***/ }),
+
+/***/ 6393:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var percentile_exports = {};
+__export(percentile_exports, {
+  $percentile: () => $percentile
+});
+module.exports = __toCommonJS(percentile_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $percentile = (collection, expr, options) => {
+  const X = (0, import_push.$push)(collection, expr.input, options).filter(import_util.isNumber).sort();
+  const centiles = (0, import_push.$push)(expr.p, "$$CURRENT", options).filter(import_util.isNumber);
+  const method = expr.method || "approximate";
+  return centiles.map((p) => {
+    (0, import_util.assert)(
+      p > 0 && p <= 1,
+      `percentile value must be between 0 (exclusive) and 1 (inclusive): invalid '${p}'.`
+    );
+    const r = p * (X.length - 1) + 1;
+    const ri = Math.floor(r);
+    const result = r === ri ? X[r - 1] : X[ri - 1] + r % 1 * (X[ri] - X[ri - 1] || 0);
+    switch (method) {
+      case "exact":
+        return result;
+      case "approximate": {
+        const i = (0, import_util.findInsertIndex)(X, result);
+        return i / X.length >= p ? X[Math.max(i - 1, 0)] : X[i];
+      }
     }
-    return (expr.finalize ? expr.finalize.call(null, state) : state);
+  });
 };
-exports.$accumulator = $accumulator;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8911:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 4518:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var push_exports = {};
+__export(push_exports, {
+  $push: () => $push
+});
+module.exports = __toCommonJS(push_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $push = (collection, expr, options) => {
+  if ((0, import_util.isNil)(expr)) return collection;
+  const copts = import_core.ComputeOptions.init(options);
+  return collection.map(
+    (obj) => (0, import_core.computeValue)(obj, expr, null, copts.update(obj))
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$addToSet = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an array of all the unique values for the selected field among for each document in that group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $addToSet = (collection, expr, options) => {
-    return (0, util_1.unique)((0, push_1.$push)(collection, expr, options), options === null || options === void 0 ? void 0 : options.hashFunction);
+
+/***/ }),
+
+/***/ 1779:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$addToSet = $addToSet;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdDevPop_exports = {};
+__export(stdDevPop_exports, {
+  $stdDevPop: () => $stdDevPop
+});
+module.exports = __toCommonJS(stdDevPop_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(1424);
+var import_push = __webpack_require__(4518);
+const $stdDevPop = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), false);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9891:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 9388:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdDevSamp_exports = {};
+__export(stdDevSamp_exports, {
+  $stdDevSamp: () => $stdDevSamp
+});
+module.exports = __toCommonJS(stdDevSamp_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(1424);
+var import_push = __webpack_require__(4518);
+const $stdDevSamp = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$avg = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an average of all the values in a group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {Number}
- */
-const $avg = (collection, expr, options) => {
-    const data = (0, push_1.$push)(collection, expr, options).filter(util_1.isNumber);
-    const sum = data.reduce((acc, n) => acc + n, 0);
-    return sum / (data.length || 1);
+
+/***/ }),
+
+/***/ 3295:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$avg = $avg;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sum_exports = {};
+__export(sum_exports, {
+  $sum: () => $sum
+});
+module.exports = __toCommonJS(sum_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+const $sum = (collection, expr, options) => {
+  if (!(0, import_util.isArray)(collection)) return 0;
+  if ((0, import_util.isNumber)(expr)) return collection.length * expr;
+  const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);
+  return nums.reduce((acc, n) => acc + n, 0);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8474:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 7995:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var top_exports = {};
+__export(top_exports, {
+  $top: () => $top
+});
+module.exports = __toCommonJS(top_exports);
+var import_topN = __webpack_require__(1977);
+const $top = (collection, expr, options) => (0, import_topN.$topN)(collection, { ...expr, n: 1 }, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bottom = void 0;
-const bottomN_1 = __webpack_require__(2102);
-/**
- * Returns the bottom element within a group according to the specified sort order.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $bottom = (collection, expr, options) => (0, bottomN_1.$bottomN)(collection, Object.assign(Object.assign({}, expr), { n: 1 }), options);
-exports.$bottom = $bottom;
+
+/***/ }),
+
+/***/ 1977:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var topN_exports = {};
+__export(topN_exports, {
+  $topN: () => $topN
+});
+module.exports = __toCommonJS(topN_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+var import_push = __webpack_require__(4518);
+const $topN = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const { n, sortBy } = (0, import_core.computeValue)(
+    copts.local.groupId,
+    expr,
+    null,
+    copts
+  );
+  const result = new import_aggregator.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(
+    collection
+  );
+  return (0, import_push.$push)(result, expr.output, copts);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2102:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6405:
+/***/ ((module) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bottomN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottomN/#mongodb-group-grp.-bottomN
-const aggregator_1 = __webpack_require__(7268);
-const core_1 = __webpack_require__(9587);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the bottom n elements within a group, according to the specified sort order.
- * If the group contains fewer than n elements, $bottomN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $bottomN = (collection, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    const { n, sortBy } = (0, core_1.computeValue)(copts.local.groupId, expr, null, copts);
-    const result = new aggregator_1.Aggregator([{ $sort: sortBy }], copts).run(collection);
-    const m = result.length;
-    const p = n;
-    return (0, push_1.$push)(m <= p ? result : result.slice(m - p), expr.output, copts);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$bottomN = $bottomN;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  truncate: () => truncate
+});
+module.exports = __toCommonJS(internal_exports);
+function truncate(num, places = 0, roundOff = false) {
+  const sign = Math.abs(num) === num ? 1 : -1;
+  num = Math.abs(num);
+  let result = Math.trunc(num);
+  const decimals = parseFloat((num - result).toFixed(places + 1));
+  if (places === 0) {
+    const firstDigit = Math.trunc(10 * decimals);
+    if (roundOff && ((result & 1) === 1 && firstDigit >= 5 || firstDigit > 5)) {
+      result++;
+    }
+  } else if (places > 0) {
+    const offset = Math.pow(10, places);
+    let remainder = Math.trunc(decimals * offset);
+    const lastDigit = Math.trunc(decimals * offset * 10) % 10;
+    if (roundOff && lastDigit > 5) {
+      remainder += 1;
+    }
+    result = (result * offset + remainder) / offset;
+  } else if (places < 0) {
+    const offset = Math.pow(10, -1 * places);
+    let excess = result % offset;
+    result = Math.max(0, result - excess);
+    if (roundOff && sign === -1) {
+      while (excess > 10) {
+        excess -= excess % 10;
+      }
+      if (result > 0 && excess >= 5) {
+        result += offset;
+      }
+    }
+  }
+  return result * sign;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1514:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 9133:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$count = void 0;
-/**
- * Returns the number of documents in the group or window.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @returns {*}
- */
-const $count = (collection, _expr, _options) => collection.length;
-exports.$count = $count;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var abs_exports = {};
+__export(abs_exports, {
+  $abs: () => $abs
+});
+module.exports = __toCommonJS(abs_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $abs = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isNil)(n) ? null : Math.abs(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7212:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9566:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$covariancePop = void 0;
-const _internal_1 = __webpack_require__(8680);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the population covariance of two numeric expressions.
- * @param  {Array} collection
- * @param  {Object} expr
- * @return {Number|null}
- */
-const $covariancePop = (collection, expr, options) => (0, _internal_1.covariance)((0, push_1.$push)(collection, expr, options), false);
-exports.$covariancePop = $covariancePop;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var add_exports = {};
+__export(add_exports, {
+  $add: () => $add
+});
+module.exports = __toCommonJS(add_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $add = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  let hasDate = false;
+  let sum = 0;
+  for (const n of args) {
+    if ((0, import_util.isDate)(n)) {
+      (0, import_util.assert)(!hasDate, "'$add' can only have one date value");
+      hasDate = true;
+    }
+    sum += +n;
+  }
+  return hasDate ? new Date(sum) : sum;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1662:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7888:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$covarianceSamp = void 0;
-const _internal_1 = __webpack_require__(8680);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the sample covariance of two numeric expressions.
- * @param  {Array} collection
- * @param  {Object} expr
- * @return {Number|null}
- */
-const $covarianceSamp = (collection, expr, options) => (0, _internal_1.covariance)((0, push_1.$push)(collection, expr, options), true);
-exports.$covarianceSamp = $covarianceSamp;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ceil_exports = {};
+__export(ceil_exports, {
+  $ceil: () => $ceil
+});
+module.exports = __toCommonJS(ceil_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $ceil = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$ceil expression must resolve to a number.");
+  return Math.ceil(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2452:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4424:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$first = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Returns the first value in a group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @returns {*}
- */
-const $first = (collection, expr, options) => {
-    return collection.length > 0
-        ? (0, core_1.computeValue)(collection[0], expr, null, options)
-        : undefined;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var divide_exports = {};
+__export(divide_exports, {
+  $divide: () => $divide
+});
+module.exports = __toCommonJS(divide_exports);
+var import_core = __webpack_require__(2760);
+const $divide = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args[0] / args[1];
 };
-exports.$first = $first;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3445:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9490:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$firstN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN/
-const core_1 = __webpack_require__(9587);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the first n elements within a group. The elements returned are meaningful only if in a specified sort order.
- * If the group contains fewer than n elements, $firstN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $firstN = (collection, expr, options) => {
-    var _a;
-    const copts = core_1.ComputeOptions.init(options);
-    const m = collection.length;
-    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);
-    return (0, push_1.$push)(m <= n ? collection : collection.slice(0, n), expr.input, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exp_exports = {};
+__export(exp_exports, {
+  $exp: () => $exp
+});
+module.exports = __toCommonJS(exp_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $exp = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$exp expression must resolve to a number.");
+  return Math.exp(n);
 };
-exports.$firstN = $firstN;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3424:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 2175:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Group stage Accumulator Operators. https://docs.mongodb.com/manual/reference/operator/aggregation-
- */
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9329), exports);
-__exportStar(__webpack_require__(8911), exports);
-__exportStar(__webpack_require__(9891), exports);
-__exportStar(__webpack_require__(8474), exports);
-__exportStar(__webpack_require__(2102), exports);
-__exportStar(__webpack_require__(1514), exports);
-__exportStar(__webpack_require__(7212), exports);
-__exportStar(__webpack_require__(1662), exports);
-__exportStar(__webpack_require__(2452), exports);
-__exportStar(__webpack_require__(3445), exports);
-__exportStar(__webpack_require__(5026), exports);
-__exportStar(__webpack_require__(9799), exports);
-__exportStar(__webpack_require__(7133), exports);
-__exportStar(__webpack_require__(8542), exports);
-__exportStar(__webpack_require__(4785), exports);
-__exportStar(__webpack_require__(5613), exports);
-__exportStar(__webpack_require__(3946), exports);
-__exportStar(__webpack_require__(7835), exports);
-__exportStar(__webpack_require__(2257), exports);
-__exportStar(__webpack_require__(4393), exports);
-__exportStar(__webpack_require__(7970), exports);
-__exportStar(__webpack_require__(1382), exports);
-__exportStar(__webpack_require__(7097), exports);
-
-
-/***/ }),
-
-/***/ 5026:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$last = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Returns the last value in the collection.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $last = (collection, expr, options) => {
-    return collection.length > 0
-        ? (0, core_1.computeValue)(collection[collection.length - 1], expr, null, options)
-        : undefined;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var floor_exports = {};
+__export(floor_exports, {
+  $floor: () => $floor
+});
+module.exports = __toCommonJS(floor_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $floor = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isNumber)(n) || isNaN(n),
+    "$floor expression must resolve to a number."
+  );
+  return Math.floor(n);
 };
-exports.$last = $last;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9799:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 4125:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arithmetic_exports = {};
+module.exports = __toCommonJS(arithmetic_exports);
+__reExport(arithmetic_exports, __webpack_require__(9133), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(9566), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(7888), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(4424), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(9490), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(2175), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(3023), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(5571), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(7462), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(7229), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(353), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(9319), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(5057), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(6451), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(8413), module.exports);
+__reExport(arithmetic_exports, __webpack_require__(731), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 3023:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lastN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN/
-const core_1 = __webpack_require__(9587);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the last n elements within a group. The elements returned are meaningful only if in a specified sort order.
- * If the group contains fewer than n elements, $lastN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $lastN = (collection, expr, options) => {
-    var _a;
-    const copts = core_1.ComputeOptions.init(options);
-    const m = collection.length;
-    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);
-    return (0, push_1.$push)(m <= n ? collection : collection.slice(m - n), expr.input, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ln_exports = {};
+__export(ln_exports, {
+  $ln: () => $ln
+});
+module.exports = __toCommonJS(ln_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $ln = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), "$ln expression must resolve to a number.");
+  return Math.log(n);
 };
-exports.$lastN = $lastN;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7133:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5571:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$max = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the highest value in a group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $max = (collection, expr, options) => {
-    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNotNaN);
-    const n = nums.reduce((acc, n) => ((0, util_1.compare)(n, acc) >= 0 ? n : acc), -Infinity);
-    return n === -Infinity ? undefined : n;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$max = $max;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  $log: () => $log
+});
+module.exports = __toCommonJS(log_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $log = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const msg = "$log expression must resolve to array(2) of numbers";
+  (0, import_util.assert)((0, import_util.isArray)(args) && args.length === 2, msg);
+  if (args.some(import_util.isNil)) return null;
+  (0, import_util.assert)(args.some(isNaN) || args.every(import_util.isNumber), msg);
+  return Math.log10(args[0]) / Math.log10(args[1]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8542:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7462:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$maxN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the maxmimum value n elements within a group.
- * If the group contains fewer than n elements, $maxN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $maxN = (collection, expr, options) => {
-    var _a;
-    const copts = core_1.ComputeOptions.init(options);
-    const m = collection.length;
-    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);
-    const arr = (0, push_1.$push)(collection, expr.input, options).filter(o => !(0, util_1.isNil)(o));
-    arr.sort((a, b) => -1 * (0, util_1.compare)(a, b));
-    return m <= n ? arr : arr.slice(0, n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$maxN = $maxN;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log10_exports = {};
+__export(log10_exports, {
+  $log10: () => $log10
+});
+module.exports = __toCommonJS(log10_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $log10 = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isNumber)(n) || isNaN(n),
+    "$log10 expression must resolve to a number."
+  );
+  return Math.log10(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4785:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7229:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$mergeObjects = void 0;
-const mergeObjects_1 = __webpack_require__(9531);
-/**
- * Combines multiple documents into a single document.
- *
- * @param {Array} collection The input array
- * @param {Object} _ The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {Array|*}
- */
-const $mergeObjects = (collection, _, options) => (0, mergeObjects_1.$mergeObjects)({ docs: collection }, "$docs", options);
-exports.$mergeObjects = $mergeObjects;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mod_exports = {};
+__export(mod_exports, {
+  $mod: () => $mod
+});
+module.exports = __toCommonJS(mod_exports);
+var import_core = __webpack_require__(2760);
+const $mod = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args[0] % args[1];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5613:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 353:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$min = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the lowest value in a group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} The options to use for this operator
- * @returns {*}
- */
-const $min = (collection, expr, options) => {
-    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNotNaN);
-    const n = nums.reduce((acc, n) => ((0, util_1.compare)(n, acc) <= 0 ? n : acc), Infinity);
-    return n === Infinity ? undefined : n;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var multiply_exports = {};
+__export(multiply_exports, {
+  $multiply: () => $multiply
+});
+module.exports = __toCommonJS(multiply_exports);
+var import_core = __webpack_require__(2760);
+const $multiply = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args.reduce((acc, num) => acc * num, 1);
 };
-exports.$min = $min;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3946:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 9319:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pow_exports = {};
+__export(pow_exports, {
+  $pow: () => $pow
+});
+module.exports = __toCommonJS(pow_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $pow = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.length === 2 && args.every(import_util.isNumber),
+    "$pow expression must resolve to array(2) of numbers"
+  );
+  (0, import_util.assert)(
+    !(args[0] === 0 && args[1] < 0),
+    "$pow cannot raise 0 to a negative exponent"
+  );
+  return Math.pow(args[0], args[1]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$minN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the minimum value n elements within a group.
- * If the group contains fewer than n elements, $minN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $minN = (collection, expr, options) => {
-    var _a;
-    const copts = core_1.ComputeOptions.init(options);
-    const m = collection.length;
-    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);
-    const arr = (0, push_1.$push)(collection, expr.input, options).filter(o => !(0, util_1.isNil)(o));
-    arr.sort(util_1.compare);
-    return m <= n ? arr : arr.slice(0, n);
+
+/***/ }),
+
+/***/ 5057:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$minN = $minN;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var round_exports = {};
+__export(round_exports, {
+  $round: () => $round
+});
+module.exports = __toCommonJS(round_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(6405);
+const $round = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const num = args[0];
+  const place = args[1];
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
+  (0, import_util.assert)((0, import_util.isNumber)(num), "$round expression must resolve to a number.");
+  return (0, import_internal.truncate)(num, place, true);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7835:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 6451:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sqrt_exports = {};
+__export(sqrt_exports, {
+  $sqrt: () => $sqrt
+});
+module.exports = __toCommonJS(sqrt_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $sqrt = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isNumber)(n) && n > 0 || isNaN(n),
+    "$sqrt expression must resolve to non-negative number."
+  );
+  return Math.sqrt(n);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$push = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns an array of all values for the selected field among for each document in that group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {Array|*}
- */
-const $push = (collection, expr, options) => {
-    if ((0, util_1.isNil)(expr))
-        return collection;
-    const copts = core_1.ComputeOptions.init(options);
-    return collection.map(obj => (0, core_1.computeValue)(obj, expr, null, copts.update(obj)));
+
+/***/ }),
+
+/***/ 8413:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subtract_exports = {};
+__export(subtract_exports, {
+  $subtract: () => $subtract
+});
+module.exports = __toCommonJS(subtract_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $subtract = (obj, expr, options) => {
+  const [a, b] = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNumber)(a) && (0, import_util.isNumber)(b) || (0, import_util.isDate)(a) && (0, import_util.isDate)(b)) return +a - +b;
+  if ((0, import_util.isDate)(a) && (0, import_util.isNumber)(b)) return new Date(+a - b);
+  (0, import_util.assert)(false, "$subtract: must resolve to number/date.");
 };
-exports.$push = $push;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2257:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 731:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$stdDevPop = void 0;
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(8680);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the population standard deviation of the input values.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @return {Number}
- */
-const $stdDevPop = (collection, expr, options) => (0, _internal_1.stddev)((0, push_1.$push)(collection, expr, options).filter(util_1.isNumber), false);
-exports.$stdDevPop = $stdDevPop;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trunc_exports = {};
+__export(trunc_exports, {
+  $trunc: () => $trunc
+});
+module.exports = __toCommonJS(trunc_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(6405);
+const $trunc = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  const num = arr[0];
+  const places = arr[1];
+  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
+  (0, import_util.assert)((0, import_util.isNumber)(num), "$trunc expression must resolve to a number.");
+  (0, import_util.assert)(
+    (0, import_util.isNil)(places) || (0, import_util.isNumber)(places) && places > -20 && places < 100,
+    "$trunc expression has invalid place"
+  );
+  return (0, import_internal.truncate)(num, places, false);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4393:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3261:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$stdDevSamp = void 0;
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(8680);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the sample standard deviation of the input values.
- * @param  {Array} collection
- * @param  {Object} expr
- * @return {Number|null}
- */
-const $stdDevSamp = (collection, expr, options) => (0, _internal_1.stddev)((0, push_1.$push)(collection, expr, options).filter(util_1.isNumber), true);
-exports.$stdDevSamp = $stdDevSamp;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arrayElemAt_exports = {};
+__export(arrayElemAt_exports, {
+  $arrayElemAt: () => $arrayElemAt
+});
+module.exports = __toCommonJS(arrayElemAt_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $arrayElemAt = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.length === 2,
+    "$arrayElemAt expression must resolve to array(2)"
+  );
+  if (args.some(import_util.isNil)) return null;
+  const index = args[1];
+  const arr = args[0];
+  if (index < 0 && Math.abs(index) <= arr.length) {
+    return arr[(index + arr.length) % arr.length];
+  } else if (index >= 0 && index < arr.length) {
+    return arr[index];
+  }
+  return void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7970:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3285:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sum = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns the sum of all the values in a group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @returns {Number}
- */
-const $sum = (collection, expr, options) => {
-    if (!(0, util_1.isArray)(collection))
-        return 0;
-    // take a short cut if expr is number literal
-    if ((0, util_1.isNumber)(expr))
-        return collection.length * expr;
-    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNumber);
-    return nums.reduce((acc, n) => acc + n, 0);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arrayToObject_exports = {};
+__export(arrayToObject_exports, {
+  $arrayToObject: () => $arrayToObject
+});
+module.exports = __toCommonJS(arrayToObject_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $arrayToObject = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$arrayToObject: expression must resolve to an array");
+  return arr.reduce((newObj, val) => {
+    while ((0, import_util.isArray)(val) && val.length === 1) val = val[0];
+    if ((0, import_util.isArray)(val) && val.length == 2) {
+      newObj[val[0]] = val[1];
+    } else {
+      const valObj = val;
+      (0, import_util.assert)(
+        (0, import_util.isObject)(valObj) && (0, import_util.has)(valObj, "k") && (0, import_util.has)(valObj, "v"),
+        "$arrayToObject expression is invalid."
+      );
+      newObj[valObj.k] = valObj.v;
+    }
+    return newObj;
+  }, {});
 };
-exports.$sum = $sum;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1382:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8590:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$top = void 0;
-const topN_1 = __webpack_require__(7097);
-/**
- * Returns the top element within a group according to the specified sort order.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $top = (collection, expr, options) => (0, topN_1.$topN)(collection, Object.assign(Object.assign({}, expr), { n: 1 }), options);
-exports.$top = $top;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var concatArrays_exports = {};
+__export(concatArrays_exports, {
+  $concatArrays: () => $concatArrays
+});
+module.exports = __toCommonJS(concatArrays_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $concatArrays = (obj, expr, options) => {
+  const nArray = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(nArray), "$concatArrays: input must resolve to an array");
+  let size = 0;
+  for (const arr of nArray) {
+    if ((0, import_util.isNil)(arr)) return null;
+    size += arr.length;
+  }
+  const result = new Array(size);
+  let i = 0;
+  for (const arr of nArray) for (const item of arr) result[i++] = item;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7097:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8106:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$topN = void 0;
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/topN/#mongodb-group-grp.-topN
-const aggregator_1 = __webpack_require__(7268);
-const core_1 = __webpack_require__(9587);
-const push_1 = __webpack_require__(7835);
-/**
- * Returns an aggregation of the top n elements within a group, according to the specified sort order.
- * If the group contains fewer than n elements, $topN returns all elements in the group.
- *
- * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
- * @param {Options} options The options to use for this operation
- * @returns {*}
- */
-const $topN = (collection, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    const { n, sortBy } = (0, core_1.computeValue)(copts.local.groupId, expr, null, copts);
-    const result = new aggregator_1.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(collection);
-    return (0, push_1.$push)(result, expr.output, copts);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filter_exports = {};
+__export(filter_exports, {
+  $filter: () => $filter
+});
+module.exports = __toCommonJS(filter_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $filter = (obj, expr, options) => {
+  const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "$filter 'input' expression must resolve to an array");
+  const copts = import_core.ComputeOptions.init(options, obj);
+  const k = expr.as || "this";
+  const local = {
+    variables: { [k]: null }
+  };
+  return input.filter((o) => {
+    local.variables[k] = o;
+    const b = (0, import_core.computeValue)(
+      obj,
+      expr.cond,
+      null,
+      copts.update(copts.root, local)
+    );
+    return (0, import_util.truthy)(b, options.useStrictMode);
+  });
 };
-exports.$topN = $topN;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6026:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 6976:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.truncate = void 0;
-/**
- * Truncates integer value to number of places. If roundOff is specified round value instead to the number of places
- * @param {Number} num
- * @param {Number} places
- * @param {Boolean} roundOff
- */
-function truncate(num, places, roundOff) {
-    const sign = Math.abs(num) === num ? 1 : -1;
-    num = Math.abs(num);
-    let result = Math.trunc(num);
-    const decimals = parseFloat((num - result).toFixed(places + 1));
-    if (places === 0) {
-        const firstDigit = Math.trunc(10 * decimals);
-        if (roundOff &&
-            (((result & 1) === 1 && firstDigit >= 5) || firstDigit > 5)) {
-            result++;
-        }
-    }
-    else if (places > 0) {
-        const offset = Math.pow(10, places);
-        let remainder = Math.trunc(decimals * offset);
-        // last digit before cut off
-        const lastDigit = Math.trunc(decimals * offset * 10) % 10;
-        // add one if last digit is greater than 5
-        if (roundOff && lastDigit > 5) {
-            remainder += 1;
-        }
-        // compute decimal remainder and add to whole number
-        // manually formatting float re
-        result = (result * offset + remainder) / offset;
-    }
-    else if (places < 0) {
-        // handle negative decimal places
-        const offset = Math.pow(10, -1 * places);
-        let excess = result % offset;
-        result = Math.max(0, result - excess);
-        // for negative values the absolute must increase so we round up the last digit if >= 5
-        if (roundOff && sign === -1) {
-            while (excess > 10) {
-                excess -= excess % 10;
-            }
-            if (result > 0 && excess >= 5) {
-                result += offset;
-            }
-        }
-    }
-    return result * sign;
-}
-exports.truncate = truncate;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var first_exports = {};
+__export(first_exports, {
+  $first: () => $first
+});
+module.exports = __toCommonJS(first_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_first = __webpack_require__(1058);
+const $first = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_first.$first)(obj, expr, options);
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(arr) && arr.length > 0,
+    "$first must resolve to a non-empty array."
+  );
+  return (0, import_util.flatten)(arr)[0];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2062:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2412:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$abs = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the absolute value of a number.
- *
- * @param obj
- * @param expr
- * @return {Number|null|NaN}
- */
-const $abs = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.isNil)(n) ? null : Math.abs(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var firstN_exports = {};
+__export(firstN_exports, {
+  $firstN: () => $firstN
+});
+module.exports = __toCommonJS(firstN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_firstN = __webpack_require__(6550);
+const $firstN = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_firstN.$firstN)(obj, expr, options);
+  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
+  return (0, import_firstN.$firstN)(input, { n, input: "$$this" }, options);
 };
-exports.$abs = $abs;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7254:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9067:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$add = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Computes the sum of an array of numbers.
- *
- * @param obj
- * @param expr
- * @returns {Object}
- */
-const $add = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    let foundDate = false;
-    const result = args.reduce((acc, val) => {
-        if ((0, util_1.isDate)(val)) {
-            (0, util_1.assert)(!foundDate, "'$add' can only have one date value");
-            foundDate = true;
-            val = val.getTime();
-        }
-        // assume val is a number
-        acc += val;
-        return acc;
-    }, 0);
-    return foundDate ? new Date(result) : result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var in_exports = {};
+__export(in_exports, {
+  $in: () => $in
+});
+module.exports = __toCommonJS(in_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $in = (obj, expr, options) => {
+  const [item, arr] = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$in second argument must be an array");
+  return arr.some((v) => (0, import_util.isEqual)(v, item));
 };
-exports.$add = $add;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4489:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 2846:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var array_exports = {};
+module.exports = __toCommonJS(array_exports);
+__reExport(array_exports, __webpack_require__(3261), module.exports);
+__reExport(array_exports, __webpack_require__(3285), module.exports);
+__reExport(array_exports, __webpack_require__(8590), module.exports);
+__reExport(array_exports, __webpack_require__(8106), module.exports);
+__reExport(array_exports, __webpack_require__(6976), module.exports);
+__reExport(array_exports, __webpack_require__(2412), module.exports);
+__reExport(array_exports, __webpack_require__(9067), module.exports);
+__reExport(array_exports, __webpack_require__(5910), module.exports);
+__reExport(array_exports, __webpack_require__(3239), module.exports);
+__reExport(array_exports, __webpack_require__(6788), module.exports);
+__reExport(array_exports, __webpack_require__(2080), module.exports);
+__reExport(array_exports, __webpack_require__(2836), module.exports);
+__reExport(array_exports, __webpack_require__(8952), module.exports);
+__reExport(array_exports, __webpack_require__(7110), module.exports);
+__reExport(array_exports, __webpack_require__(5676), module.exports);
+__reExport(array_exports, __webpack_require__(1603), module.exports);
+__reExport(array_exports, __webpack_require__(2866), module.exports);
+__reExport(array_exports, __webpack_require__(7607), module.exports);
+__reExport(array_exports, __webpack_require__(2881), module.exports);
+__reExport(array_exports, __webpack_require__(7292), module.exports);
+__reExport(array_exports, __webpack_require__(1931), module.exports);
+__reExport(array_exports, __webpack_require__(4657), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 5910:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ceil = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the smallest integer greater than or equal to the specified number.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $ceil = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), "$ceil expression must resolve to a number.");
-    return Math.ceil(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var indexOfArray_exports = {};
+__export(indexOfArray_exports, {
+  $indexOfArray: () => $indexOfArray
+});
+module.exports = __toCommonJS(indexOfArray_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $indexOfArray = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args)) return null;
+  let arr = args[0];
+  const searchValue = args[1];
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$indexOfArray expression must resolve to an array.");
+  const start = args[2] || 0;
+  let end = args[3];
+  if ((0, import_util.isNil)(end)) end = arr.length;
+  if (start > end) return -1;
+  (0, import_util.assert)(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
+  if (start > 0 || end < arr.length) {
+    arr = arr.slice(start, end);
+  }
+  let index = -1;
+  arr.some((v, i) => {
+    const b = (0, import_util.isEqual)(v, searchValue);
+    if (b) index = i;
+    return b;
+  });
+  return index + start;
 };
-exports.$ceil = $ceil;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4203:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3239:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$divide = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Takes two numbers and divides the first number by the second.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $divide = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args[0] / args[1];
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$divide = $divide;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isArray_exports = {};
+__export(isArray_exports, {
+  $isArray: () => $isArray
+});
+module.exports = __toCommonJS(isArray_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $isArray = (obj, expr, options) => (0, import_util.isArray)((0, import_core.computeValue)(obj, expr[0], null, options));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8216:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6788:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$exp = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Raises Euler’s number (i.e. e ) to the specified exponent and returns the result.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $exp = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), "$exp expression must resolve to a number.");
-    return Math.exp(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$exp = $exp;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var last_exports = {};
+__export(last_exports, {
+  $last: () => $last
+});
+module.exports = __toCommonJS(last_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_last = __webpack_require__(9666);
+const $last = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_last.$last)(obj, expr, options);
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(arr) && arr.length > 0,
+    "$last must resolve to a non-empty array."
+  );
+  return (0, import_util.flatten)(arr)[arr.length - 1];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7827:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2080:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$floor = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the largest integer less than or equal to the specified number.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $floor = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), "$floor expression must resolve to a number.");
-    return Math.floor(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$floor = $floor;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lastN_exports = {};
+__export(lastN_exports, {
+  $lastN: () => $lastN
+});
+module.exports = __toCommonJS(lastN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_lastN = __webpack_require__(3830);
+const $lastN = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_lastN.$lastN)(obj, expr, options);
+  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
+  return (0, import_lastN.$lastN)(input, { n, input: "$$this" }, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1744:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 2836:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(2062), exports);
-__exportStar(__webpack_require__(7254), exports);
-__exportStar(__webpack_require__(4489), exports);
-__exportStar(__webpack_require__(4203), exports);
-__exportStar(__webpack_require__(8216), exports);
-__exportStar(__webpack_require__(7827), exports);
-__exportStar(__webpack_require__(1424), exports);
-__exportStar(__webpack_require__(368), exports);
-__exportStar(__webpack_require__(7654), exports);
-__exportStar(__webpack_require__(5971), exports);
-__exportStar(__webpack_require__(4325), exports);
-__exportStar(__webpack_require__(8519), exports);
-__exportStar(__webpack_require__(2151), exports);
-__exportStar(__webpack_require__(7625), exports);
-__exportStar(__webpack_require__(7709), exports);
-__exportStar(__webpack_require__(8736), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var map_exports = {};
+__export(map_exports, {
+  $map: () => $map
+});
+module.exports = __toCommonJS(map_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $map = (obj, expr, options) => {
+  const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), `$map 'input' expression must resolve to an array`);
+  const copts = import_core.ComputeOptions.init(options);
+  const k = expr.as || "this";
+  return input.map((o) => {
+    return (0, import_core.computeValue)(
+      obj,
+      expr.in,
+      null,
+      copts.update(copts.root, {
+        variables: { [k]: o }
+      })
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1424:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8952:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ln = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Calculates the natural logarithm ln (i.e loge) of a number and returns the result as a double.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $ln = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), "$ln expression must resolve to a number.");
-    return Math.log(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var maxN_exports = {};
+__export(maxN_exports, {
+  $maxN: () => $maxN
+});
+module.exports = __toCommonJS(maxN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_maxN = __webpack_require__(6870);
+const $maxN = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_maxN.$maxN)(obj, expr, options);
+  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
+  return (0, import_maxN.$maxN)(input, { n, input: "$$this" }, options);
 };
-exports.$ln = $ln;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 368:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7110:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$log = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Calculates the log of a number in the specified base and returns the result as a double.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $log = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const msg = "$log expression must resolve to array(2) of numbers";
-    (0, util_1.assert)((0, util_1.isArray)(args) && args.length === 2, msg);
-    if (args.some(util_1.isNil))
-        return null;
-    (0, util_1.assert)(args.some(isNaN) || args.every(util_1.isNumber), msg);
-    return Math.log10(args[0]) / Math.log10(args[1]);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var minN_exports = {};
+__export(minN_exports, {
+  $minN: () => $minN
+});
+module.exports = __toCommonJS(minN_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_minN = __webpack_require__(2184);
+const $minN = (obj, expr, options) => {
+  if ((0, import_util.isArray)(obj)) return (0, import_minN.$minN)(obj, expr, options);
+  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
+  return (0, import_minN.$minN)(input, { n, input: "$$this" }, options);
 };
-exports.$log = $log;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7654:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5676:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$log10 = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Calculates the log base 10 of a number and returns the result as a double.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $log10 = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), "$log10 expression must resolve to a number.");
-    return Math.log10(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$log10 = $log10;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nin_exports = {};
+__export(nin_exports, {
+  $nin: () => $nin
+});
+module.exports = __toCommonJS(nin_exports);
+var import_predicates = __webpack_require__(4330);
+const $nin = (0, import_predicates.createExpressionOperator)(import_predicates.$nin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5971:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1603:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$mod = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Takes two numbers and calculates the modulo of the first number divided by the second.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $mod = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args[0] % args[1];
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var range_exports = {};
+__export(range_exports, {
+  $range: () => $range
+});
+module.exports = __toCommonJS(range_exports);
+var import_core = __webpack_require__(2760);
+const $range = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  const start = arr[0];
+  const end = arr[1];
+  const step = arr[2] || 1;
+  const result = new Array();
+  let counter = start;
+  while (counter < end && step > 0 || counter > end && step < 0) {
+    result.push(counter);
+    counter += step;
+  }
+  return result;
 };
-exports.$mod = $mod;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4325:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2866:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$multiply = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Computes the product of an array of numbers.
- *
- * @param obj
- * @param expr
- * @returns {Object}
- */
-const $multiply = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args.reduce((acc, num) => acc * num, 1);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$multiply = $multiply;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reduce_exports = {};
+__export(reduce_exports, {
+  $reduce: () => $reduce
+});
+module.exports = __toCommonJS(reduce_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $reduce = (obj, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  const input = (0, import_core.computeValue)(obj, expr.input, null, copts);
+  const initialValue = (0, import_core.computeValue)(obj, expr.initialValue, null, copts);
+  const inExpr = expr["in"];
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "$reduce 'input' expression must resolve to an array");
+  return input.reduce((acc, n) => {
+    return (0, import_core.computeValue)(
+      n,
+      inExpr,
+      null,
+      copts.update(copts.root, {
+        variables: { value: acc }
+      })
+    );
+  }, initialValue);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8519:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7607:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$pow = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Raises a number to the specified exponent and returns the result.
- *
- * @param obj
- * @param expr
- * @returns {Object}
- */
-const $pow = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(args) && args.length === 2 && args.every(util_1.isNumber), "$pow expression must resolve to array(2) of numbers");
-    (0, util_1.assert)(!(args[0] === 0 && args[1] < 0), "$pow cannot raise 0 to a negative exponent");
-    return Math.pow(args[0], args[1]);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$pow = $pow;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reverseArray_exports = {};
+__export(reverseArray_exports, {
+  $reverseArray: () => $reverseArray
+});
+module.exports = __toCommonJS(reverseArray_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $reverseArray = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$reverseArray expression must resolve to an array");
+  const result = arr.slice(0);
+  result.reverse();
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2151:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2881:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$round = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(6026);
-/**
- * Rounds a number to to a whole integer or to a specified decimal place.
- * @param {*} obj
- * @param {*} expr
- */
-const $round = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const num = args[0];
-    const place = args[1];
-    if ((0, util_1.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
-        return num;
-    (0, util_1.assert)((0, util_1.isNumber)(num), "$round expression must resolve to a number.");
-    return (0, _internal_1.truncate)(num, place, true);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var size_exports = {};
+__export(size_exports, {
+  $size: () => $size
+});
+module.exports = __toCommonJS(size_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $size = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isArray)(value) ? value.length : void 0;
 };
-exports.$round = $round;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7625:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7292:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sqrt = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Calculates the square root of a positive number and returns the result as a double.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $sqrt = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(n))
-        return null;
-    (0, util_1.assert)(((0, util_1.isNumber)(n) && n > 0) || isNaN(n), "$sqrt expression must resolve to non-negative number.");
-    return Math.sqrt(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var slice_exports = {};
+__export(slice_exports, {
+  $slice: () => $slice
+});
+module.exports = __toCommonJS(slice_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $slice = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const arr = args[0];
+  let skip = args[1];
+  let limit = args[2];
+  if ((0, import_util.isNil)(limit)) {
+    if (skip < 0) {
+      skip = Math.max(0, arr.length + skip);
+      limit = arr.length - skip + 1;
+    } else {
+      limit = skip;
+      skip = 0;
+    }
+  } else {
+    if (skip < 0) {
+      skip = Math.max(0, arr.length + skip);
+    }
+    (0, import_util.assert)(
+      limit > 0,
+      `Invalid argument for $slice operator. Limit must be a positive number`
+    );
+    limit += skip;
+  }
+  return arr.slice(skip, limit);
 };
-exports.$sqrt = $sqrt;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7709:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1931:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$subtract = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Takes an array that contains two numbers or two dates and subtracts the second value from the first.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $subtract = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args[0] - args[1];
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sortArray_exports = {};
+__export(sortArray_exports, {
+  $sortArray: () => $sortArray
+});
+module.exports = __toCommonJS(sortArray_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $sortArray = (obj, expr, options) => {
+  const { input, sortBy } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(input), "$sortArray expression must resolve to an array");
+  if ((0, import_util.isObject)(sortBy)) {
+    return new import_aggregator.Aggregator([{ $sort: sortBy }]).run(input);
+  }
+  const result = [...input];
+  result.sort(import_util.compare);
+  if (sortBy === -1) result.reverse();
+  return result;
 };
-exports.$subtract = $subtract;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8736:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4657:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$trunc = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(6026);
-/**
- * Truncates a number to a whole integer or to a specified decimal place.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $trunc = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    const num = arr[0];
-    const places = arr[1];
-    if ((0, util_1.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)
-        return num;
-    (0, util_1.assert)((0, util_1.isNumber)(num), "$trunc expression must resolve to a number.");
-    (0, util_1.assert)((0, util_1.isNil)(places) || ((0, util_1.isNumber)(places) && places > -20 && places < 100), "$trunc expression has invalid place");
-    return (0, _internal_1.truncate)(num, places, false);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var zip_exports = {};
+__export(zip_exports, {
+  $zip: () => $zip
+});
+module.exports = __toCommonJS(zip_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $zip = (obj, expr, options) => {
+  const inputs = (0, import_core.computeValue)(obj, expr.inputs, null, options);
+  const useLongestLength = expr.useLongestLength || false;
+  if ((0, import_util.isNil)(inputs)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(inputs), "'inputs' expression must resolve to an array");
+  (0, import_util.assert)((0, import_util.isBoolean)(useLongestLength), "'useLongestLength' must be a boolean");
+  if ((0, import_util.isArray)(expr.defaults)) {
+    (0, import_util.assert)(
+      useLongestLength,
+      "'useLongestLength' must be set to true to use 'defaults'"
+    );
+  }
+  let zipCount = 0;
+  for (const arr of inputs) {
+    if ((0, import_util.isNil)(arr)) return null;
+    (0, import_util.assert)(
+      (0, import_util.isArray)(arr),
+      "'inputs' expression values must resolve to an array or null"
+    );
+    zipCount = useLongestLength ? Math.max(zipCount, arr.length) : Math.min(zipCount || arr.length, arr.length);
+  }
+  const result = [];
+  const defaults = expr.defaults || [];
+  for (let i = 0; i < zipCount; i++) {
+    const temp = inputs.map((val, index) => {
+      return (0, import_util.isNil)(val[i]) ? defaults[index] || null : val[i];
+    });
+    result.push(temp);
+  }
+  return result;
 };
-exports.$trunc = $trunc;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5614:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1172:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$arrayElemAt = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the element at the specified array index.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $arrayElemAt = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)(args instanceof Array && args.length === 2, "$arrayElemAt expression must resolve to array(2)");
-    if (args.some(util_1.isNil))
-        return null;
-    const index = args[1];
-    const arr = args[0];
-    if (index < 0 && Math.abs(index) <= arr.length) {
-        return arr[(index + arr.length) % arr.length];
-    }
-    else if (index >= 0 && index < arr.length) {
-        return arr[index];
-    }
-    return undefined;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$arrayElemAt = $arrayElemAt;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  bitwise: () => bitwise
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const bitwise = (op, compute) => (obj, expr, options) => {
+  (0, import_util.assert)((0, import_util.isArray)(expr), `${op}: expression must be an array.`);
+  const nums = (0, import_core.computeValue)(obj, expr, null, options);
+  if (nums.some(import_util.isNil)) return null;
+  (0, import_util.assert)(
+    nums.every(import_util.isNumber),
+    `${op}: expression must evalue to array of numbers.`
+  );
+  return compute(nums);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 608:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4718:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$arrayToObject = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Converts an array of key value pairs to a document.
- */
-const $arrayToObject = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(arr), "$arrayToObject expression must resolve to an array");
-    return arr.reduce((newObj, val) => {
-        // flatten
-        while ((0, util_1.isArray)(val) && val.length === 1)
-            val = val[0];
-        if (val instanceof Array && val.length == 2) {
-            newObj[val[0]] = val[1];
-        }
-        else {
-            const valObj = val;
-            (0, util_1.assert)((0, util_1.isObject)(valObj) && (0, util_1.has)(valObj, "k") && (0, util_1.has)(valObj, "v"), "$arrayToObject expression is invalid.");
-            newObj[valObj.k] = valObj.v;
-        }
-        return newObj;
-    }, {});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$arrayToObject = $arrayToObject;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitAnd_exports = {};
+__export(bitAnd_exports, {
+  $bitAnd: () => $bitAnd
+});
+module.exports = __toCommonJS(bitAnd_exports);
+var import_internal = __webpack_require__(1172);
+const $bitAnd = (0, import_internal.bitwise)(
+  "$bitAnd",
+  (nums) => nums.reduce((a, b) => a & b, -1)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5579:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3766:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$concatArrays = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Concatenates arrays to return the concatenated array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $concatArrays = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(arr), "$concatArrays must resolve to an array");
-    if (arr.some(util_1.isNil))
-        return null;
-    return arr.reduce((acc, item) => (0, util_1.into)(acc, item), []);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$concatArrays = $concatArrays;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitNot_exports = {};
+__export(bitNot_exports, {
+  $bitNot: () => $bitNot
+});
+module.exports = __toCommonJS(bitNot_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $bitNot = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(n)) return null;
+  if ((0, import_util.isNumber)(n)) return ~n;
+  throw new import_util.MingoError("$bitNot: expression must evaluate to a number.");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2903:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5578:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$filter = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Selects a subset of the array to return an array with only the elements that match the filter condition.
- *
- * @param  {Object} obj The current document
- * @param  {*} expr The filter spec
- * @return {*}
- */
-const $filter = (obj, expr, options) => {
-    const input = (0, core_1.computeValue)(obj, expr.input, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(input), "$filter 'input' expression must resolve to an array");
-    const copts = core_1.ComputeOptions.init(options, obj);
-    const k = expr.as || "this";
-    const local = {
-        variables: { [k]: null }
-    };
-    return input.filter((o) => {
-        local.variables[k] = o;
-        const b = (0, core_1.computeValue)(obj, expr.cond, null, copts.update(copts.root, local));
-        // allow empty strings only in strict MongoDB mode (default).
-        return (0, util_1.truthy)(b, options.useStrictMode);
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$filter = $filter;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitOr_exports = {};
+__export(bitOr_exports, {
+  $bitOr: () => $bitOr
+});
+module.exports = __toCommonJS(bitOr_exports);
+var import_internal = __webpack_require__(1172);
+const $bitOr = (0, import_internal.bitwise)(
+  "$bitOr",
+  (nums) => nums.reduce((a, b) => a | b, 0)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9975:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5938:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$first = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const accumulator_1 = __webpack_require__(3424);
-/**
- * Returns the first element in an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $first = (obj, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    if (obj instanceof Array)
-        return (0, accumulator_1.$first)(obj, expr, copts.update());
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(arr))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(arr), "Must resolve to an array/null or missing");
-    return (0, accumulator_1.$first)(arr, "$$this", options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$first = $first;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitXor_exports = {};
+__export(bitXor_exports, {
+  $bitXor: () => $bitXor
+});
+module.exports = __toCommonJS(bitXor_exports);
+var import_internal = __webpack_require__(1172);
+const $bitXor = (0, import_internal.bitwise)(
+  "$bitXor",
+  (nums) => nums.reduce((a, b) => a ^ b, 0)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3425:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 5148:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitwise_exports = {};
+module.exports = __toCommonJS(bitwise_exports);
+__reExport(bitwise_exports, __webpack_require__(4718), module.exports);
+__reExport(bitwise_exports, __webpack_require__(3766), module.exports);
+__reExport(bitwise_exports, __webpack_require__(5578), module.exports);
+__reExport(bitwise_exports, __webpack_require__(5938), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN-array-element/#mongodb-expression-exp.-firstN
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$firstN = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const firstN_1 = __webpack_require__(3445);
-/**
- * Returns a specified number of elements from the beginning of an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $firstN = (obj, expr, options) => {
-    // first try the accumulator if input is an array.
-    if (obj instanceof Array)
-        return (0, firstN_1.$firstN)(obj, expr, options);
-    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "Must resolve to an array/null or missing");
-    return (0, firstN_1.$firstN)(input, { n, input: "$$this" }, options);
+
+/***/ }),
+
+/***/ 70:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var and_exports = {};
+__export(and_exports, {
+  $and: () => $and
+});
+module.exports = __toCommonJS(and_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $and = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.truthy)(value, options.useStrictMode) && value.every((v) => (0, import_util.truthy)(v, options.useStrictMode));
 };
-exports.$firstN = $firstN;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7485:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1703:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$in = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a boolean indicating whether a specified value is in an array.
- *
- * @param {Object} obj
- * @param {Array} expr
- */
-const $in = (obj, expr, options) => {
-    const [item, arr] = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(arr), "$in second argument must be an array");
-    return arr.some(util_1.isEqual.bind(null, item));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$in = $in;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var boolean_exports = {};
+module.exports = __toCommonJS(boolean_exports);
+__reExport(boolean_exports, __webpack_require__(70), module.exports);
+__reExport(boolean_exports, __webpack_require__(5950), module.exports);
+__reExport(boolean_exports, __webpack_require__(770), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1613:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 5950:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(5614), exports);
-__exportStar(__webpack_require__(608), exports);
-__exportStar(__webpack_require__(5579), exports);
-__exportStar(__webpack_require__(2903), exports);
-__exportStar(__webpack_require__(9975), exports);
-__exportStar(__webpack_require__(3425), exports);
-__exportStar(__webpack_require__(7485), exports);
-__exportStar(__webpack_require__(2686), exports);
-__exportStar(__webpack_require__(5499), exports);
-__exportStar(__webpack_require__(1410), exports);
-__exportStar(__webpack_require__(3927), exports);
-__exportStar(__webpack_require__(1965), exports);
-__exportStar(__webpack_require__(8245), exports);
-__exportStar(__webpack_require__(3051), exports);
-__exportStar(__webpack_require__(893), exports);
-__exportStar(__webpack_require__(9633), exports);
-__exportStar(__webpack_require__(2641), exports);
-__exportStar(__webpack_require__(1951), exports);
-__exportStar(__webpack_require__(5052), exports);
-__exportStar(__webpack_require__(5000), exports);
-__exportStar(__webpack_require__(5450), exports);
-__exportStar(__webpack_require__(7393), exports);
-
-
-/***/ }),
-
-/***/ 2686:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var not_exports = {};
+__export(not_exports, {
+  $not: () => $not
+});
+module.exports = __toCommonJS(not_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $not = (obj, expr, options) => {
+  const booleanExpr = (0, import_util.ensureArray)(expr);
+  if (booleanExpr.length == 0) return false;
+  (0, import_util.assert)(booleanExpr.length == 1, "Expression $not takes exactly 1 argument");
+  return !(0, import_core.computeValue)(obj, booleanExpr[0], null, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-"use strict";
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$indexOfArray = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Searches an array for an occurrence of a specified value and returns the array index of the first occurrence.
- * If the substring is not found, returns -1.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $indexOfArray = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(args))
-        return null;
-    let arr = args[0];
-    const searchValue = args[1];
-    if ((0, util_1.isNil)(arr))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(arr), "$indexOfArray expression must resolve to an array.");
-    const start = args[2] || 0;
-    let end = args[3];
-    if ((0, util_1.isNil)(end))
-        end = arr.length;
-    if (start > end)
-        return -1;
-    (0, util_1.assert)(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
-    if (start > 0 || end < arr.length) {
-        arr = arr.slice(start, end);
-    }
-    // Array.prototype.findIndex not supported in IE9 hence this workaround
-    let index = -1;
-    arr.some((v, i) => {
-        const b = (0, util_1.isEqual)(v, searchValue);
-        if (b)
-            index = i;
-        return b;
-    });
-    return index + start;
+/***/ }),
+
+/***/ 770:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$indexOfArray = $indexOfArray;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var or_exports = {};
+__export(or_exports, {
+  $or: () => $or
+});
+module.exports = __toCommonJS(or_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $or = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  const strict = options.useStrictMode;
+  return (0, import_util.truthy)(value, strict) && value.some((v) => (0, import_util.truthy)(v, strict));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5499:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6460:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$isArray = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Determines if the operand is an array. Returns a boolean.
- *
- * @param  {Object}  obj
- * @param  {*}  expr
- * @return {Boolean}
- */
-const $isArray = (obj, expr, options) => {
-    return (0, core_1.computeValue)(obj, expr[0], null, options) instanceof Array;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cmp_exports = {};
+__export(cmp_exports, {
+  $cmp: () => $cmp
+});
+module.exports = __toCommonJS(cmp_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $cmp = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.length == 2,
+    "$cmp: expression must resolve to array of size 2."
+  );
+  return (0, import_util.compare)(args[0], args[1]);
 };
-exports.$isArray = $isArray;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1410:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1768:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$last = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const accumulator_1 = __webpack_require__(3424);
-/**
- * Returns the last element in an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $last = (obj, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    if (obj instanceof Array)
-        return (0, accumulator_1.$last)(obj, expr, copts.update());
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(arr))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(arr), "Must resolve to an array/null or missing");
-    return (0, accumulator_1.$last)(arr, "$$this", options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$last = $last;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eq_exports = {};
+__export(eq_exports, {
+  $eq: () => $eq
+});
+module.exports = __toCommonJS(eq_exports);
+var import_predicates = __webpack_require__(4330);
+const $eq = (0, import_predicates.createExpressionOperator)(import_predicates.$eq);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3927:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3113:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN-array-element/#mongodb-expression-exp.-lastN
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lastN = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const lastN_1 = __webpack_require__(9799);
-/**
- * Returns a specified number of elements from the end of an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $lastN = (obj, expr, options) => {
-    // first try the accumulator if input is an array.
-    if (obj instanceof Array)
-        return (0, lastN_1.$lastN)(obj, expr, options);
-    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "Must resolve to an array/null or missing");
-    return (0, lastN_1.$lastN)(input, { n, input: "$$this" }, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$lastN = $lastN;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gt_exports = {};
+__export(gt_exports, {
+  $gt: () => $gt
+});
+module.exports = __toCommonJS(gt_exports);
+var import_predicates = __webpack_require__(4330);
+const $gt = (0, import_predicates.createExpressionOperator)(import_predicates.$gt);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1965:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9530:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$map = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Applies a sub-expression to each element of an array and returns the array of resulting values in order.
- *
- * @param obj
- * @param expr
- * @returns {Array|*}
- */
-const $map = (obj, expr, options) => {
-    const input = (0, core_1.computeValue)(obj, expr.input, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(input), `$map 'input' expression must resolve to an array`);
-    const copts = core_1.ComputeOptions.init(options);
-    const k = expr.as || "this";
-    return input.map((o) => {
-        return (0, core_1.computeValue)(obj, expr.in, null, copts.update(copts.root, {
-            variables: { [k]: o }
-        }));
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$map = $map;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gte_exports = {};
+__export(gte_exports, {
+  $gte: () => $gte
+});
+module.exports = __toCommonJS(gte_exports);
+var import_predicates = __webpack_require__(4330);
+const $gte = (0, import_predicates.createExpressionOperator)(import_predicates.$gte);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8245:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3336:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN-array-element/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$maxN = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const maxN_1 = __webpack_require__(8542);
-/**
- * Returns the n largest values in an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $maxN = (obj, expr, options) => {
-    // first try the accumulator if input is an array.
-    if (obj instanceof Array)
-        return (0, maxN_1.$maxN)(obj, expr, options);
-    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "Must resolve to an array/null or missing");
-    return (0, maxN_1.$maxN)(input, { n, input: "$$this" }, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$maxN = $maxN;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var comparison_exports = {};
+module.exports = __toCommonJS(comparison_exports);
+__reExport(comparison_exports, __webpack_require__(6460), module.exports);
+__reExport(comparison_exports, __webpack_require__(1768), module.exports);
+__reExport(comparison_exports, __webpack_require__(3113), module.exports);
+__reExport(comparison_exports, __webpack_require__(9530), module.exports);
+__reExport(comparison_exports, __webpack_require__(6646), module.exports);
+__reExport(comparison_exports, __webpack_require__(7887), module.exports);
+__reExport(comparison_exports, __webpack_require__(3515), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3051:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6646:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN-array-element/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$minN = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const minN_1 = __webpack_require__(3946);
-/**
- * Returns the n smallest values in an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $minN = (obj, expr, options) => {
-    // first try the accumulator if input is an array.
-    if (obj instanceof Array)
-        return (0, minN_1.$minN)(obj, expr, options);
-    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "Must resolve to an array/null or missing");
-    return (0, minN_1.$minN)(input, { n, input: "$$this" }, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$minN = $minN;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lt_exports = {};
+__export(lt_exports, {
+  $lt: () => $lt
+});
+module.exports = __toCommonJS(lt_exports);
+var import_predicates = __webpack_require__(4330);
+const $lt = (0, import_predicates.createExpressionOperator)(import_predicates.$lt);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 893:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7887:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$nin = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Returns a boolean indicating whether a specified value is not an array.
- * Note: This expression operator is missing from the documentation
- *
- * @param {Object} obj
- * @param {Array} expr
- */
-exports.$nin = (0, _predicates_1.createExpressionOperator)(_predicates_1.$nin);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lte_exports = {};
+__export(lte_exports, {
+  $lte: () => $lte
+});
+module.exports = __toCommonJS(lte_exports);
+var import_predicates = __webpack_require__(4330);
+const $lte = (0, import_predicates.createExpressionOperator)(import_predicates.$lte);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9633:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3515:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$range = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Returns an array whose elements are a generated sequence of numbers.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $range = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    const start = arr[0];
-    const end = arr[1];
-    const step = arr[2] || 1;
-    const result = new Array();
-    let counter = start;
-    while ((counter < end && step > 0) || (counter > end && step < 0)) {
-        result.push(counter);
-        counter += step;
-    }
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$range = $range;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ne_exports = {};
+__export(ne_exports, {
+  $ne: () => $ne
+});
+module.exports = __toCommonJS(ne_exports);
+var import_predicates = __webpack_require__(4330);
+const $ne = (0, import_predicates.createExpressionOperator)(import_predicates.$ne);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2641:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6343:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$reduce = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Applies an expression to each element in an array and combines them into a single value.
- *
- * @param {Object} obj
- * @param {*} expr
- */
-const $reduce = (obj, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    const input = (0, core_1.computeValue)(obj, expr.input, null, copts);
-    const initialValue = (0, core_1.computeValue)(obj, expr.initialValue, null, copts);
-    const inExpr = expr["in"];
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "$reduce 'input' expression must resolve to an array");
-    return input.reduce((acc, n) => {
-        return (0, core_1.computeValue)(n, inExpr, null, copts.update(copts.root, {
-            variables: { value: acc }
-        }));
-    }, initialValue);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$reduce = $reduce;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cond_exports = {};
+__export(cond_exports, {
+  $cond: () => $cond
+});
+module.exports = __toCommonJS(cond_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $cond = (obj, expr, options) => {
+  let ifExpr;
+  let thenExpr;
+  let elseExpr;
+  const errorMsg = "$cond: invalid arguments";
+  if ((0, import_util.isArray)(expr)) {
+    (0, import_util.assert)(expr.length === 3, errorMsg);
+    ifExpr = expr[0];
+    thenExpr = expr[1];
+    elseExpr = expr[2];
+  } else {
+    (0, import_util.assert)((0, import_util.isObject)(expr), errorMsg);
+    ifExpr = expr.if;
+    thenExpr = expr.then;
+    elseExpr = expr.else;
+  }
+  const condition = (0, import_util.truthy)(
+    (0, import_core.computeValue)(obj, ifExpr, null, options),
+    options.useStrictMode
+  );
+  return (0, import_core.computeValue)(obj, condition ? thenExpr : elseExpr, null, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1951:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3653:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$reverseArray = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns an array with the elements in reverse order.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $reverseArray = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(arr))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(arr), "$reverseArray expression must resolve to an array");
-    const result = arr.slice(0);
-    result.reverse();
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ifNull_exports = {};
+__export(ifNull_exports, {
+  $ifNull: () => $ifNull
+});
+module.exports = __toCommonJS(ifNull_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $ifNull = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return args.find((arg) => !(0, import_util.isNil)(arg)) ?? args[args.length - 1];
 };
-exports.$reverseArray = $reverseArray;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5052:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5459:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$size = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Counts and returns the total the number of items in an array.
- *
- * @param obj
- * @param expr
- */
-const $size = (obj, expr, options) => {
-    const value = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.isArray)(value) ? value.length : undefined;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$size = $size;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conditional_exports = {};
+module.exports = __toCommonJS(conditional_exports);
+__reExport(conditional_exports, __webpack_require__(6343), module.exports);
+__reExport(conditional_exports, __webpack_require__(3653), module.exports);
+__reExport(conditional_exports, __webpack_require__(4739), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5000:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4739:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$slice = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a subset of an array.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $slice = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const arr = args[0];
-    let skip = args[1];
-    let limit = args[2];
-    // MongoDB $slice works a bit differently from Array.slice
-    // Uses single argument for 'limit' and array argument [skip, limit]
-    if ((0, util_1.isNil)(limit)) {
-        if (skip < 0) {
-            skip = Math.max(0, arr.length + skip);
-            limit = arr.length - skip + 1;
-        }
-        else {
-            limit = skip;
-            skip = 0;
-        }
-    }
-    else {
-        if (skip < 0) {
-            skip = Math.max(0, arr.length + skip);
-        }
-        (0, util_1.assert)(limit > 0, `Invalid argument for $slice operator. Limit must be a positive number`);
-        limit += skip;
-    }
-    return arr.slice(skip, limit);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$slice = $slice;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var switch_exports = {};
+__export(switch_exports, {
+  $switch: () => $switch
+});
+module.exports = __toCommonJS(switch_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $switch = (obj, expr, options) => {
+  let thenExpr = null;
+  expr.branches.some((b) => {
+    const condition = (0, import_util.truthy)(
+      (0, import_core.computeValue)(obj, b.case, null, options),
+      options.useStrictMode
+    );
+    if (condition) thenExpr = b.then;
+    return condition;
+  });
+  return (0, import_core.computeValue)(
+    obj,
+    thenExpr !== null ? thenExpr : expr.default,
+    null,
+    options
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5450:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3388:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// https://www.mongodb.com/docs/manual/reference/operator/aggregation/sortArray/#mongodb-expression-exp.-sortArray
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sortArray = void 0;
-const aggregator_1 = __webpack_require__(7268);
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Sorts an array based on its elements. The sort order is user specified.
- *
- * @param obj The target object
- * @param expr The expression argument
- * @param options Options
- * @returns
- */
-const $sortArray = (obj, expr, options) => {
-    const { input, sortBy } = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isArray)(input), "$sortArray expression must resolve to an array");
-    if ((0, util_1.isObject)(sortBy)) {
-        return new aggregator_1.Aggregator([{ $sort: sortBy }]).run(input);
-    }
-    const result = [...input];
-    result.sort(util_1.compare);
-    if (sortBy === -1)
-        result.reverse();
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var function_exports = {};
+__export(function_exports, {
+  $function: () => $function
+});
+module.exports = __toCommonJS(function_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $function = (obj, expr, options) => {
+  (0, import_util.assert)(
+    options.scriptEnabled,
+    "$function operator requires 'scriptEnabled' option to be true"
+  );
+  const fn = (0, import_core.computeValue)(obj, expr, null, options);
+  return fn.body.apply(null, fn.args);
 };
-exports.$sortArray = $sortArray;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7393:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6518:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$zip = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Merge two lists together.
- *
- * Transposes an array of input arrays so that the first element of the output array would be an array containing,
- * the first element of the first input array, the first element of the second input array, etc.
- *
- * @param  {Obj} obj
- * @param  {*} expr
- * @return {*}
- */
-const $zip = (obj, expr, options) => {
-    const inputs = (0, core_1.computeValue)(obj, expr.inputs, null, options);
-    const useLongestLength = expr.useLongestLength || false;
-    (0, util_1.assert)((0, util_1.isArray)(inputs), "'inputs' expression must resolve to an array");
-    (0, util_1.assert)((0, util_1.isBoolean)(useLongestLength), "'useLongestLength' must be a boolean");
-    if ((0, util_1.isArray)(expr.defaults)) {
-        (0, util_1.assert)(useLongestLength, "'useLongestLength' must be set to true to use 'defaults'");
-    }
-    let zipCount = 0;
-    for (let i = 0, len = inputs.length; i < len; i++) {
-        const arr = inputs[i];
-        if ((0, util_1.isNil)(arr))
-            return null;
-        (0, util_1.assert)((0, util_1.isArray)(arr), "'inputs' expression values must resolve to an array or null");
-        zipCount = useLongestLength
-            ? Math.max(zipCount, arr.length)
-            : Math.min(zipCount || arr.length, arr.length);
-    }
-    const result = [];
-    const defaults = expr.defaults || [];
-    for (let i = 0; i < zipCount; i++) {
-        const temp = inputs.map((val, index) => {
-            return (0, util_1.isNil)(val[i]) ? defaults[index] || null : val[i];
-        });
-        result.push(temp);
-    }
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$zip = $zip;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var custom_exports = {};
+module.exports = __toCommonJS(custom_exports);
+__reExport(custom_exports, __webpack_require__(3388), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6635:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1277:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$and = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true only when all its expressions evaluate to true. Accepts any number of argument expressions.
- *
- * @param obj
- * @param expr
- * @returns {boolean}
- */
-const $and = (obj, expr, options) => {
-    const value = (0, core_1.computeValue)(obj, expr, null, options);
-    return ((0, util_1.truthy)(value, options.useStrictMode) &&
-        value.every(v => (0, util_1.truthy)(v, options.useStrictMode)));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  DATE_FORMAT: () => DATE_FORMAT,
+  DATE_PART_INTERVAL: () => DATE_PART_INTERVAL,
+  DATE_SYM_TABLE: () => DATE_SYM_TABLE,
+  DAYS_OF_WEEK: () => DAYS_OF_WEEK,
+  DAYS_OF_WEEK_SET: () => DAYS_OF_WEEK_SET,
+  DAYS_PER_WEEK: () => DAYS_PER_WEEK,
+  LEAP_YEAR_REF_POINT: () => LEAP_YEAR_REF_POINT,
+  MILLIS_PER_DAY: () => MILLIS_PER_DAY,
+  MINUTES_PER_HOUR: () => MINUTES_PER_HOUR,
+  TIMEUNIT_IN_MILLIS: () => TIMEUNIT_IN_MILLIS,
+  adjustDate: () => adjustDate,
+  computeDate: () => computeDate,
+  dateAdd: () => dateAdd,
+  dateDiffDay: () => dateDiffDay,
+  dateDiffHour: () => dateDiffHour,
+  dateDiffMonth: () => dateDiffMonth,
+  dateDiffQuarter: () => dateDiffQuarter,
+  dateDiffWeek: () => dateDiffWeek,
+  dateDiffYear: () => dateDiffYear,
+  dayOfYear: () => dayOfYear,
+  daysBetweenYears: () => daysBetweenYears,
+  daysInMonth: () => daysInMonth,
+  daysInYear: () => daysInYear,
+  formatTimezone: () => formatTimezone,
+  isLeapYear: () => isLeapYear,
+  isoWeek: () => isoWeek,
+  isoWeekYear: () => isoWeekYear,
+  isoWeekday: () => isoWeekday,
+  padDigits: () => padDigits,
+  parseTimezone: () => parseTimezone
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const LEAP_YEAR_REF_POINT = -1e9;
+const DAYS_PER_WEEK = 7;
+const isLeapYear = (y) => (y & 3) == 0 && (y % 100 != 0 || y % 400 == 0);
+const DAYS_IN_YEAR = [
+  365,
+  366
+  /*leap*/
+];
+const daysInYear = (year) => DAYS_IN_YEAR[+isLeapYear(year)];
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const daysInMonth = (d) => DAYS_IN_MONTH[d.getUTCMonth()] + Number(
+  d.getUTCMonth() === 1 && isLeapYear(d.getUTCFullYear())
+);
+const YEAR_DAYS_OFFSET = [
+  [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
+  [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
+  /*leap*/
+];
+const dayOfYear = (d) => YEAR_DAYS_OFFSET[+isLeapYear(d.getUTCFullYear())][d.getUTCMonth()] + d.getUTCDate();
+const isoWeekday = (date, startOfWeek = "sun") => {
+  const dow = date.getUTCDay() || 7;
+  return (dow - ISO_WEEKDAY_MAP[startOfWeek] + DAYS_PER_WEEK) % DAYS_PER_WEEK;
+};
+const p = (y) => (y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400)) % 7;
+const weeks = (y) => 52 + Number(p(y) == 4 || p(y - 1) == 3);
+function isoWeek(d) {
+  const dow = d.getUTCDay() || 7;
+  const w = Math.floor((10 + dayOfYear(d) - dow) / 7);
+  if (w < 1) return weeks(d.getUTCFullYear() - 1);
+  if (w > weeks(d.getUTCFullYear())) return 1;
+  return w;
+}
+function isoWeekYear(d) {
+  return d.getUTCFullYear() - Number(d.getUTCMonth() === 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);
+}
+const MINUTES_PER_HOUR = 60;
+const MILLIS_PER_DAY = 1e3 * 60 * 60 * 24;
+const TIMEUNIT_IN_MILLIS = {
+  week: MILLIS_PER_DAY * DAYS_PER_WEEK,
+  day: MILLIS_PER_DAY,
+  hour: 1e3 * 60 * 60,
+  minute: 1e3 * 60,
+  second: 1e3,
+  millisecond: 1
+};
+const DAYS_OF_WEEK = [
+  "monday",
+  "mon",
+  "tuesday",
+  "tue",
+  "wednesday",
+  "wed",
+  "thursday",
+  "thu",
+  "friday",
+  "fri",
+  "saturday",
+  "sat",
+  "sunday",
+  "sun"
+];
+const DAYS_OF_WEEK_SET = new Set(DAYS_OF_WEEK);
+const ISO_WEEKDAY_MAP = Object.freeze({
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6,
+  sun: 7
+});
+const DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%LZ";
+const DATE_PART_INTERVAL = [
+  ["year", 0, 9999],
+  ["month", 1, 12],
+  ["day", 1, 31],
+  ["hour", 0, 23],
+  ["minute", 0, 59],
+  ["second", 0, 59],
+  ["millisecond", 0, 999]
+];
+const DATE_SYM_TABLE = Object.freeze({
+  "%Y": { name: "year", padding: 4, re: /([0-9]{4})/ },
+  "%G": { name: "year", padding: 4, re: /([0-9]{4})/ },
+  "%m": { name: "month", padding: 2, re: /(0[1-9]|1[012])/ },
+  "%d": { name: "day", padding: 2, re: /(0[1-9]|[12][0-9]|3[01])/ },
+  "%H": { name: "hour", padding: 2, re: /([01][0-9]|2[0-3])/ },
+  "%M": { name: "minute", padding: 2, re: /([0-5][0-9])/ },
+  "%S": { name: "second", padding: 2, re: /([0-5][0-9]|60)/ },
+  "%L": { name: "millisecond", padding: 3, re: /([0-9]{3})/ },
+  "%u": { name: "weekday", padding: 1, re: /([1-7])/ },
+  "%U": { name: "week", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },
+  "%V": { name: "isoWeek", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },
+  "%z": {
+    name: "timezone",
+    padding: 2,
+    re: /(([+-][01][0-9]|2[0-3]):?([0-5][0-9])?)/
+  },
+  "%Z": { name: "minuteOffset", padding: 3, re: /([+-][0-9]{3})/ }
+  // "%%": "%",
+});
+const TIMEZONE_RE = /^[a-zA-Z_]+\/[a-zA-Z_]+$/;
+function parseTimezone(tzstr) {
+  if ((0, import_util.isNil)(tzstr)) return 0;
+  if (TIMEZONE_RE.test(tzstr)) {
+    const date = /* @__PURE__ */ new Date();
+    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+    const tzDate = new Date(date.toLocaleString("en-US", { timeZone: tzstr }));
+    return (tzDate.getTime() - utcDate.getTime()) / 6e4;
+  }
+  const m = DATE_SYM_TABLE["%z"].re.exec(tzstr);
+  if (!m) {
+    throw new import_util.MingoError(`Timezone '${tzstr}' is invalid or not supported`);
+  }
+  const hr = parseInt(m[2]) || 0;
+  const min = parseInt(m[3]) || 0;
+  return (Math.abs(hr * MINUTES_PER_HOUR) + min) * (hr < 0 ? -1 : 1);
+}
+function formatTimezone(minuteOffset) {
+  return (minuteOffset < 0 ? "-" : "+") + padDigits(Math.abs(Math.floor(minuteOffset / MINUTES_PER_HOUR)), 2) + padDigits(Math.abs(minuteOffset) % MINUTES_PER_HOUR, 2);
+}
+function adjustDate(d, minuteOffset) {
+  d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);
+}
+function computeDate(obj, expr, options) {
+  if ((0, import_util.isDate)(obj)) return obj;
+  const d = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isDate)(d)) return new Date(d);
+  if ((0, import_util.isNumber)(d)) return new Date(d * 1e3);
+  if (d.date) {
+    const date = (0, import_util.isDate)(d.date) ? new Date(d.date) : new Date(d.date * 1e3);
+    if (d.timezone) {
+      adjustDate(date, parseTimezone(d.timezone));
+    }
+    return date;
+  }
+  throw Error(`cannot convert ${JSON.stringify(expr)} to date`);
+}
+function padDigits(n, digits) {
+  return new Array(Math.max(digits - String(n).length + 1, 0)).join("0") + n.toString();
+}
+const leapYearsSinceReferencePoint = (year) => {
+  const yearsSinceReferencePoint = year - LEAP_YEAR_REF_POINT;
+  return Math.trunc(yearsSinceReferencePoint / 4) - Math.trunc(yearsSinceReferencePoint / 100) + Math.trunc(yearsSinceReferencePoint / 400);
+};
+function daysBetweenYears(startYear, endYear) {
+  return Math.trunc(
+    leapYearsSinceReferencePoint(endYear - 1) - leapYearsSinceReferencePoint(startYear - 1) + (endYear - startYear) * DAYS_IN_YEAR[0]
+  );
+}
+const dateDiffYear = (start, end) => end.getUTCFullYear() - start.getUTCFullYear();
+const dateDiffMonth = (start, end) => end.getUTCMonth() - start.getUTCMonth() + dateDiffYear(start, end) * 12;
+const dateDiffQuarter = (start, end) => {
+  const a = Math.trunc(start.getUTCMonth() / 3);
+  const b = Math.trunc(end.getUTCMonth() / 3);
+  return b - a + dateDiffYear(start, end) * 4;
+};
+const dateDiffDay = (start, end) => dayOfYear(end) - dayOfYear(start) + daysBetweenYears(start.getUTCFullYear(), end.getUTCFullYear());
+const dateDiffWeek = (start, end, startOfWeek) => {
+  const wk = (startOfWeek || "sun").substring(0, 3);
+  return Math.trunc(
+    (dateDiffDay(start, end) + isoWeekday(start, wk) - isoWeekday(end, wk)) / DAYS_PER_WEEK
+  );
+};
+const dateDiffHour = (start, end) => end.getUTCHours() - start.getUTCHours() + dateDiffDay(start, end) * 24;
+const addMonth = (d, amount) => {
+  const m = d.getUTCMonth() + amount;
+  const yearOffset = Math.floor(m / 12);
+  if (m < 0) {
+    const month = m % 12 + 12;
+    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());
+  } else {
+    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());
+  }
+};
+const dateAdd = (date, unit, amount, _timezone) => {
+  const d = new Date(date);
+  switch (unit) {
+    case "year":
+      d.setUTCFullYear(d.getUTCFullYear() + amount);
+      break;
+    case "quarter":
+      addMonth(d, 3 * amount);
+      break;
+    case "month":
+      addMonth(d, amount);
+      break;
+    default:
+      d.setTime(d.getTime() + TIMEUNIT_IN_MILLIS[unit] * amount);
+  }
+  return d;
 };
-exports.$and = $and;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 628:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 8410:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(6635), exports);
-__exportStar(__webpack_require__(2560), exports);
-__exportStar(__webpack_require__(497), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateAdd_exports = {};
+__export(dateAdd_exports, {
+  $dateAdd: () => $dateAdd
+});
+module.exports = __toCommonJS(dateAdd_exports);
+var import_core = __webpack_require__(2760);
+var import_internal = __webpack_require__(1277);
+const $dateAdd = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_internal.dateAdd)(args.startDate, args.unit, args.amount, args.timezone);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2560:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9178:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$not = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the boolean value that is the opposite of its argument expression. Accepts a single argument expression.
- *
- * @param obj RawObject from collection
- * @param expr Right hand side expression of operator
- * @returns {boolean}
- */
-const $not = (obj, expr, options) => {
-    const booleanExpr = (0, util_1.ensureArray)(expr);
-    // array values are truthy so an emty array is false
-    if (booleanExpr.length == 0)
-        return false;
-    // use provided value non-array value
-    if (booleanExpr.length == 1)
-        return !(0, core_1.computeValue)(obj, booleanExpr[0], null, options);
-    // expects a single argument
-    throw "Expression $not takes exactly 1 argument";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateDiff_exports = {};
+__export(dateDiff_exports, {
+  $dateDiff: () => $dateDiff
+});
+module.exports = __toCommonJS(dateDiff_exports);
+var import_core = __webpack_require__(2760);
+var import_internal = __webpack_require__(1277);
+const $dateDiff = (obj, expr, options) => {
+  const { startDate, endDate, unit, timezone, startOfWeek } = (0, import_core.computeValue)(
+    obj,
+    expr,
+    null,
+    options
+  );
+  const d1 = new Date(startDate);
+  const d2 = new Date(endDate);
+  const minuteOffset = (0, import_internal.parseTimezone)(timezone);
+  (0, import_internal.adjustDate)(d1, minuteOffset);
+  (0, import_internal.adjustDate)(d2, minuteOffset);
+  switch (unit) {
+    case "year":
+      return (0, import_internal.dateDiffYear)(d1, d2);
+    case "quarter":
+      return (0, import_internal.dateDiffQuarter)(d1, d2);
+    case "month":
+      return (0, import_internal.dateDiffMonth)(d1, d2);
+    case "week":
+      return (0, import_internal.dateDiffWeek)(d1, d2, startOfWeek);
+    case "day":
+      return (0, import_internal.dateDiffDay)(d1, d2);
+    case "hour":
+      return (0, import_internal.dateDiffHour)(d1, d2);
+    case "minute":
+      d1.setUTCSeconds(0);
+      d1.setUTCMilliseconds(0);
+      d2.setUTCSeconds(0);
+      d2.setUTCMilliseconds(0);
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / import_internal.TIMEUNIT_IN_MILLIS[unit]
+      );
+    default:
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / import_internal.TIMEUNIT_IN_MILLIS[unit]
+      );
+  }
 };
-exports.$not = $not;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 497:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 611:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$or = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true when any of its expressions evaluates to true. Accepts any number of argument expressions.
- *
- * @param obj
- * @param expr
- * @returns {boolean}
- */
-const $or = (obj, expr, options) => {
-    const value = (0, core_1.computeValue)(obj, expr, null, options);
-    const strict = options.useStrictMode;
-    return (0, util_1.truthy)(value, strict) && value.some(v => (0, util_1.truthy)(v, strict));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$or = $or;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateFromParts_exports = {};
+__export(dateFromParts_exports, {
+  $dateFromParts: () => $dateFromParts
+});
+module.exports = __toCommonJS(dateFromParts_exports);
+var import_core = __webpack_require__(2760);
+var import_internal = __webpack_require__(1277);
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const getDaysInMonth = (date) => {
+  return date.month == 2 && (0, import_internal.isLeapYear)(date.year) ? 29 : DAYS_IN_MONTH[date.month - 1];
+};
+const $dateFromParts = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const minuteOffset = (0, import_internal.parseTimezone)(args.timezone);
+  for (let i = import_internal.DATE_PART_INTERVAL.length - 1, remainder = 0; i >= 0; i--) {
+    const datePartInterval = import_internal.DATE_PART_INTERVAL[i];
+    const k = datePartInterval[0];
+    const min = datePartInterval[1];
+    const max = datePartInterval[2];
+    let part = (args[k] || 0) + remainder;
+    remainder = 0;
+    const limit = max + 1;
+    if (k == "hour") part += Math.floor(minuteOffset / import_internal.MINUTES_PER_HOUR) * -1;
+    if (k == "minute") part += minuteOffset % import_internal.MINUTES_PER_HOUR * -1;
+    if (part < min) {
+      const delta = min - part;
+      remainder = -1 * Math.ceil(delta / limit);
+      part = limit - delta % limit;
+    } else if (part > max) {
+      part += min;
+      remainder = Math.trunc(part / limit);
+      part %= limit;
+    }
+    args[k] = part;
+  }
+  args.day = Math.min(args.day, getDaysInMonth(args));
+  return new Date(
+    Date.UTC(
+      args.year,
+      args.month - 1,
+      args.day,
+      args.hour,
+      args.minute,
+      args.second,
+      args.millisecond
+    )
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9543:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5268:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$cmp = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Compares two values and returns the result of the comparison as an integer.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $cmp = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    if (args[0] > args[1])
-        return 1;
-    if (args[0] < args[1])
-        return -1;
-    return 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateFromString_exports = {};
+__export(dateFromString_exports, {
+  $dateFromString: () => $dateFromString
+});
+module.exports = __toCommonJS(dateFromString_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(1277);
+const buildMap = (letters, sign) => {
+  const h = {};
+  letters.split("").forEach((v, i) => h[v] = sign * (i + 1));
+  return h;
+};
+const TZ_LETTER_OFFSETS = {
+  ...buildMap("ABCDEFGHIKLM", 1),
+  ...buildMap("NOPQRSTUVWXY", -1),
+  Z: 0
+};
+const regexStrip = (s) => s.replace(/^\//, "").replace(/\/$/, "");
+const REGEX_SPECIAL_CHARS = ["^", ".", "-", "*", "?", "$"];
+const regexQuote = (s) => {
+  REGEX_SPECIAL_CHARS.forEach((c) => {
+    s = s.replace(c, `\\${c}`);
+  });
+  return s;
+};
+const $dateFromString = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  args.format = args.format || import_internal.DATE_FORMAT;
+  args.onNull = args.onNull || null;
+  let dateString = args.dateString;
+  if ((0, import_util.isNil)(dateString)) return args.onNull;
+  const separators = args.format.split(/%[YGmdHMSLuVzZ]/);
+  separators.reverse();
+  const matches = args.format.match(
+    /(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%V|%z|%Z)/g
+  );
+  const dateParts = {};
+  let expectedPattern = "";
+  for (let i = 0, len = matches.length; i < len; i++) {
+    const formatSpecifier = matches[i];
+    const props = import_internal.DATE_SYM_TABLE[formatSpecifier];
+    if ((0, import_util.isObject)(props)) {
+      const m2 = props.re.exec(dateString);
+      const delimiter = separators.pop() || "";
+      if (m2 !== null) {
+        dateParts[props.name] = /^\d+$/.exec(m2[0]) ? parseInt(m2[0]) : m2[0];
+        dateString = dateString.substr(0, m2.index) + dateString.substr(m2.index + m2[0].length);
+        expectedPattern += regexQuote(delimiter) + regexStrip(props.re.toString());
+      } else {
+        dateParts[props.name] = null;
+      }
+    }
+  }
+  if ((0, import_util.isNil)(dateParts.year) || (0, import_util.isNil)(dateParts.month) || (0, import_util.isNil)(dateParts.day) || !new RegExp("^" + expectedPattern + "[A-Z]?$").exec(args.dateString)) {
+    return args.onError;
+  }
+  const m = args.dateString.match(/([A-Z])$/);
+  (0, import_util.assert)(
+    // only one of in-date timeone or timezone argument but not both.
+    !(m && args.timezone),
+    `$dateFromString: you cannot pass in a date/time string with time zone information ('${m && m[0]}') together with a timezone argument`
+  );
+  const minuteOffset = m ? TZ_LETTER_OFFSETS[m[0]] * import_internal.MINUTES_PER_HOUR : (0, import_internal.parseTimezone)(args.timezone);
+  const d = new Date(
+    Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0)
+  );
+  if (!(0, import_util.isNil)(dateParts.hour)) d.setUTCHours(dateParts.hour);
+  if (!(0, import_util.isNil)(dateParts.minute)) d.setUTCMinutes(dateParts.minute);
+  if (!(0, import_util.isNil)(dateParts.second)) d.setUTCSeconds(dateParts.second);
+  if (!(0, import_util.isNil)(dateParts.millisecond))
+    d.setUTCMilliseconds(dateParts.millisecond);
+  (0, import_internal.adjustDate)(d, -minuteOffset);
+  return d;
 };
-exports.$cmp = $cmp;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5495:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5817:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$eq = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are equal to a specified value.
- */
-exports.$eq = (0, _predicates_1.createExpressionOperator)(_predicates_1.$eq);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateSubtract_exports = {};
+__export(dateSubtract_exports, {
+  $dateSubtract: () => $dateSubtract
+});
+module.exports = __toCommonJS(dateSubtract_exports);
+var import_core = __webpack_require__(2760);
+var import_dateAdd = __webpack_require__(8410);
+const $dateSubtract = (obj, expr, options) => {
+  const amount = (0, import_core.computeValue)(obj, expr?.amount, null, options);
+  return (0, import_dateAdd.$dateAdd)(obj, { ...expr, amount: -1 * amount }, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2005:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 112:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$gt = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are greater than a specified value.
- */
-exports.$gt = (0, _predicates_1.createExpressionOperator)(_predicates_1.$gt);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateToParts_exports = {};
+__export(dateToParts_exports, {
+  $dateToParts: () => $dateToParts
+});
+module.exports = __toCommonJS(dateToParts_exports);
+var import_core = __webpack_require__(2760);
+var import_internal = __webpack_require__(1277);
+const $dateToParts = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const d = new Date(args.date);
+  const tz = (0, import_internal.parseTimezone)(args.timezone);
+  (0, import_internal.adjustDate)(d, tz);
+  const timePart = {
+    hour: d.getUTCHours(),
+    minute: d.getUTCMinutes(),
+    second: d.getUTCSeconds(),
+    millisecond: d.getUTCMilliseconds()
+  };
+  if (args.iso8601 == true) {
+    return Object.assign(timePart, {
+      isoWeekYear: (0, import_internal.isoWeekYear)(d),
+      isoWeek: (0, import_internal.isoWeek)(d),
+      isoDayOfWeek: d.getUTCDay() || 7
+    });
+  }
+  return Object.assign(timePart, {
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9070:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7165:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$gte = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * 	Matches values that are greater than or equal to a specified value.
- */
-exports.$gte = (0, _predicates_1.createExpressionOperator)(_predicates_1.$gte);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateToString_exports = {};
+__export(dateToString_exports, {
+  $dateToString: () => $dateToString
+});
+module.exports = __toCommonJS(dateToString_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(1277);
+var import_dayOfMonth = __webpack_require__(2470);
+var import_hour = __webpack_require__(4067);
+var import_isoDayOfWeek = __webpack_require__(1125);
+var import_isoWeek = __webpack_require__(612);
+var import_millisecond = __webpack_require__(7216);
+var import_minute = __webpack_require__(949);
+var import_month = __webpack_require__(7711);
+var import_second = __webpack_require__(9549);
+var import_week = __webpack_require__(2813);
+var import_year = __webpack_require__(2880);
+const DATE_FUNCTIONS = {
+  "%Y": import_year.$year,
+  "%G": import_year.$year,
+  "%m": import_month.$month,
+  "%d": import_dayOfMonth.$dayOfMonth,
+  "%H": import_hour.$hour,
+  "%M": import_minute.$minute,
+  "%S": import_second.$second,
+  "%L": import_millisecond.$millisecond,
+  "%u": import_isoDayOfWeek.$isoDayOfWeek,
+  "%U": import_week.$week,
+  "%V": import_isoWeek.$isoWeek
+};
+const $dateToString = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args.onNull)) args.onNull = null;
+  if ((0, import_util.isNil)(args.date)) return args.onNull;
+  const date = (0, import_internal.computeDate)(obj, args.date, options);
+  let format = args.format || import_internal.DATE_FORMAT;
+  const minuteOffset = (0, import_internal.parseTimezone)(args.timezone);
+  const matches = format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%U|%V|%z|%Z)/g);
+  (0, import_internal.adjustDate)(date, minuteOffset);
+  for (let i = 0, len = matches.length; i < len; i++) {
+    const formatSpecifier = matches[i];
+    const props = import_internal.DATE_SYM_TABLE[formatSpecifier];
+    const operatorFn = DATE_FUNCTIONS[formatSpecifier];
+    let value;
+    if ((0, import_util.isObject)(props)) {
+      if (props.name === "timezone") {
+        value = (0, import_internal.formatTimezone)(minuteOffset);
+      } else if (props.name === "minuteOffset") {
+        value = minuteOffset.toString();
+      } else {
+        (0, import_util.assert)(
+          !!operatorFn,
+          `unsupported date format specifier '${formatSpecifier}'`
+        );
+        value = (0, import_internal.padDigits)(operatorFn(obj, date, options), props.padding);
+      }
+    }
+    format = format.replace(formatSpecifier, value);
+  }
+  return format;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4591:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 9791:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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]; } };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateTrunc_exports = {};
+__export(dateTrunc_exports, {
+  $dateTrunc: () => $dateTrunc
+});
+module.exports = __toCommonJS(dateTrunc_exports);
+var import_core = __webpack_require__(2760);
+var import_types = __webpack_require__(486);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(1277);
+const REF_DATE_MILLIS = 9466848e5;
+const distanceToBinLowerBound = (value, binSize) => {
+  let remainder = value % binSize;
+  if (remainder < 0) {
+    remainder += binSize;
+  }
+  return remainder;
+};
+const DATE_DIFF_FN = {
+  day: import_internal.dateDiffDay,
+  month: import_internal.dateDiffMonth,
+  quarter: import_internal.dateDiffQuarter,
+  year: import_internal.dateDiffYear
+};
+const $dateTrunc = (obj, expr, options) => {
+  const {
+    date,
+    unit,
+    binSize: optBinSize,
+    timezone,
+    startOfWeek: optStartOfWeek
+  } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(date) || (0, import_util.isNil)(unit)) return null;
+  const startOfWeek = (optStartOfWeek ?? "sun").toLowerCase().substring(0, 3);
+  (0, import_util.assert)(
+    (0, import_util.isDate)(date),
+    "$dateTrunc: 'date' must resolve to a valid Date object."
+  );
+  (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), "$dateTrunc: unit is invalid.");
+  (0, import_util.assert)(
+    unit != "week" || import_internal.DAYS_OF_WEEK_SET.has(startOfWeek),
+    `$dateTrunc: startOfWeek '${startOfWeek}' is not a valid.`
+  );
+  (0, import_util.assert)(
+    (0, import_util.isNil)(optBinSize) || optBinSize > 0,
+    "$dateTrunc requires 'binSize' to be greater than 0, but got value 0."
+  );
+  const binSize = optBinSize ?? 1;
+  switch (unit) {
+    case "millisecond":
+    case "second":
+    case "minute":
+    case "hour": {
+      const binSizeMillis = binSize * import_internal.TIMEUNIT_IN_MILLIS[unit];
+      const shiftedDate = date.getTime() - REF_DATE_MILLIS;
+      return new Date(
+        date.getTime() - distanceToBinLowerBound(shiftedDate, binSizeMillis)
+      );
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    default: {
+      (0, import_util.assert)(binSize <= 1e11, "dateTrunc unsupported binSize value");
+      const d = new Date(date);
+      const refPointDate = new Date(REF_DATE_MILLIS);
+      let distanceFromRefPoint = 0;
+      if (unit == "week") {
+        const refPointDayOfWeek = (0, import_internal.isoWeekday)(refPointDate, startOfWeek);
+        const daysToAdjustBy = (import_internal.DAYS_PER_WEEK - refPointDayOfWeek) % import_internal.DAYS_PER_WEEK;
+        refPointDate.setTime(
+          refPointDate.getTime() + daysToAdjustBy * import_internal.TIMEUNIT_IN_MILLIS.day
+        );
+        distanceFromRefPoint = (0, import_internal.dateDiffWeek)(refPointDate, d, startOfWeek);
+      } else {
+        distanceFromRefPoint = DATE_DIFF_FN[unit](refPointDate, d);
+      }
+      const binLowerBoundFromRefPoint = distanceFromRefPoint - distanceToBinLowerBound(distanceFromRefPoint, binSize);
+      const newDate = (0, import_internal.dateAdd)(
+        refPointDate,
+        unit,
+        binLowerBoundFromRefPoint,
+        timezone
+      );
+      const minuteOffset = (0, import_internal.parseTimezone)(timezone);
+      (0, import_internal.adjustDate)(newDate, -minuteOffset);
+      return newDate;
+    }
+  }
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9543), exports);
-__exportStar(__webpack_require__(5495), exports);
-__exportStar(__webpack_require__(2005), exports);
-__exportStar(__webpack_require__(9070), exports);
-__exportStar(__webpack_require__(1337), exports);
-__exportStar(__webpack_require__(3701), exports);
-__exportStar(__webpack_require__(4267), exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1337:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lt = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are less than the value specified in the query.
- */
-exports.$lt = (0, _predicates_1.createExpressionOperator)(_predicates_1.$lt);
+/***/ 2470:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dayOfMonth_exports = {};
+__export(dayOfMonth_exports, {
+  $dayOfMonth: () => $dayOfMonth
+});
+module.exports = __toCommonJS(dayOfMonth_exports);
+var import_internal = __webpack_require__(1277);
+const $dayOfMonth = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCDate();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3701:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5998:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lte = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are less than or equal to the value specified in the query.
- */
-exports.$lte = (0, _predicates_1.createExpressionOperator)(_predicates_1.$lte);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dayOfWeek_exports = {};
+__export(dayOfWeek_exports, {
+  $dayOfWeek: () => $dayOfWeek
+});
+module.exports = __toCommonJS(dayOfWeek_exports);
+var import_internal = __webpack_require__(1277);
+const $dayOfWeek = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCDay() + 1;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4267:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7107:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ne = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches all values that are not equal to the value specified in the query.
- */
-exports.$ne = (0, _predicates_1.createExpressionOperator)(_predicates_1.$ne);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dayOfYear_exports = {};
+__export(dayOfYear_exports, {
+  $dayOfYear: () => $dayOfYear
+});
+module.exports = __toCommonJS(dayOfYear_exports);
+var import_internal = __webpack_require__(1277);
+const $dayOfYear = (obj, expr, options) => {
+  return (0, import_internal.dayOfYear)((0, import_internal.computeDate)(obj, expr, options));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3833:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4067:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$cond = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * A ternary operator that evaluates one expression,
- * and depending on the result returns the value of one following expressions.
- *
- * @param obj
- * @param expr
- */
-const $cond = (obj, expr, options) => {
-    let ifExpr;
-    let thenExpr;
-    let elseExpr;
-    const errorMsg = "$cond: invalid arguments";
-    if (expr instanceof Array) {
-        (0, util_1.assert)(expr.length === 3, errorMsg);
-        ifExpr = expr[0];
-        thenExpr = expr[1];
-        elseExpr = expr[2];
-    }
-    else {
-        (0, util_1.assert)((0, util_1.isObject)(expr), errorMsg);
-        ifExpr = expr.if;
-        thenExpr = expr.then;
-        elseExpr = expr.else;
-    }
-    const condition = (0, util_1.truthy)((0, core_1.computeValue)(obj, ifExpr, null, options), options.useStrictMode);
-    return (0, core_1.computeValue)(obj, condition ? thenExpr : elseExpr, null, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hour_exports = {};
+__export(hour_exports, {
+  $hour: () => $hour
+});
+module.exports = __toCommonJS(hour_exports);
+var import_internal = __webpack_require__(1277);
+const $hour = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCHours();
 };
-exports.$cond = $cond;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 419:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 3381:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var date_exports = {};
+module.exports = __toCommonJS(date_exports);
+__reExport(date_exports, __webpack_require__(8410), module.exports);
+__reExport(date_exports, __webpack_require__(9178), module.exports);
+__reExport(date_exports, __webpack_require__(611), module.exports);
+__reExport(date_exports, __webpack_require__(5268), module.exports);
+__reExport(date_exports, __webpack_require__(5817), module.exports);
+__reExport(date_exports, __webpack_require__(112), module.exports);
+__reExport(date_exports, __webpack_require__(7165), module.exports);
+__reExport(date_exports, __webpack_require__(9791), module.exports);
+__reExport(date_exports, __webpack_require__(2470), module.exports);
+__reExport(date_exports, __webpack_require__(5998), module.exports);
+__reExport(date_exports, __webpack_require__(7107), module.exports);
+__reExport(date_exports, __webpack_require__(4067), module.exports);
+__reExport(date_exports, __webpack_require__(1125), module.exports);
+__reExport(date_exports, __webpack_require__(612), module.exports);
+__reExport(date_exports, __webpack_require__(5373), module.exports);
+__reExport(date_exports, __webpack_require__(7216), module.exports);
+__reExport(date_exports, __webpack_require__(949), module.exports);
+__reExport(date_exports, __webpack_require__(7711), module.exports);
+__reExport(date_exports, __webpack_require__(9549), module.exports);
+__reExport(date_exports, __webpack_require__(2813), module.exports);
+__reExport(date_exports, __webpack_require__(2880), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 1125:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ifNull = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Evaluates an expression and returns the first non-null value.
- *
- * @param obj
- * @param expr
- * @returns {*}
- */
-const $ifNull = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args.find(arg => !(0, util_1.isNil)(arg));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isoDayOfWeek_exports = {};
+__export(isoDayOfWeek_exports, {
+  $isoDayOfWeek: () => $isoDayOfWeek
+});
+module.exports = __toCommonJS(isoDayOfWeek_exports);
+var import_internal = __webpack_require__(1277);
+const $isoDayOfWeek = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCDay() || 7;
 };
-exports.$ifNull = $ifNull;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5112:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 612:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(3833), exports);
-__exportStar(__webpack_require__(419), exports);
-__exportStar(__webpack_require__(9605), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isoWeek_exports = {};
+__export(isoWeek_exports, {
+  $isoWeek: () => $isoWeek
+});
+module.exports = __toCommonJS(isoWeek_exports);
+var import_internal = __webpack_require__(1277);
+const $isoWeek = (obj, expr, options) => {
+  return (0, import_internal.isoWeek)((0, import_internal.computeDate)(obj, expr, options));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9605:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5373:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$switch = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * An operator that evaluates a series of case expressions. When it finds an expression which
- * evaluates to true, it returns the resulting expression for that case. If none of the cases
- * evaluate to true, it returns the default expression.
- *
- * @param obj
- * @param expr
- */
-const $switch = (obj, expr, options) => {
-    let thenExpr = null;
-    // Array.prototype.find not supported in IE, hence the '.some()' proxy
-    expr.branches.some((b) => {
-        const condition = (0, util_1.truthy)((0, core_1.computeValue)(obj, b.case, null, options), options.useStrictMode);
-        if (condition)
-            thenExpr = b.then;
-        return condition;
-    });
-    return (0, core_1.computeValue)(obj, thenExpr !== null ? thenExpr : expr.default, null, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$switch = $switch;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isoWeekYear_exports = {};
+__export(isoWeekYear_exports, {
+  $isoWeekYear: () => $isoWeekYear
+});
+module.exports = __toCommonJS(isoWeekYear_exports);
+var import_internal = __webpack_require__(1277);
+const $isoWeekYear = (obj, expr, options) => (0, import_internal.isoWeekYear)((0, import_internal.computeDate)(obj, expr, options));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1416:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7216:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Custom Aggregation Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#custom-aggregation-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$function = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Defines a custom function.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The expression for the operator
- * @param {Options} options Options
- */
-const $function = (obj, expr, options) => {
-    (0, util_1.assert)(options.scriptEnabled, "$function operator requires 'scriptEnabled' option to be true");
-    const fn = (0, core_1.computeValue)(obj, expr, null, options);
-    return fn.body.apply(null, fn.args);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$function = $function;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var millisecond_exports = {};
+__export(millisecond_exports, {
+  $millisecond: () => $millisecond
+});
+module.exports = __toCommonJS(millisecond_exports);
+var import_internal = __webpack_require__(1277);
+const $millisecond = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCMilliseconds();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4052:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 949:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(1416), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var minute_exports = {};
+__export(minute_exports, {
+  $minute: () => $minute
+});
+module.exports = __toCommonJS(minute_exports);
+var import_internal = __webpack_require__(1277);
+const $minute = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCMinutes();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7974:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7711:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.regexStrip = exports.regexQuote = exports.padDigits = exports.computeDate = exports.adjustDate = exports.formatTimezone = exports.parseTimezone = exports.DATE_SYM_TABLE = exports.DATE_PART_INTERVAL = exports.DATE_FORMAT = exports.DURATION_IN_MILLIS = exports.MILLIS_PER_DAY = exports.MINUTES_PER_HOUR = exports.isoWeekYear = exports.isoWeek = exports.getDayOfYear = exports.isLeapYear = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const COMMON_YEAR_DAYS_OFFSET = [
-    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
-];
-const LEAP_YEAR_DAYS_OFFSET = [
-    0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
-];
-// https://en.wikipedia.org/wiki/ISO_week_date
-const p = (y) => (y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400)) % 7;
-const weeks = (y) => 52 + Number(p(y) == 4 || p(y - 1) == 3);
-const isLeapYear = (year) => (year & 3) == 0 && (year % 100 != 0 || year % 400 == 0);
-exports.isLeapYear = isLeapYear;
-const getDayOfYear = (d) => ((0, exports.isLeapYear)(d.getUTCFullYear())
-    ? LEAP_YEAR_DAYS_OFFSET
-    : COMMON_YEAR_DAYS_OFFSET)[d.getUTCMonth()] + d.getUTCDate();
-exports.getDayOfYear = getDayOfYear;
-function isoWeek(d) {
-    // algorithm based on https://en.wikipedia.org/wiki/ISO_week_date
-    const w = Math.floor((10 + (0, exports.getDayOfYear)(d) - (d.getUTCDay() || 7)) / 7);
-    if (w < 1)
-        return weeks(d.getUTCFullYear() - 1);
-    if (w > weeks(d.getUTCFullYear()))
-        return 1;
-    return w;
-}
-exports.isoWeek = isoWeek;
-function isoWeekYear(d) {
-    return (d.getUTCFullYear() -
-        Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1));
-}
-exports.isoWeekYear = isoWeekYear;
-exports.MINUTES_PER_HOUR = 60;
-exports.MILLIS_PER_DAY = 1000 * 60 * 60 * 24;
-exports.DURATION_IN_MILLIS = {
-    week: exports.MILLIS_PER_DAY * 7,
-    day: exports.MILLIS_PER_DAY,
-    hour: 1000 * 60 * 60,
-    minute: 1000 * 60,
-    second: 1000,
-    millisecond: 1
-};
-// default format if unspecified
-exports.DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%LZ";
-// Inclusive interval of date parts
-exports.DATE_PART_INTERVAL = [
-    ["year", 0, 9999],
-    ["month", 1, 12],
-    ["day", 1, 31],
-    ["hour", 0, 23],
-    ["minute", 0, 59],
-    ["second", 0, 59],
-    ["millisecond", 0, 999]
-];
-// used for formatting dates in $dateToString operator
-exports.DATE_SYM_TABLE = {
-    "%Y": { name: "year", padding: 4, re: /([0-9]{4})/ },
-    "%G": { name: "year", padding: 4, re: /([0-9]{4})/ },
-    "%m": { name: "month", padding: 2, re: /(0[1-9]|1[012])/ },
-    "%d": { name: "day", padding: 2, re: /(0[1-9]|[12][0-9]|3[01])/ },
-    "%H": { name: "hour", padding: 2, re: /([01][0-9]|2[0-3])/ },
-    "%M": { name: "minute", padding: 2, re: /([0-5][0-9])/ },
-    "%S": { name: "second", padding: 2, re: /([0-5][0-9]|60)/ },
-    "%L": { name: "millisecond", padding: 3, re: /([0-9]{3})/ },
-    "%u": { name: "weekday", padding: 1, re: /([1-7])/ },
-    "%U": { name: "week", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },
-    "%V": { name: "isoWeek", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },
-    "%z": {
-        name: "timezone",
-        padding: 2,
-        re: /(([+-][01][0-9]|2[0-3]):?([0-5][0-9])?)/
-    },
-    "%Z": { name: "minuteOffset", padding: 3, re: /([+-][0-9]{3})/ }
-    // "%%": "%",
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Parse and return the timezone string as a number
- * @param tzstr Timezone string matching '+/-hh[:][mm]'
- */
-function parseTimezone(tzstr) {
-    if ((0, util_1.isNil)(tzstr))
-        return 0;
-    const m = exports.DATE_SYM_TABLE["%z"].re.exec(tzstr);
-    if (!m)
-        throw Error(`invalid or location-based timezone '${tzstr}' not supported`);
-    const hr = parseInt(m[2]) || 0;
-    const min = parseInt(m[3]) || 0;
-    return (Math.abs(hr * exports.MINUTES_PER_HOUR) + min) * (hr < 0 ? -1 : 1);
-}
-exports.parseTimezone = parseTimezone;
-/**
- * Formats the timezone for output
- * @param tz A timezone object
- */
-function formatTimezone(minuteOffset) {
-    return ((minuteOffset < 0 ? "-" : "+") +
-        padDigits(Math.abs(Math.floor(minuteOffset / exports.MINUTES_PER_HOUR)), 2) +
-        padDigits(Math.abs(minuteOffset) % exports.MINUTES_PER_HOUR, 2));
-}
-exports.formatTimezone = formatTimezone;
-/**
- * Adjust the date by the given timezone
- * @param d Date object
- * @param minuteOffset number
- */
-function adjustDate(d, minuteOffset) {
-    d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);
-}
-exports.adjustDate = adjustDate;
-/**
- * Computes a date expression
- * @param obj The target object
- * @param expr Any value that resolves to a valid date expression. Valid expressions include a number, Date, or Object{date: number|Date, timezone?: string}
- */
-function computeDate(obj, expr, options) {
-    const d = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isDate)(d))
-        return new Date(d);
-    // timestamp is in seconds
-    if ((0, util_1.isNumber)(d))
-        return new Date(d * 1000);
-    if (d.date) {
-        const date = (0, util_1.isDate)(d.date) ? new Date(d.date) : new Date(d.date * 1000);
-        if (d.timezone) {
-            adjustDate(date, parseTimezone(d.timezone));
-        }
-        return date;
-    }
-    throw Error(`cannot convert ${expr === null || expr === void 0 ? void 0 : expr.toString()} to date`);
-}
-exports.computeDate = computeDate;
-function padDigits(n, digits) {
-    return (new Array(Math.max(digits - String(n).length + 1, 0)).join("0") +
-        n.toString());
-}
-exports.padDigits = padDigits;
-function regexQuote(s) {
-    "^.-*?$".split("").forEach((c) => {
-        s = s.replace(c, `\\${c}`);
-    });
-    return s;
-}
-exports.regexQuote = regexQuote;
-function regexStrip(s) {
-    return s.replace(/^\//, "").replace(/\/$/, "");
-}
-exports.regexStrip = regexStrip;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var month_exports = {};
+__export(month_exports, {
+  $month: () => $month
+});
+module.exports = __toCommonJS(month_exports);
+var import_internal = __webpack_require__(1277);
+const $month = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCMonth() + 1;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9784:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9549:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateAdd = void 0;
-const core_1 = __webpack_require__(9587);
-const _internal_1 = __webpack_require__(7974);
-/**
- * Increments a Date object by a specified number of time units.
- * @param obj
- * @param expr
- */
-const $dateAdd = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const d = (0, _internal_1.computeDate)(obj, expr.startDate, options);
-    switch (args.unit) {
-        case "year":
-            d.setUTCFullYear(d.getUTCFullYear() + args.amount);
-            break;
-        case "quarter":
-            addMonth(d, 3 * args.amount);
-            break;
-        case "month":
-            addMonth(d, args.amount);
-            break;
-        default:
-            d.setTime(d.getTime() + _internal_1.DURATION_IN_MILLIS[args.unit] * args.amount);
-    }
-    if (args.timezone) {
-        const tz = (0, _internal_1.parseTimezone)(args.timezone);
-        (0, _internal_1.adjustDate)(d, tz);
-    }
-    return d;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$dateAdd = $dateAdd;
-function addMonth(d, amount) {
-    // months start from 0 to 11.
-    const m = d.getUTCMonth() + amount;
-    const yearOffset = Math.floor(m / 12);
-    if (m < 0) {
-        const month = (m % 12) + 12;
-        d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());
-    }
-    else {
-        d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());
-    }
-}
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var second_exports = {};
+__export(second_exports, {
+  $second: () => $second
+});
+module.exports = __toCommonJS(second_exports);
+var import_internal = __webpack_require__(1277);
+const $second = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCSeconds();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6145:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2813:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateDiff = void 0;
-const core_1 = __webpack_require__(9587);
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the difference between two dates.
- * @param obj
- * @param expr
- * @param options Options
- */
-const $dateDiff = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const d1 = (0, _internal_1.computeDate)(obj, expr.startDate, options);
-    const d2 = (0, _internal_1.computeDate)(obj, expr.endDate, options);
-    let diff;
-    switch (args.unit) {
-        case "year":
-        case "quarter":
-        case "month":
-            diff = diffYQM(d1, d2, args.unit);
-            break;
-        default:
-            diff = (d2.getTime() - d1.getTime()) / _internal_1.DURATION_IN_MILLIS[args.unit];
-    }
-    return diff;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$dateDiff = $dateDiff;
-const unitMonths = {
-    year: 12,
-    quarter: 3,
-    month: 1
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-function diffYQM(d1, d2, unit) {
-    let months = (d2.getUTCFullYear() - d1.getUTCFullYear()) * 12;
-    months -= d1.getUTCMonth();
-    months += d2.getUTCMonth();
-    return Math.trunc(months / unitMonths[unit]);
-}
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var week_exports = {};
+__export(week_exports, {
+  $week: () => $week
+});
+module.exports = __toCommonJS(week_exports);
+var import_internal = __webpack_require__(1277);
+const $week = (obj, expr, options) => {
+  const d = (0, import_internal.computeDate)(obj, expr, options);
+  const result = (0, import_internal.isoWeek)(d);
+  if (d.getUTCDay() > 0 && d.getUTCDate() == 1 && d.getUTCMonth() == 0)
+    return 0;
+  if (d.getUTCDay() == 0) return result + 1;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6723:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2880:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateFromParts = void 0;
-const core_1 = __webpack_require__(9587);
-const _internal_1 = __webpack_require__(7974);
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const getDaysInMonth = (date) => {
-    return date.month == 2 && (0, _internal_1.isLeapYear)(date.year)
-        ? 29
-        : DAYS_IN_MONTH[date.month - 1];
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Constructs and returns a Date object given the date’s constituent properties.
- *
- * @param obj The document
- * @param expr The date expression
- * @param options Options
- */
-const $dateFromParts = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const minuteOffset = (0, _internal_1.parseTimezone)(args.timezone);
-    // assign default and adjust value ranges of the different parts
-    for (let i = _internal_1.DATE_PART_INTERVAL.length - 1, remainder = 0; i >= 0; i--) {
-        const datePartInterval = _internal_1.DATE_PART_INTERVAL[i];
-        const k = datePartInterval[0];
-        const min = datePartInterval[1];
-        const max = datePartInterval[2];
-        // add remainder from previous part. units should already be correct
-        let part = (args[k] || 0) + remainder;
-        // reset remainder now that it's been used.
-        remainder = 0;
-        // 1. compute the remainder for the next part
-        // 2. adjust the current part to a valid range
-        // 3. assign back to 'args'
-        const limit = max + 1;
-        // invert timezone to adjust the hours to UTC
-        if (k == "hour")
-            part += Math.floor(minuteOffset / _internal_1.MINUTES_PER_HOUR) * -1;
-        if (k == "minute")
-            part += (minuteOffset % _internal_1.MINUTES_PER_HOUR) * -1;
-        // smaller than lower bound
-        if (part < min) {
-            const delta = min - part;
-            remainder = -1 * Math.ceil(delta / limit);
-            part = limit - (delta % limit);
-        }
-        else if (part > max) {
-            // offset with the 'min' value to adjust non-zero date parts correctly
-            part += min;
-            remainder = Math.trunc(part / limit);
-            part %= limit;
-        }
-        // reassign
-        args[k] = part;
-    }
-    // adjust end of month to correctly handle overflows
-    args.day = Math.min(args.day, getDaysInMonth(args));
-    return new Date(Date.UTC(args.year, args.month - 1, args.day, args.hour, args.minute, args.second, args.millisecond));
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var year_exports = {};
+__export(year_exports, {
+  $year: () => $year
+});
+module.exports = __toCommonJS(year_exports);
+var import_internal = __webpack_require__(1277);
+const $year = (obj, expr, options) => {
+  return (0, import_internal.computeDate)(obj, expr, options).getUTCFullYear();
 };
-exports.$dateFromParts = $dateFromParts;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5342:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5764:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateFromString = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(7974);
-const buildMap = (letters, sign) => {
-    const h = {};
-    letters.split("").forEach((v, i) => (h[v] = sign * (i + 1)));
-    return h;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-const TZ_LETTER_OFFSETS = Object.assign(Object.assign(Object.assign({}, buildMap("ABCDEFGHIKLM", 1)), buildMap("NOPQRSTUVWXY", -1)), { Z: 0 });
-/**
- * Converts a date/time string to a date object.
- * @param obj
- * @param expr
- */
-const $dateFromString = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    args.format = args.format || _internal_1.DATE_FORMAT;
-    args.onNull = args.onNull || null;
-    let dateString = args.dateString;
-    if ((0, util_1.isNil)(dateString))
-        return args.onNull;
-    // collect all separators of the format string
-    const separators = args.format.split(/%[YGmdHMSLuVzZ]/);
-    separators.reverse();
-    const matches = args.format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%V|%z|%Z)/g);
-    const dateParts = {};
-    // holds the valid regex of parts that matches input date string
-    let expectedPattern = "";
-    for (let i = 0, len = matches.length; i < len; i++) {
-        const formatSpecifier = matches[i];
-        const props = _internal_1.DATE_SYM_TABLE[formatSpecifier];
-        if ((0, util_1.isObject)(props)) {
-            // get pattern and alias from table
-            const m = props.re.exec(dateString);
-            // get the next separtor
-            const delimiter = separators.pop() || "";
-            if (m !== null) {
-                // store and cut out matched part
-                dateParts[props.name] = /^\d+$/.exec(m[0]) ? parseInt(m[0]) : m[0];
-                dateString =
-                    dateString.substr(0, m.index) +
-                        dateString.substr(m.index + m[0].length);
-                // construct expected pattern
-                expectedPattern +=
-                    (0, _internal_1.regexQuote)(delimiter) + (0, _internal_1.regexStrip)(props.re.toString());
-            }
-            else {
-                dateParts[props.name] = null;
-            }
-        }
-    }
-    // 1. validate all required date parts exists
-    // 2. validate original dateString against expected pattern.
-    if ((0, util_1.isNil)(dateParts.year) ||
-        (0, util_1.isNil)(dateParts.month) ||
-        (0, util_1.isNil)(dateParts.day) ||
-        !new RegExp("^" + expectedPattern + "[A-Z]?$").exec(args.dateString)) {
-        return args.onError;
-    }
-    const m = args.dateString.match(/([A-Z])$/);
-    (0, util_1.assert)(
-    // only one of in-date timeone or timezone argument but not both.
-    !(m && args.timezone), `$dateFromString: you cannot pass in a date/time string with time zone information ('${m && m[0]}') together with a timezone argument`);
-    const minuteOffset = m
-        ? TZ_LETTER_OFFSETS[m[0]] * _internal_1.MINUTES_PER_HOUR
-        : (0, _internal_1.parseTimezone)(args.timezone);
-    // create the date. month is 0-based in Date
-    const d = new Date(Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0));
-    if (!(0, util_1.isNil)(dateParts.hour))
-        d.setUTCHours(dateParts.hour);
-    if (!(0, util_1.isNil)(dateParts.minute))
-        d.setUTCMinutes(dateParts.minute);
-    if (!(0, util_1.isNil)(dateParts.second))
-        d.setUTCSeconds(dateParts.second);
-    if (!(0, util_1.isNil)(dateParts.millisecond))
-        d.setUTCMilliseconds(dateParts.millisecond);
-    // adjust to the correct represention for UTC
-    (0, _internal_1.adjustDate)(d, -minuteOffset);
-    return d;
-};
-exports.$dateFromString = $dateFromString;
-
-
-/***/ }),
-
-/***/ 9051:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expression_exports = {};
+module.exports = __toCommonJS(expression_exports);
+__reExport(expression_exports, __webpack_require__(4125), module.exports);
+__reExport(expression_exports, __webpack_require__(2846), module.exports);
+__reExport(expression_exports, __webpack_require__(5148), module.exports);
+__reExport(expression_exports, __webpack_require__(1703), module.exports);
+__reExport(expression_exports, __webpack_require__(3336), module.exports);
+__reExport(expression_exports, __webpack_require__(5459), module.exports);
+__reExport(expression_exports, __webpack_require__(6518), module.exports);
+__reExport(expression_exports, __webpack_require__(3381), module.exports);
+__reExport(expression_exports, __webpack_require__(5535), module.exports);
+__reExport(expression_exports, __webpack_require__(6808), module.exports);
+__reExport(expression_exports, __webpack_require__(6789), module.exports);
+__reExport(expression_exports, __webpack_require__(3450), module.exports);
+__reExport(expression_exports, __webpack_require__(5053), module.exports);
+__reExport(expression_exports, __webpack_require__(5731), module.exports);
+__reExport(expression_exports, __webpack_require__(7620), module.exports);
+__reExport(expression_exports, __webpack_require__(7367), module.exports);
+__reExport(expression_exports, __webpack_require__(1377), module.exports);
+__reExport(expression_exports, __webpack_require__(2537), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 5535:
+/***/ ((module) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateSubtract = void 0;
-const core_1 = __webpack_require__(9587);
-const dateAdd_1 = __webpack_require__(9784);
-/**
- * Decrements a Date object by a specified number of time units.
- * @param obj
- * @param expr
- */
-const $dateSubtract = (obj, expr, options) => {
-    const amount = (0, core_1.computeValue)(obj, expr === null || expr === void 0 ? void 0 : expr.amount, null, options);
-    return (0, dateAdd_1.$dateAdd)(obj, Object.assign(Object.assign({}, expr), { amount: -1 * amount }), options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$dateSubtract = $dateSubtract;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var literal_exports = {};
+__export(literal_exports, {
+  $literal: () => $literal
+});
+module.exports = __toCommonJS(literal_exports);
+const $literal = (_obj, expr, _options) => expr;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 281:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6808:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateToParts = void 0;
-const core_1 = __webpack_require__(9587);
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns a document that contains the constituent parts of a given Date value as individual properties.
- * The properties returned are year, month, day, hour, minute, second and millisecond.
- *
- * @param obj
- * @param expr
- * @param options
- */
-const $dateToParts = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const d = new Date(args.date);
-    const tz = (0, _internal_1.parseTimezone)(args.timezone);
-    (0, _internal_1.adjustDate)(d, tz);
-    const timePart = {
-        hour: d.getUTCHours(),
-        minute: d.getUTCMinutes(),
-        second: d.getUTCSeconds(),
-        millisecond: d.getUTCMilliseconds()
-    };
-    if (args.iso8601 == true) {
-        return Object.assign(timePart, {
-            isoWeekYear: (0, _internal_1.isoWeekYear)(d),
-            isoWeek: (0, _internal_1.isoWeek)(d),
-            isoDayOfWeek: d.getUTCDay() || 7
-        });
-    }
-    return Object.assign(timePart, {
-        year: d.getUTCFullYear(),
-        month: d.getUTCMonth() + 1,
-        day: d.getUTCDate()
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$dateToParts = $dateToParts;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var median_exports = {};
+__export(median_exports, {
+  $median: () => $median
+});
+module.exports = __toCommonJS(median_exports);
+var import_core = __webpack_require__(2760);
+var import_median = __webpack_require__(9524);
+const $median = (obj, expr, options) => {
+  const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  return (0, import_median.$median)(input, { input: "$$CURRENT" }, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1300:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 257:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dateToString = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(7974);
-const dayOfMonth_1 = __webpack_require__(5327);
-const hour_1 = __webpack_require__(5882);
-const isoDayOfWeek_1 = __webpack_require__(404);
-const isoWeek_1 = __webpack_require__(9812);
-const millisecond_1 = __webpack_require__(1338);
-const minute_1 = __webpack_require__(5337);
-const month_1 = __webpack_require__(6879);
-const second_1 = __webpack_require__(743);
-const week_1 = __webpack_require__(626);
-const year_1 = __webpack_require__(8546);
-// date functions for format specifiers
-const DATE_FUNCTIONS = {
-    "%Y": year_1.$year,
-    "%G": year_1.$year,
-    "%m": month_1.$month,
-    "%d": dayOfMonth_1.$dayOfMonth,
-    "%H": hour_1.$hour,
-    "%M": minute_1.$minute,
-    "%S": second_1.$second,
-    "%L": millisecond_1.$millisecond,
-    "%u": isoDayOfWeek_1.$isoDayOfWeek,
-    "%U": week_1.$week,
-    "%V": isoWeek_1.$isoWeek
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Returns the date as a formatted string.
- *
- * %d	Day of Month (2 digits, zero padded)	01-31
- * %G	Year in ISO 8601 format	0000-9999
- * %H	Hour (2 digits, zero padded, 24-hour clock)	00-23
- * %L	Millisecond (3 digits, zero padded)	000-999
- * %m	Month (2 digits, zero padded)	01-12
- * %M	Minute (2 digits, zero padded)	00-59
- * %S	Second (2 digits, zero padded)	00-60
- * %u	Day of week number in ISO 8601 format (1-Monday, 7-Sunday)	1-7
- * %V	Week of Year in ISO 8601 format	1-53
- * %Y	Year (4 digits, zero padded)	0000-9999
- * %z	The timezone offset from UTC.	+/-[hh][mm]
- * %Z	The minutes offset from UTC as a number. For example, if the timezone offset (+/-[hhmm]) was +0445, the minutes offset is +285.	+/-mmm
- * %%	Percent Character as a Literal	%
- *
- * @param obj current object
- * @param expr operator expression
- */
-const $dateToString = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(args.onNull))
-        args.onNull = null;
-    if ((0, util_1.isNil)(args.date))
-        return args.onNull;
-    const date = (0, _internal_1.computeDate)(obj, args.date, options);
-    let format = args.format || _internal_1.DATE_FORMAT;
-    const minuteOffset = (0, _internal_1.parseTimezone)(args.timezone);
-    const matches = format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%U|%V|%z|%Z)/g);
-    // adjust the date to reflect timezone
-    (0, _internal_1.adjustDate)(date, minuteOffset);
-    for (let i = 0, len = matches.length; i < len; i++) {
-        const formatSpecifier = matches[i];
-        const props = _internal_1.DATE_SYM_TABLE[formatSpecifier];
-        const operatorFn = DATE_FUNCTIONS[formatSpecifier];
-        let value;
-        if ((0, util_1.isObject)(props)) {
-            // reuse date
-            if (props.name === "timezone") {
-                value = (0, _internal_1.formatTimezone)(minuteOffset);
-            }
-            else if (props.name === "minuteOffset") {
-                value = minuteOffset.toString();
-            }
-            else {
-                (0, util_1.assert)(!!operatorFn, `unsupported date format specifier '${formatSpecifier}'`);
-                value = (0, _internal_1.padDigits)(operatorFn(obj, date, options), props.padding);
-            }
-        }
-        // replace the match with resolved value
-        format = format.replace(formatSpecifier, value);
-    }
-    return format;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getField_exports = {};
+__export(getField_exports, {
+  $getField: () => $getField
+});
+module.exports = __toCommonJS(getField_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $getField = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const [field, input] = (0, import_util.isObject)(args) ? [args.field, args.input || obj] : [args, obj];
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isObject)(input),
+    "$getField expression 'input' must evaluate to an object"
+  );
+  (0, import_util.assert)(
+    (0, import_util.isString)(field),
+    "$getField expression 'field' must evaluate to a string"
+  );
+  return input[field];
 };
-exports.$dateToString = $dateToString;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5327:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6789:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dayOfMonth = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the day of the month for a date as a number between 1 and 31.
- * @param obj
- * @param expr
- */
-const $dayOfMonth = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDate();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$dayOfMonth = $dayOfMonth;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var misc_exports = {};
+module.exports = __toCommonJS(misc_exports);
+__reExport(misc_exports, __webpack_require__(257), module.exports);
+__reExport(misc_exports, __webpack_require__(438), module.exports);
+__reExport(misc_exports, __webpack_require__(5969), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 982:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 438:
+/***/ ((module) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dayOfWeek = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the day of the week for a date as a number between 1 (Sunday) and 7 (Saturday).
- * @param obj
- * @param expr
- */
-const $dayOfWeek = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDay() + 1;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$dayOfWeek = $dayOfWeek;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rand_exports = {};
+__export(rand_exports, {
+  $rand: () => $rand
+});
+module.exports = __toCommonJS(rand_exports);
+const $rand = (_obj, _expr, _options) => Math.random();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 623:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5969:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$dayOfYear = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the day of the year for a date as a number between 1 and 366 (leap year).
- * @param obj
- * @param expr
- */
-const $dayOfYear = (obj, expr, options) => {
-    return (0, _internal_1.getDayOfYear)((0, _internal_1.computeDate)(obj, expr, options));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$dayOfYear = $dayOfYear;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sampleRate_exports = {};
+__export(sampleRate_exports, {
+  $sampleRate: () => $sampleRate
+});
+module.exports = __toCommonJS(sampleRate_exports);
+var import_core = __webpack_require__(2760);
+const $sampleRate = (obj, expr, options) => Math.random() <= (0, import_core.computeValue)(obj, expr, null, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5882:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3450:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$hour = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the hour for a date as a number between 0 and 23.
- * @param obj
- * @param expr
- */
-const $hour = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCHours();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$hour = $hour;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var object_exports = {};
+module.exports = __toCommonJS(object_exports);
+__reExport(object_exports, __webpack_require__(4420), module.exports);
+__reExport(object_exports, __webpack_require__(5013), module.exports);
+__reExport(object_exports, __webpack_require__(4392), module.exports);
+__reExport(object_exports, __webpack_require__(5159), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9173:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 4420:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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]; } };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeObjects_exports = {};
+__export(mergeObjects_exports, {
+  $mergeObjects: () => $mergeObjects
+});
+module.exports = __toCommonJS(mergeObjects_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $mergeObjects = (obj, expr, options) => {
+  const docs = (0, import_core.computeValue)(obj, expr, null, options) ?? [];
+  const acc = {};
+  for (const o of docs) {
+    if ((0, import_util.isNil)(o)) continue;
+    for (const k of Object.keys(o)) {
+      if (o[k] !== void 0) acc[k] = o[k];
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  }
+  return acc;
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9784), exports);
-__exportStar(__webpack_require__(6145), exports);
-__exportStar(__webpack_require__(6723), exports);
-__exportStar(__webpack_require__(5342), exports);
-__exportStar(__webpack_require__(9051), exports);
-__exportStar(__webpack_require__(281), exports);
-__exportStar(__webpack_require__(1300), exports);
-__exportStar(__webpack_require__(5327), exports);
-__exportStar(__webpack_require__(982), exports);
-__exportStar(__webpack_require__(623), exports);
-__exportStar(__webpack_require__(5882), exports);
-__exportStar(__webpack_require__(404), exports);
-__exportStar(__webpack_require__(9812), exports);
-__exportStar(__webpack_require__(1123), exports);
-__exportStar(__webpack_require__(1338), exports);
-__exportStar(__webpack_require__(5337), exports);
-__exportStar(__webpack_require__(6879), exports);
-__exportStar(__webpack_require__(743), exports);
-__exportStar(__webpack_require__(626), exports);
-__exportStar(__webpack_require__(8546), exports);
-
-
-/***/ }),
-
-/***/ 404:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-"use strict";
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$isoDayOfWeek = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the weekday number in ISO 8601 format, ranging from 1 (Monday) to 7 (Sunday).
- * @param obj
- * @param expr
- */
-const $isoDayOfWeek = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDay() || 7;
+/***/ }),
+
+/***/ 5013:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var objectToArray_exports = {};
+__export(objectToArray_exports, {
+  $objectToArray: () => $objectToArray
+});
+module.exports = __toCommonJS(objectToArray_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $objectToArray = (obj, expr, options) => {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(val)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isObject)(val),
+    `$objectToArray requires a document input, found: ${(0, import_util.typeOf)(val)}`
+  );
+  const entries = Object.entries(val);
+  const result = new Array(entries.length);
+  let i = 0;
+  for (const [k, v] of entries) {
+    result[i++] = { k, v };
+  }
+  return result;
 };
-exports.$isoDayOfWeek = $isoDayOfWeek;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9812:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4392:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$isoWeek = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the week number in ISO 8601 format, ranging from 1 to 53.
- * Week numbers start at 1 with the week (Monday through Sunday) that contains the year's first Thursday.
- * @param obj
- * @param expr
- */
-const $isoWeek = (obj, expr, options) => {
-    return (0, _internal_1.isoWeek)((0, _internal_1.computeDate)(obj, expr, options));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setField_exports = {};
+__export(setField_exports, {
+  $setField: () => $setField
+});
+module.exports = __toCommonJS(setField_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setField = (obj, expr, options) => {
+  const { input, field, value } = (0, import_core.computeValue)(
+    obj,
+    expr,
+    null,
+    options
+  );
+  if ((0, import_util.isNil)(input)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isObject)(input),
+    "$setField expression 'input' must evaluate to an object"
+  );
+  (0, import_util.assert)(
+    (0, import_util.isString)(field),
+    "$setField expression 'field' must evaluate to a string"
+  );
+  if (expr.value == "$$REMOVE") {
+    delete obj[field];
+  } else {
+    obj[field] = value;
+  }
+  return obj;
 };
-exports.$isoWeek = $isoWeek;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1123:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5159:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$isoWeekYear = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the year number in ISO 8601 format. The year starts with the Monday of week 1 and ends with the Sunday of the last week.
- * @param obj
- * @param expr
- */
-const $isoWeekYear = (obj, expr, options) => {
-    const d = (0, _internal_1.computeDate)(obj, expr, options);
-    return (d.getUTCFullYear() -
-        Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unsetField_exports = {};
+__export(unsetField_exports, {
+  $unsetField: () => $unsetField
+});
+module.exports = __toCommonJS(unsetField_exports);
+var import_setField = __webpack_require__(4392);
+const $unsetField = (obj, expr, options) => {
+  return (0, import_setField.$setField)(
+    obj,
+    {
+      ...expr,
+      value: "$$REMOVE"
+    },
+    options
+  );
 };
-exports.$isoWeekYear = $isoWeekYear;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1338:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5053:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$millisecond = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the milliseconds of a date as a number between 0 and 999.
- * @param obj
- * @param expr
- */
-const $millisecond = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMilliseconds();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var percentile_exports = {};
+__export(percentile_exports, {
+  $percentile: () => $percentile
+});
+module.exports = __toCommonJS(percentile_exports);
+var import_core = __webpack_require__(2760);
+var import_percentile = __webpack_require__(6393);
+const $percentile = (obj, expr, options) => {
+  const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  return (0, import_percentile.$percentile)(input, { ...expr, input: "$$CURRENT" }, options);
 };
-exports.$millisecond = $millisecond;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5337:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 337:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$minute = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the minute for a date as a number between 0 and 59.
- * @param obj
- * @param expr
- */
-const $minute = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMinutes();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$minute = $minute;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var allElementsTrue_exports = {};
+__export(allElementsTrue_exports, {
+  $allElementsTrue: () => $allElementsTrue
+});
+module.exports = __toCommonJS(allElementsTrue_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $allElementsTrue = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options)[0];
+  return args.every((v) => (0, import_util.truthy)(v, options.useStrictMode));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6879:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2961:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$month = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the month for a date as a number between 1 (January) and 12 (December).
- * @param obj
- * @param expr
- */
-const $month = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMonth() + 1;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var anyElementTrue_exports = {};
+__export(anyElementTrue_exports, {
+  $anyElementTrue: () => $anyElementTrue
+});
+module.exports = __toCommonJS(anyElementTrue_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $anyElementTrue = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options)[0];
+  return args.some((v) => (0, import_util.truthy)(v, options.useStrictMode));
 };
-exports.$month = $month;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 743:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5731:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$second = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the seconds for a date as a number between 0 and 60 (leap seconds).
- * @param obj
- * @param expr
- */
-const $second = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCSeconds();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$second = $second;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+module.exports = __toCommonJS(set_exports);
+__reExport(set_exports, __webpack_require__(337), module.exports);
+__reExport(set_exports, __webpack_require__(2961), module.exports);
+__reExport(set_exports, __webpack_require__(9432), module.exports);
+__reExport(set_exports, __webpack_require__(1962), module.exports);
+__reExport(set_exports, __webpack_require__(7750), module.exports);
+__reExport(set_exports, __webpack_require__(8189), module.exports);
+__reExport(set_exports, __webpack_require__(1476), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 626:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9432:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$week = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the week of the year for a date as a number between 0 and 53.
- * Weeks begin on Sundays, and week 1 begins with the first Sunday of the year. Days preceding the first Sunday of the year are in week 0
- * @param obj
- * @param expr
- */
-const $week = (obj, expr, options) => {
-    const d = (0, _internal_1.computeDate)(obj, expr, options);
-    const result = (0, _internal_1.isoWeek)(d);
-    // check for starting of year and adjust accordingly
-    if (d.getUTCDay() > 0 && d.getUTCDate() == 1 && d.getUTCMonth() == 0)
-        return 0;
-    // adjust for week start on Sunday
-    if (d.getUTCDay() == 0)
-        return result + 1;
-    // else
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setDifference_exports = {};
+__export(setDifference_exports, {
+  $setDifference: () => $setDifference
+});
+module.exports = __toCommonJS(setDifference_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setDifference = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(args), "$setDifference must be an arrays.");
+  if (args.some(import_util.isNil)) return null;
+  (0, import_util.assert)(args.length == 2, `$setDifference takes exactly 2 arguments.`);
+  (0, import_util.assert)(args.every(import_util.isArray), "$setDifference operands must be arrays.");
+  const m = import_util.ValueMap.init(options.hashFunction);
+  args[0].forEach((v) => m.set(v, true));
+  args[1].forEach((v) => m.delete(v));
+  return Array.from(m.keys());
 };
-exports.$week = $week;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8546:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1962:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$year = void 0;
-const _internal_1 = __webpack_require__(7974);
-/**
- * Returns the year for a date as a number (e.g. 2014).
- * @param obj
- * @param expr
- */
-const $year = (obj, expr, options) => {
-    return (0, _internal_1.computeDate)(obj, expr, options).getUTCFullYear();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$year = $year;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setEquals_exports = {};
+__export(setEquals_exports, {
+  $setEquals: () => $setEquals
+});
+module.exports = __toCommonJS(setEquals_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setEquals = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.every(import_util.isArray),
+    "$setEquals operands must be arrays."
+  );
+  const map = import_util.ValueMap.init();
+  args[0].every((v, i) => map.set(v, i));
+  for (let i = 1; i < args.length; i++) {
+    const arr = args[i];
+    const set = /* @__PURE__ */ new Set();
+    for (let j = 0; j < arr.length; j++) {
+      const n = map.get(arr[j]) ?? -1;
+      if (n === -1) return false;
+      set.add(n);
+    }
+    if (set.size !== map.size) return false;
+  }
+  return true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8985:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 7750:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(1744), exports);
-__exportStar(__webpack_require__(1613), exports);
-__exportStar(__webpack_require__(628), exports);
-__exportStar(__webpack_require__(4591), exports);
-__exportStar(__webpack_require__(5112), exports);
-__exportStar(__webpack_require__(4052), exports);
-__exportStar(__webpack_require__(9173), exports);
-__exportStar(__webpack_require__(5951), exports);
-__exportStar(__webpack_require__(2385), exports);
-__exportStar(__webpack_require__(6478), exports);
-__exportStar(__webpack_require__(8234), exports);
-__exportStar(__webpack_require__(9266), exports);
-__exportStar(__webpack_require__(4441), exports);
-__exportStar(__webpack_require__(1146), exports);
-__exportStar(__webpack_require__(4354), exports);
-
-
-/***/ }),
-
-/***/ 5951:
-/***/ ((__unused_webpack_module, exports) => {
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setIntersection_exports = {};
+__export(setIntersection_exports, {
+  $setIntersection: () => $setIntersection
+});
+module.exports = __toCommonJS(setIntersection_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setIntersection = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.every(import_util.isArray),
+    "$setIntersection operands must be arrays."
+  );
+  return (0, import_util.intersection)(args, options?.hashFunction);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-"use strict";
 
-// Literal Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#literal-expression-operator
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$literal = void 0;
-/**
- * Return a value without parsing.
- * @param obj
- * @param expr
- * @param options
- */
-const $literal = (_obj, expr, _options) => expr;
-exports.$literal = $literal;
+/***/ }),
 
+/***/ 8189:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/***/ }),
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setIsSubset_exports = {};
+__export(setIsSubset_exports, {
+  $setIsSubset: () => $setIsSubset
+});
+module.exports = __toCommonJS(setIsSubset_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setIsSubset = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.every(import_util.isArray),
+    "$setIsSubset operands must be arrays."
+  );
+  const first = args[0];
+  const second = args[1];
+  const map = import_util.ValueMap.init();
+  const set = /* @__PURE__ */ new Set();
+  first.every((v, i) => map.set(v, i));
+  for (const v of second) {
+    set.add(map.get(v) ?? -1);
+    if (set.size > map.size) return true;
+  }
+  set.delete(-1);
+  return set.size == map.size;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-/***/ 8848:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-"use strict";
+/***/ }),
 
-// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/rand/#mongodb-expression-exp.-rand
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$getField = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Adds, updates, or removes a specified field in a document.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $getField = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    let input = obj;
-    let field = args;
-    if ((0, util_1.isObject)(args) && args.input && args.field) {
-        input = args.input;
-        field = args.field;
-    }
-    if ((0, util_1.isNil)(input))
-        return null;
-    (0, util_1.assert)((0, util_1.isObject)(input), "$getField expression 'input' must evaluate to an object");
-    (0, util_1.assert)((0, util_1.isString)(field), "$getField expression 'field' must evaluate to a string");
-    return input[field];
+/***/ 1476:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setUnion_exports = {};
+__export(setUnion_exports, {
+  $setUnion: () => $setUnion
+});
+module.exports = __toCommonJS(setUnion_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $setUnion = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args)) return null;
+  (0, import_util.assert)((0, import_util.isArray)(args), "$setUnion operands must be arrays.");
+  if (args.some(import_util.isNil)) return null;
+  return (0, import_util.unique)((0, import_util.flatten)(args), options?.hashFunction);
 };
-exports.$getField = $getField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2385:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 9756:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(8848), exports);
-__exportStar(__webpack_require__(2746), exports);
-__exportStar(__webpack_require__(9468), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  regexSearch: () => regexSearch,
+  trimString: () => trimString
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const WHITESPACE_CHARS = [
+  0,
+  // '\0' Null character
+  32,
+  // ' ', Space
+  9,
+  // '\t' Horizontal tab
+  10,
+  // '\n' Line feed/new line
+  11,
+  // '\v' Vertical tab
+  12,
+  // '\f' Form feed
+  13,
+  // '\r' Carriage return
+  160,
+  // Non-breaking space
+  5760,
+  // Ogham space mark
+  8192,
+  // En quad
+  8193,
+  // Em quad
+  8194,
+  // En space
+  8195,
+  // Em space
+  8196,
+  // Three-per-em space
+  8197,
+  // Four-per-em space
+  8198,
+  // Six-per-em space
+  8199,
+  // Figure space
+  8200,
+  // Punctuation space
+  8201,
+  // Thin space
+  8202
+  // Hair space
+];
+function trimString(obj, expr, options, trimOpts) {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  const s = val.input;
+  if ((0, import_util.isNil)(s)) return null;
+  const codepoints = (0, import_util.isNil)(val.chars) ? WHITESPACE_CHARS : val.chars.split("").map((c) => c.codePointAt(0));
+  let i = 0;
+  let j = s.length - 1;
+  while (trimOpts.left && i <= j && codepoints.indexOf(s[i].codePointAt(0)) !== -1)
+    i++;
+  while (trimOpts.right && i <= j && codepoints.indexOf(s[j].codePointAt(0)) !== -1)
+    j--;
+  return s.substring(i, j + 1);
+}
+function regexSearch(obj, expr, options, reOpts) {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if (!(0, import_util.isString)(val.input)) return [];
+  const regexOptions = val.options;
+  if (regexOptions) {
+    (0, import_util.assert)(
+      regexOptions.indexOf("x") === -1,
+      "extended capability option 'x' not supported"
+    );
+    (0, import_util.assert)(regexOptions.indexOf("g") === -1, "global option 'g' not supported");
+  }
+  let input = val.input;
+  const re = new RegExp(val.regex, regexOptions);
+  let m;
+  const matches = new Array();
+  let offset = 0;
+  while (m = re.exec(input)) {
+    const result = {
+      match: m[0],
+      idx: m.index + offset,
+      captures: []
+    };
+    for (let i = 1; i < m.length; i++) result.captures.push(m[i] || null);
+    matches.push(result);
+    if (!reOpts.global) break;
+    offset = m.index + m[0].length;
+    input = input.substring(offset);
+  }
+  return matches;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2746:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 3266:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/rand/#mongodb-expression-exp.-rand
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$rand = void 0;
-/**
- * Returns a random float between 0 and 1.
- *
- * @param {*} _obj The target object for this expression
- * @param {*} _expr The right-hand side of the operator
- * @param {Options} _options Options to use for operation
- */
-const $rand = (_obj, _expr, _options) => Math.random();
-exports.$rand = $rand;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var concat_exports = {};
+__export(concat_exports, {
+  $concat: () => $concat
+});
+module.exports = __toCommonJS(concat_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $concat = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)(
+    args.every((v) => (0, import_util.isString)(v) || (0, import_util.isNil)(v)),
+    "$concat only supports strings."
+  );
+  if (args.some(import_util.isNil)) return null;
+  return args.join("");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9468:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 7620:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var string_exports = {};
+module.exports = __toCommonJS(string_exports);
+__reExport(string_exports, __webpack_require__(3266), module.exports);
+__reExport(string_exports, __webpack_require__(6586), module.exports);
+__reExport(string_exports, __webpack_require__(9148), module.exports);
+__reExport(string_exports, __webpack_require__(7724), module.exports);
+__reExport(string_exports, __webpack_require__(7205), module.exports);
+__reExport(string_exports, __webpack_require__(3798), module.exports);
+__reExport(string_exports, __webpack_require__(1541), module.exports);
+__reExport(string_exports, __webpack_require__(6942), module.exports);
+__reExport(string_exports, __webpack_require__(6070), module.exports);
+__reExport(string_exports, __webpack_require__(1612), module.exports);
+__reExport(string_exports, __webpack_require__(9587), module.exports);
+__reExport(string_exports, __webpack_require__(7993), module.exports);
+__reExport(string_exports, __webpack_require__(415), module.exports);
+__reExport(string_exports, __webpack_require__(9635), module.exports);
+__reExport(string_exports, __webpack_require__(5332), module.exports);
+__reExport(string_exports, __webpack_require__(356), module.exports);
+__reExport(string_exports, __webpack_require__(2174), module.exports);
+__reExport(string_exports, __webpack_require__(6459), module.exports);
+__reExport(string_exports, __webpack_require__(5158), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 6586:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#miscellaneous-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sampleRate = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Randomly select documents at a given rate.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $sampleRate = (obj, expr, options) => Math.random() <= (0, core_1.computeValue)(obj, expr, null, options);
-exports.$sampleRate = $sampleRate;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var indexOfBytes_exports = {};
+__export(indexOfBytes_exports, {
+  $indexOfBytes: () => $indexOfBytes
+});
+module.exports = __toCommonJS(indexOfBytes_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $indexOfBytes = (obj, expr, options) => {
+  const arr = (0, import_core.computeValue)(obj, expr, null, options);
+  const errorMsg = "$indexOfBytes expression resolves to invalid an argument";
+  if ((0, import_util.isNil)(arr[0])) return null;
+  (0, import_util.assert)((0, import_util.isString)(arr[0]) && (0, import_util.isString)(arr[1]), errorMsg);
+  const str = arr[0];
+  const searchStr = arr[1];
+  let start = arr[2];
+  let end = arr[3];
+  let valid = (0, import_util.isNil)(start) || (0, import_util.isNumber)(start) && start >= 0 && Math.round(start) === start;
+  valid = valid && ((0, import_util.isNil)(end) || (0, import_util.isNumber)(end) && end >= 0 && Math.round(end) === end);
+  (0, import_util.assert)(valid, errorMsg);
+  start = start || 0;
+  end = end || str.length;
+  if (start > end) return -1;
+  const index = str.substring(start, end).indexOf(searchStr);
+  return index > -1 ? index + start : index;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 9148:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ltrim_exports = {};
+__export(ltrim_exports, {
+  $ltrim: () => $ltrim
+});
+module.exports = __toCommonJS(ltrim_exports);
+var import_internal = __webpack_require__(9756);
+const $ltrim = (obj, expr, options) => {
+  return (0, import_internal.trimString)(obj, expr, options, { left: true, right: false });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6478:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 7724:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9531), exports);
-__exportStar(__webpack_require__(4137), exports);
-__exportStar(__webpack_require__(3514), exports);
-__exportStar(__webpack_require__(5432), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var regexFind_exports = {};
+__export(regexFind_exports, {
+  $regexFind: () => $regexFind
+});
+module.exports = __toCommonJS(regexFind_exports);
+var import_internal = __webpack_require__(9756);
+const $regexFind = (obj, expr, options) => {
+  const result = (0, import_internal.regexSearch)(obj, expr, options, { global: false });
+  return result && result.length > 0 ? result[0] : null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9531:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7205:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$mergeObjects = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Combines multiple documents into a single document.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $mergeObjects = (obj, expr, options) => {
-    const docs = (0, core_1.computeValue)(obj, expr, null, options);
-    return docs instanceof Array
-        ? docs.reduce((memo, o) => (0, util_1.into)(memo, o), {})
-        : {};
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$mergeObjects = $mergeObjects;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var regexFindAll_exports = {};
+__export(regexFindAll_exports, {
+  $regexFindAll: () => $regexFindAll
+});
+module.exports = __toCommonJS(regexFindAll_exports);
+var import_internal = __webpack_require__(9756);
+const $regexFindAll = (obj, expr, options) => {
+  return (0, import_internal.regexSearch)(obj, expr, options, { global: true });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4137:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3798:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$objectToArray = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Converts a document to an array of documents representing key-value pairs.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $objectToArray = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isObject)(val), "$objectToArray expression must resolve to an object");
-    const entries = Object.entries(val);
-    const result = new Array(entries.length);
-    let i = 0;
-    for (const [k, v] of entries) {
-        result[i++] = { k, v };
-    }
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$objectToArray = $objectToArray;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var regexMatch_exports = {};
+__export(regexMatch_exports, {
+  $regexMatch: () => $regexMatch
+});
+module.exports = __toCommonJS(regexMatch_exports);
+var import_internal = __webpack_require__(9756);
+const $regexMatch = (obj, expr, options) => {
+  return (0, import_internal.regexSearch)(obj, expr, options, { global: false }).length != 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3514:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1541:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setField = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Adds, updates, or removes a specified field in a document.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $setField = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(args.input))
-        return null;
-    (0, util_1.assert)((0, util_1.isObject)(args.input), "$setField expression 'input' must evaluate to an object");
-    (0, util_1.assert)((0, util_1.isString)(args.field), "$setField expression 'field' must evaluate to a string");
-    if (expr.value == "$$REMOVE") {
-        delete obj[args.field];
-    }
-    else {
-        obj[args.field] = args.value;
-    }
-    return obj;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$setField = $setField;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replaceAll_exports = {};
+__export(replaceAll_exports, {
+  $replaceAll: () => $replaceAll
+});
+module.exports = __toCommonJS(replaceAll_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $replaceAll = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const arr = [args.input, args.find, args.replacement];
+  if (arr.some(import_util.isNil)) return null;
+  (0, import_util.assert)(
+    arr.every(import_util.isString),
+    "$replaceAll expression fields must evaluate to string"
+  );
+  return args.input.replace(new RegExp(args.find, "g"), args.replacement);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5432:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6942:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$unsetField = void 0;
-const setField_1 = __webpack_require__(3514);
-/**
- * Adds, updates, or removes a specified field in a document.
- *
- * @param {*} obj The target object for this expression
- * @param {*} expr The right-hand side of the operator
- * @param {Options} options Options to use for operation
- */
-const $unsetField = (obj, expr, options) => {
-    return (0, setField_1.$setField)(obj, Object.assign(Object.assign({}, expr), { value: "$$REMOVE" }), options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$unsetField = $unsetField;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replaceOne_exports = {};
+__export(replaceOne_exports, {
+  $replaceOne: () => $replaceOne
+});
+module.exports = __toCommonJS(replaceOne_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $replaceOne = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const arr = [args.input, args.find, args.replacement];
+  if (arr.some(import_util.isNil)) return null;
+  (0, import_util.assert)(
+    arr.every(import_util.isString),
+    "$replaceOne expression fields must evaluate to string"
+  );
+  return args.input.replace(args.find, args.replacement);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9462:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6070:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$allElementsTrue = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true if all elements of a set evaluate to true, and false otherwise.
- * @param obj
- * @param expr
- */
-const $allElementsTrue = (obj, expr, options) => {
-    // mongodb nests the array expression in another
-    const args = (0, core_1.computeValue)(obj, expr, null, options)[0];
-    return args.every(v => (0, util_1.truthy)(v, options.useStrictMode));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rtrim_exports = {};
+__export(rtrim_exports, {
+  $rtrim: () => $rtrim
+});
+module.exports = __toCommonJS(rtrim_exports);
+var import_internal = __webpack_require__(9756);
+const $rtrim = (obj, expr, options) => {
+  return (0, import_internal.trimString)(obj, expr, options, { left: false, right: true });
 };
-exports.$allElementsTrue = $allElementsTrue;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5459:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1612:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$anyElementTrue = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true if any elements of a set evaluate to true, and false otherwise.
- * @param obj
- * @param expr
- */
-const $anyElementTrue = (obj, expr, options) => {
-    // mongodb nests the array expression in another
-    const args = (0, core_1.computeValue)(obj, expr, null, options)[0];
-    return args.some(v => (0, util_1.truthy)(v, options.useStrictMode));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var split_exports = {};
+__export(split_exports, {
+  $split: () => $split
+});
+module.exports = __toCommonJS(split_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $split = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(args[0])) return null;
+  (0, import_util.assert)(
+    args.every(import_util.isString),
+    "$split expression must result to array(2) of strings"
+  );
+  return args[0].split(args[1]);
 };
-exports.$anyElementTrue = $anyElementTrue;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8234:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 7993:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9462), exports);
-__exportStar(__webpack_require__(5459), exports);
-__exportStar(__webpack_require__(5403), exports);
-__exportStar(__webpack_require__(6155), exports);
-__exportStar(__webpack_require__(1860), exports);
-__exportStar(__webpack_require__(5810), exports);
-__exportStar(__webpack_require__(2409), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strLenBytes_exports = {};
+__export(strLenBytes_exports, {
+  $strLenBytes: () => $strLenBytes
+});
+module.exports = __toCommonJS(strLenBytes_exports);
+var import_core = __webpack_require__(2760);
+const $strLenBytes = (obj, expr, options) => {
+  return ~-encodeURI((0, import_core.computeValue)(obj, expr, null, options)).split(
+    /%..|./
+  ).length;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5403:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 415:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setDifference = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns elements of a set that do not appear in a second set.
- * @param obj
- * @param expr
- */
-const $setDifference = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return args[0].filter(util_1.notInArray.bind(null, args[1]));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strLenCP_exports = {};
+__export(strLenCP_exports, {
+  $strLenCP: () => $strLenCP
+});
+module.exports = __toCommonJS(strLenCP_exports);
+var import_core = __webpack_require__(2760);
+const $strLenCP = (obj, expr, options) => {
+  return (0, import_core.computeValue)(obj, expr, null, options).length;
 };
-exports.$setDifference = $setDifference;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6155:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9587:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setEquals = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true if two sets have the same elements.
- * @param obj
- * @param expr
- */
-const $setEquals = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const xs = (0, util_1.unique)(args[0], options === null || options === void 0 ? void 0 : options.hashFunction);
-    const ys = (0, util_1.unique)(args[1], options === null || options === void 0 ? void 0 : options.hashFunction);
-    return (xs.length === ys.length &&
-        xs.length === (0, util_1.intersection)([xs, ys], options === null || options === void 0 ? void 0 : options.hashFunction).length);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strcasecmp_exports = {};
+__export(strcasecmp_exports, {
+  $strcasecmp: () => $strcasecmp
+});
+module.exports = __toCommonJS(strcasecmp_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $strcasecmp = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  let a = args[0];
+  let b = args[1];
+  if ((0, import_util.isEqual)(a, b) || args.every(import_util.isNil)) return 0;
+  (0, import_util.assert)(
+    args.every(import_util.isString),
+    "$strcasecmp must resolve to array(2) of strings"
+  );
+  a = a.toUpperCase();
+  b = b.toUpperCase();
+  return a > b && 1 || a < b && -1 || 0;
 };
-exports.$setEquals = $setEquals;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1860:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9635:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setIntersection = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the common elements of the input sets.
- * @param obj
- * @param expr
- */
-const $setIntersection = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(args) && args.every(util_1.isArray), "$setIntersection: expresssion must resolve to array of arrays");
-    return (0, util_1.intersection)(args, options === null || options === void 0 ? void 0 : options.hashFunction);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$setIntersection = $setIntersection;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var substr_exports = {};
+__export(substr_exports, {
+  $substr: () => $substr
+});
+module.exports = __toCommonJS(substr_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $substr = (obj, expr, options) => {
+  const [s, start, count] = (0, import_core.computeValue)(obj, expr, null, options);
+  if (start < 0 || !(0, import_util.isString)(s)) return "";
+  if (count < 0) return s.substring(start);
+  return s.substring(start, start + count);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5810:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5332:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setIsSubset = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns true if all elements of a set appear in a second set.
- * @param obj
- * @param expr
- */
-const $setIsSubset = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.intersection)(args, options === null || options === void 0 ? void 0 : options.hashFunction).length === args[0].length;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var substrBytes_exports = {};
+__export(substrBytes_exports, {
+  $substrBytes: () => $substrBytes
+});
+module.exports = __toCommonJS(substrBytes_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const UTF8_MASK = [192, 224, 240];
+function toUtf8(n) {
+  if (n < 128) return [n];
+  let count = n < 2048 && 1 || n < 65536 && 2 || 3;
+  const offset = UTF8_MASK[count - 1];
+  const utf8 = [(n >> 6 * count) + offset];
+  while (count > 0) utf8.push(128 | n >> 6 * --count & 63);
+  return utf8;
+}
+function utf8Encode(s) {
+  const buf = [];
+  for (let i = 0, len = s.length; i < len; i++) {
+    buf.push(toUtf8(s.codePointAt(i)));
+  }
+  return buf;
+}
+const $substrBytes = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  const s = args[0];
+  const index = args[1];
+  const count = args[2];
+  (0, import_util.assert)(
+    (0, import_util.isString)(s) && (0, import_util.isNumber)(index) && index >= 0 && (0, import_util.isNumber)(count) && count >= 0,
+    "$substrBytes: invalid arguments"
+  );
+  const buf = utf8Encode(s);
+  const validIndex = [];
+  let acc = 0;
+  for (let i = 0; i < buf.length; i++) {
+    validIndex.push(acc);
+    acc += buf[i].length;
+  }
+  const begin = validIndex.indexOf(index);
+  const end = validIndex.indexOf(index + count);
+  (0, import_util.assert)(
+    begin > -1 && end > -1,
+    "$substrBytes: invalid range, start or end index is a UTF-8 continuation byte."
+  );
+  return s.substring(begin, end);
 };
-exports.$setIsSubset = $setIsSubset;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2409:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 356:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setUnion = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a set that holds all elements of the input sets.
- * @param obj
- * @param expr
- */
-const $setUnion = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    (0, util_1.assert)((0, util_1.isArray)(args) && args.length == 2 && args.every(util_1.isArray), "$setUnion: arguments must be arrays");
-    return (0, util_1.unique)(args[0].concat(args[1]), options === null || options === void 0 ? void 0 : options.hashFunction);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var substrCP_exports = {};
+__export(substrCP_exports, {
+  $substrCP: () => $substrCP
+});
+module.exports = __toCommonJS(substrCP_exports);
+var import_substr = __webpack_require__(9635);
+const $substrCP = (obj, expr, options) => {
+  return (0, import_substr.$substr)(obj, expr, options);
 };
-exports.$setUnion = $setUnion;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3421:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2174:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.regexSearch = exports.trimString = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/* eslint-disable*/
-const WHITESPACE_CHARS = [
-    0x0000,
-    0x0020,
-    0x0009,
-    0x000a,
-    0x000b,
-    0x000c,
-    0x000d,
-    0x00a0,
-    0x1680,
-    0x2000,
-    0x2001,
-    0x2002,
-    0x2003,
-    0x2004,
-    0x2005,
-    0x2006,
-    0x2007,
-    0x2008,
-    0x2009,
-    0x200a // Hair space
-];
-/**
- * Trims the resolved string
- *
- * @param obj
- * @param expr
- * @param options
- */
-function trimString(obj, expr, options, trimOpts) {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    const s = val.input;
-    if ((0, util_1.isNil)(s))
-        return null;
-    const codepoints = (0, util_1.isNil)(val.chars)
-        ? WHITESPACE_CHARS
-        : val.chars.split("").map((c) => c.codePointAt(0));
-    let i = 0;
-    let j = s.length - 1;
-    while (trimOpts.left &&
-        i <= j &&
-        codepoints.indexOf(s[i].codePointAt(0)) !== -1)
-        i++;
-    while (trimOpts.right &&
-        i <= j &&
-        codepoints.indexOf(s[j].codePointAt(0)) !== -1)
-        j--;
-    return s.substring(i, j + 1);
-}
-exports.trimString = trimString;
-/**
- * Performs a regex search
- *
- * @param obj
- * @param expr
- * @param opts
- */
-function regexSearch(obj, expr, options, reOpts) {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if (!(0, util_1.isString)(val.input))
-        return [];
-    const regexOptions = val.options;
-    if (regexOptions) {
-        (0, util_1.assert)(regexOptions.indexOf("x") === -1, "extended capability option 'x' not supported");
-        (0, util_1.assert)(regexOptions.indexOf("g") === -1, "global option 'g' not supported");
-    }
-    let input = val.input;
-    const re = new RegExp(val.regex, regexOptions);
-    let m;
-    const matches = new Array();
-    let offset = 0;
-    while ((m = re.exec(input))) {
-        const result = {
-            match: m[0],
-            idx: m.index + offset,
-            captures: []
-        };
-        for (let i = 1; i < m.length; i++)
-            result.captures.push(m[i] || null);
-        matches.push(result);
-        if (!reOpts.global)
-            break;
-        offset = m.index + m[0].length;
-        input = input.substring(offset);
-    }
-    return matches;
-}
-exports.regexSearch = regexSearch;
-/*eslint-enable*/
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toLower_exports = {};
+__export(toLower_exports, {
+  $toLower: () => $toLower
+});
+module.exports = __toCommonJS(toLower_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $toLower = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isEmpty)(value) ? "" : value.toLowerCase();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8995:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6459:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$concat = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Concatenates two strings.
- *
- * @param obj
- * @param expr
- * @returns {string|*}
- */
-const $concat = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    // does not allow concatenation with nulls
-    if ([null, undefined].some(util_1.inArray.bind(null, args)))
-        return null;
-    return args.join("");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toUpper_exports = {};
+__export(toUpper_exports, {
+  $toUpper: () => $toUpper
+});
+module.exports = __toCommonJS(toUpper_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $toUpper = (obj, expr, options) => {
+  const value = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isEmpty)(value) ? "" : value.toUpperCase();
 };
-exports.$concat = $concat;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9266:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 5158:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(8995), exports);
-__exportStar(__webpack_require__(3375), exports);
-__exportStar(__webpack_require__(1366), exports);
-__exportStar(__webpack_require__(5649), exports);
-__exportStar(__webpack_require__(7258), exports);
-__exportStar(__webpack_require__(7433), exports);
-__exportStar(__webpack_require__(4385), exports);
-__exportStar(__webpack_require__(3869), exports);
-__exportStar(__webpack_require__(3648), exports);
-__exportStar(__webpack_require__(7066), exports);
-__exportStar(__webpack_require__(3868), exports);
-__exportStar(__webpack_require__(3837), exports);
-__exportStar(__webpack_require__(5292), exports);
-__exportStar(__webpack_require__(8378), exports);
-__exportStar(__webpack_require__(7476), exports);
-__exportStar(__webpack_require__(4098), exports);
-__exportStar(__webpack_require__(7013), exports);
-__exportStar(__webpack_require__(310), exports);
-__exportStar(__webpack_require__(8745), exports);
-
-
-/***/ }),
-
-/***/ 3375:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$indexOfBytes = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Searches a string for an occurrence of a substring and returns the UTF-8 code point index of the first occurence.
- * If the substring is not found, returns -1.
- *
- * @param  {Object} obj
- * @param  {*} expr
- * @return {*}
- */
-const $indexOfBytes = (obj, expr, options) => {
-    const arr = (0, core_1.computeValue)(obj, expr, null, options);
-    const errorMsg = "$indexOfBytes expression resolves to invalid an argument";
-    if ((0, util_1.isNil)(arr[0]))
-        return null;
-    (0, util_1.assert)((0, util_1.isString)(arr[0]) && (0, util_1.isString)(arr[1]), errorMsg);
-    const str = arr[0];
-    const searchStr = arr[1];
-    let start = arr[2];
-    let end = arr[3];
-    let valid = (0, util_1.isNil)(start) ||
-        ((0, util_1.isNumber)(start) && start >= 0 && Math.round(start) === start);
-    valid =
-        valid &&
-            ((0, util_1.isNil)(end) || ((0, util_1.isNumber)(end) && end >= 0 && Math.round(end) === end));
-    (0, util_1.assert)(valid, errorMsg);
-    start = start || 0;
-    end = end || str.length;
-    if (start > end)
-        return -1;
-    const index = str.substring(start, end).indexOf(searchStr);
-    return index > -1 ? index + start : index;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trim_exports = {};
+__export(trim_exports, {
+  $trim: () => $trim
+});
+module.exports = __toCommonJS(trim_exports);
+var import_internal = __webpack_require__(9756);
+const $trim = (obj, expr, options) => {
+  return (0, import_internal.trimString)(obj, expr, options, { left: true, right: true });
 };
-exports.$indexOfBytes = $indexOfBytes;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1366:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1291:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ltrim = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Removes whitespace characters, including null, or the specified characters from the beginning of a string.
- *
- * @param obj
- * @param expr
- */
-const $ltrim = (obj, expr, options) => {
-    return (0, _internal_1.trimString)(obj, expr, options, { left: true, right: false });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$ltrim = $ltrim;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  createTrignometryOperator: () => createTrignometryOperator
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const FIXED_POINTS = {
+  undefined: null,
+  null: null,
+  NaN: NaN,
+  Infinity: new Error(),
+  "-Infinity": new Error()
+};
+function createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {
+  const fp = Object.assign({}, FIXED_POINTS, fixedPoints);
+  const keySet = new Set(Object.keys(fp));
+  return (obj, expr, options) => {
+    const n = (0, import_core.computeValue)(obj, expr, null, options);
+    if (keySet.has(`${n}`)) {
+      const res = fp[`${n}`];
+      if (res instanceof Error) {
+        throw new import_util.MingoError(
+          `cannot apply $${f.name} to -inf, value must in (-inf,inf)`
+        );
+      }
+      return res;
+    }
+    return f(n);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5649:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 1025:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var acos_exports = {};
+__export(acos_exports, {
+  $acos: () => $acos
+});
+module.exports = __toCommonJS(acos_exports);
+var import_internal = __webpack_require__(1291);
+const $acos = (0, import_internal.createTrignometryOperator)(Math.acos, {
+  Infinity: Infinity,
+  0: new Error()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$regexFind = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Applies a regular expression (regex) to a string and returns information on the first matched substring.
- *
- * @param obj
- * @param expr
- */
-const $regexFind = (obj, expr, options) => {
-    const result = (0, _internal_1.regexSearch)(obj, expr, options, { global: false });
-    return result && result.length > 0 ? result[0] : null;
+
+/***/ }),
+
+/***/ 9637:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$regexFind = $regexFind;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var acosh_exports = {};
+__export(acosh_exports, {
+  $acosh: () => $acosh
+});
+module.exports = __toCommonJS(acosh_exports);
+var import_internal = __webpack_require__(1291);
+const $acosh = (0, import_internal.createTrignometryOperator)(Math.acosh, {
+  Infinity: Infinity,
+  0: new Error()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7258:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8000:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$regexFindAll = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Applies a regular expression (regex) to a string and returns information on the all matched substrings.
- *
- * @param obj
- * @param expr
- */
-const $regexFindAll = (obj, expr, options) => {
-    return (0, _internal_1.regexSearch)(obj, expr, options, { global: true });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$regexFindAll = $regexFindAll;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asin_exports = {};
+__export(asin_exports, {
+  $asin: () => $asin
+});
+module.exports = __toCommonJS(asin_exports);
+var import_internal = __webpack_require__(1291);
+const $asin = (0, import_internal.createTrignometryOperator)(Math.asin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7433:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8634:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$regexMatch = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Applies a regular expression (regex) to a string and returns a boolean that indicates if a match is found or not.
- *
- * @param obj
- * @param expr
- */
-const $regexMatch = (obj, expr, options) => {
-    return (0, _internal_1.regexSearch)(obj, expr, options, { global: false }).length != 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$regexMatch = $regexMatch;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asinh_exports = {};
+__export(asinh_exports, {
+  $asinh: () => $asinh
+});
+module.exports = __toCommonJS(asinh_exports);
+var import_internal = __webpack_require__(1291);
+const $asinh = (0, import_internal.createTrignometryOperator)(Math.asinh, {
+  Infinity: Infinity,
+  "-Infinity": -Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4385:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5285:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$replaceAll = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Replaces all instances of a matched string in a given input.
- *
- * @param  {Object} obj
- * @param  {Array} expr
- */
-const $replaceAll = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const arr = [args.input, args.find, args.replacement];
-    if (arr.some(util_1.isNil))
-        return null;
-    (0, util_1.assert)(arr.every(util_1.isString), "$replaceAll expression fields must evaluate to string");
-    return args.input.replace(new RegExp(args.find, "g"), args.replacement);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$replaceAll = $replaceAll;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var atan_exports = {};
+__export(atan_exports, {
+  $atan: () => $atan
+});
+module.exports = __toCommonJS(atan_exports);
+var import_internal = __webpack_require__(1291);
+const $atan = (0, import_internal.createTrignometryOperator)(Math.atan);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3869:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5991:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$replaceOne = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Replaces the first instance of a matched string in a given input.
- *
- * @param  {Object} obj
- * @param  {Array} expr
- */
-const $replaceOne = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const arr = [args.input, args.find, args.replacement];
-    if (arr.some(util_1.isNil))
-        return null;
-    (0, util_1.assert)(arr.every(util_1.isString), "$replaceOne expression fields must evaluate to string");
-    return args.input.replace(args.find, args.replacement);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var atan2_exports = {};
+__export(atan2_exports, {
+  $atan2: () => $atan2
+});
+module.exports = __toCommonJS(atan2_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $atan2 = (obj, expr, options) => {
+  const [y, x] = (0, import_core.computeValue)(obj, expr, null, options);
+  if (isNaN(y) || (0, import_util.isNil)(y)) return y;
+  if (isNaN(x) || (0, import_util.isNil)(x)) return x;
+  return Math.atan2(y, x);
 };
-exports.$replaceOne = $replaceOne;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3648:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9825:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$rtrim = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Removes whitespace characters, including null, or the specified characters from the end of a string.
- *
- * @param obj
- * @param expr
- */
-const $rtrim = (obj, expr, options) => {
-    return (0, _internal_1.trimString)(obj, expr, options, { left: false, right: true });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$rtrim = $rtrim;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var atanh_exports = {};
+__export(atanh_exports, {
+  $atanh: () => $atanh
+});
+module.exports = __toCommonJS(atanh_exports);
+var import_internal = __webpack_require__(1291);
+const $atanh = (0, import_internal.createTrignometryOperator)(Math.atanh, {
+  1: Infinity,
+  "-1": -Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7066:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3676:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$split = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Splits a string into substrings based on a delimiter.
- * If the delimiter is not found within the string, returns an array containing the original string.
- *
- * @param  {Object} obj
- * @param  {Array} expr
- * @return {Array} Returns an array of substrings.
- */
-const $split = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(args[0]))
-        return null;
-    (0, util_1.assert)(args.every(util_1.isString), "$split expression must result to array(2) of strings");
-    return args[0].split(args[1]);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$split = $split;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cos_exports = {};
+__export(cos_exports, {
+  $cos: () => $cos
+});
+module.exports = __toCommonJS(cos_exports);
+var import_internal = __webpack_require__(1291);
+const $cos = (0, import_internal.createTrignometryOperator)(Math.cos);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3837:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5310:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$strLenBytes = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Returns the number of UTF-8 encoded bytes in the specified string.
- *
- * @param  {Object} obj
- * @param  {String} expr
- * @return {Number}
- */
-const $strLenBytes = (obj, expr, options) => {
-    return ~-encodeURI((0, core_1.computeValue)(obj, expr, null, options)).split(/%..|./).length;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$strLenBytes = $strLenBytes;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cosh_exports = {};
+__export(cosh_exports, {
+  $cosh: () => $cosh
+});
+module.exports = __toCommonJS(cosh_exports);
+var import_internal = __webpack_require__(1291);
+const $cosh = (0, import_internal.createTrignometryOperator)(Math.cosh, {
+  "-Infinity": Infinity,
+  Infinity: Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5292:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 757:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$strLenCP = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Returns the number of UTF-8 code points in the specified string.
- *
- * @param  {Object} obj
- * @param  {String} expr
- * @return {Number}
- */
-const $strLenCP = (obj, expr, options) => {
-    return (0, core_1.computeValue)(obj, expr, null, options).length;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$strLenCP = $strLenCP;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var degreesToRadians_exports = {};
+__export(degreesToRadians_exports, {
+  $degreesToRadians: () => $degreesToRadians
+});
+module.exports = __toCommonJS(degreesToRadians_exports);
+var import_internal = __webpack_require__(1291);
+const RADIANS_FACTOR = Math.PI / 180;
+const $degreesToRadians = (0, import_internal.createTrignometryOperator)(
+  (n) => n * RADIANS_FACTOR,
+  {
+    Infinity: Infinity,
+    "-Infinity": Infinity
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3868:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 7367:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trignometry_exports = {};
+module.exports = __toCommonJS(trignometry_exports);
+__reExport(trignometry_exports, __webpack_require__(1025), module.exports);
+__reExport(trignometry_exports, __webpack_require__(9637), module.exports);
+__reExport(trignometry_exports, __webpack_require__(8000), module.exports);
+__reExport(trignometry_exports, __webpack_require__(8634), module.exports);
+__reExport(trignometry_exports, __webpack_require__(5285), module.exports);
+__reExport(trignometry_exports, __webpack_require__(5991), module.exports);
+__reExport(trignometry_exports, __webpack_require__(9825), module.exports);
+__reExport(trignometry_exports, __webpack_require__(3676), module.exports);
+__reExport(trignometry_exports, __webpack_require__(5310), module.exports);
+__reExport(trignometry_exports, __webpack_require__(757), module.exports);
+__reExport(trignometry_exports, __webpack_require__(5183), module.exports);
+__reExport(trignometry_exports, __webpack_require__(7969), module.exports);
+__reExport(trignometry_exports, __webpack_require__(9589), module.exports);
+__reExport(trignometry_exports, __webpack_require__(6404), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 5183:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$strcasecmp = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Compares two strings and returns an integer that reflects the comparison.
- *
- * @param obj
- * @param expr
- * @returns {number}
- */
-const $strcasecmp = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    let a = args[0];
-    let b = args[1];
-    if ((0, util_1.isEqual)(a, b) || args.every(util_1.isNil))
-        return 0;
-    (0, util_1.assert)(args.every(util_1.isString), "$strcasecmp must resolve to array(2) of strings");
-    a = a.toUpperCase();
-    b = b.toUpperCase();
-    return (a > b && 1) || (a < b && -1) || 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$strcasecmp = $strcasecmp;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var radiansToDegrees_exports = {};
+__export(radiansToDegrees_exports, {
+  $radiansToDegrees: () => $radiansToDegrees
+});
+module.exports = __toCommonJS(radiansToDegrees_exports);
+var import_internal = __webpack_require__(1291);
+const DEGREES_FACTOR = 180 / Math.PI;
+const $radiansToDegrees = (0, import_internal.createTrignometryOperator)(
+  (n) => n * DEGREES_FACTOR,
+  {
+    Infinity: Infinity,
+    "-Infinity": -Infinity
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8378:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7969:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$substr = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a substring of a string, starting at a specified index position and including the specified number of characters.
- * The index is zero-based.
- *
- * @param obj
- * @param expr
- * @returns {string}
- */
-const $substr = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const s = args[0];
-    const index = args[1];
-    const count = args[2];
-    if ((0, util_1.isString)(s)) {
-        if (index < 0) {
-            return "";
-        }
-        else if (count < 0) {
-            return s.substr(index);
-        }
-        else {
-            return s.substr(index, count);
-        }
-    }
-    return "";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$substr = $substr;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sin_exports = {};
+__export(sin_exports, {
+  $sin: () => $sin
+});
+module.exports = __toCommonJS(sin_exports);
+var import_internal = __webpack_require__(1291);
+const $sin = (0, import_internal.createTrignometryOperator)(Math.sin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7476:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9589:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$substrBytes = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const UTF8_MASK = [0xc0, 0xe0, 0xf0];
-// encodes a unicode code point to a utf8 byte sequence
-// https://encoding.spec.whatwg.org/#utf-8
-function toUtf8(n) {
-    if (n < 0x80)
-        return [n];
-    let count = (n < 0x0800 && 1) || (n < 0x10000 && 2) || 3;
-    const offset = UTF8_MASK[count - 1];
-    const utf8 = [(n >> (6 * count)) + offset];
-    while (count > 0)
-        utf8.push(0x80 | ((n >> (6 * --count)) & 0x3f));
-    return utf8;
-}
-function utf8Encode(s) {
-    const buf = [];
-    for (let i = 0, len = s.length; i < len; i++) {
-        buf.push(toUtf8(s.codePointAt(i)));
-    }
-    return buf;
-}
-/**
- * Returns a substring of a string, starting at a specified index position and including the specified number of characters.
- * The index is zero-based.
- *
- * @param obj
- * @param expr
- * @returns {string}
- */
-const $substrBytes = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    const s = args[0];
-    const index = args[1];
-    const count = args[2];
-    (0, util_1.assert)((0, util_1.isString)(s) &&
-        (0, util_1.isNumber)(index) &&
-        index >= 0 &&
-        (0, util_1.isNumber)(count) &&
-        count >= 0, "$substrBytes: invalid arguments");
-    const buf = utf8Encode(s);
-    const validIndex = [];
-    let acc = 0;
-    for (let i = 0; i < buf.length; i++) {
-        validIndex.push(acc);
-        acc += buf[i].length;
-    }
-    const begin = validIndex.indexOf(index);
-    const end = validIndex.indexOf(index + count);
-    (0, util_1.assert)(begin > -1 && end > -1, "$substrBytes: invalid range, start or end index is a UTF-8 continuation byte.");
-    return s.substring(begin, end);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$substrBytes = $substrBytes;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sinh_exports = {};
+__export(sinh_exports, {
+  $sinh: () => $sinh
+});
+module.exports = __toCommonJS(sinh_exports);
+var import_internal = __webpack_require__(1291);
+const $sinh = (0, import_internal.createTrignometryOperator)(Math.sinh, {
+  "-Infinity": -Infinity,
+  Infinity: Infinity
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4098:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6404:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$substrCP = void 0;
-const substr_1 = __webpack_require__(8378);
-const $substrCP = (obj, expr, options) => {
-    return (0, substr_1.$substr)(obj, expr, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$substrCP = $substrCP;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tan_exports = {};
+__export(tan_exports, {
+  $tan: () => $tan
+});
+module.exports = __toCommonJS(tan_exports);
+var import_internal = __webpack_require__(1291);
+const $tan = (0, import_internal.createTrignometryOperator)(Math.tan);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7013:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5281:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toLower = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Converts a string to lowercase.
- *
- * @param obj
- * @param expr
- * @returns {string}
- */
-const $toLower = (obj, expr, options) => {
-    const value = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.isEmpty)(value) ? "" : value.toLowerCase();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$toLower = $toLower;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  MAX_INT: () => MAX_INT,
+  MAX_LONG: () => MAX_LONG,
+  MIN_INT: () => MIN_INT,
+  MIN_LONG: () => MIN_LONG,
+  TypeConvertError: () => TypeConvertError,
+  toInteger: () => toInteger
+});
+module.exports = __toCommonJS(internal_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const MAX_INT = 2147483647;
+const MIN_INT = -2147483648;
+const MAX_LONG = Number.MAX_SAFE_INTEGER;
+const MIN_LONG = Number.MIN_SAFE_INTEGER;
+class TypeConvertError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+function toInteger(obj, expr, options, min, max) {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if (val === true) return 1;
+  if (val === false) return 0;
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) return val.getTime();
+  const n = Number(val);
+  if ((0, import_util.isNumber)(n) && n >= min && n <= max) {
+    if (!(0, import_util.isString)(val) || n.toString().indexOf(".") === -1) {
+      return Math.trunc(n);
+    }
+  }
+  throw new TypeConvertError(
+    `cannot convert '${val}' to ${max == MAX_INT ? "int" : "long"}`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 310:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 6234:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var convert_exports = {};
+__export(convert_exports, {
+  $convert: () => $convert
+});
+module.exports = __toCommonJS(convert_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(5281);
+var import_toBool = __webpack_require__(448);
+var import_toDate = __webpack_require__(2848);
+var import_toDouble = __webpack_require__(7093);
+var import_toInt = __webpack_require__(5375);
+var import_toLong = __webpack_require__(8074);
+var import_toString = __webpack_require__(4077);
+const $convert = (obj, expr, options) => {
+  const args = (0, import_core.computeValue)(obj, expr, null, options);
+  args.onNull = args.onNull === void 0 ? null : args.onNull;
+  if ((0, import_util.isNil)(args.input)) return args.onNull;
+  try {
+    switch (args.to) {
+      case 2:
+      case "string":
+        return (0, import_toString.$toString)(obj, args.input, options);
+      case 8:
+      case "boolean":
+      case "bool":
+        return (0, import_toBool.$toBool)(obj, args.input, options);
+      case 9:
+      case "date":
+        return (0, import_toDate.$toDate)(obj, args.input, options);
+      case 1:
+      case 19:
+      case "double":
+      case "decimal":
+      case "number":
+        return (0, import_toDouble.$toDouble)(obj, args.input, options);
+      case 16:
+      case "int":
+        return (0, import_toInt.$toInt)(obj, args.input, options);
+      case 18:
+      case "long":
+        return (0, import_toLong.$toLong)(obj, args.input, options);
+    }
+  } catch {
+  }
+  if (args.onError !== void 0) return args.onError;
+  throw new import_internal.TypeConvertError(`could not convert to type ${args.to}.`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 1377:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toUpper = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Converts a string to uppercase.
- *
- * @param obj
- * @param expr
- * @returns {string}
- */
-const $toUpper = (obj, expr, options) => {
-    const value = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.isEmpty)(value) ? "" : value.toUpperCase();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$toUpper = $toUpper;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);
+__reExport(type_exports, __webpack_require__(6234), module.exports);
+__reExport(type_exports, __webpack_require__(2024), module.exports);
+__reExport(type_exports, __webpack_require__(448), module.exports);
+__reExport(type_exports, __webpack_require__(2848), module.exports);
+__reExport(type_exports, __webpack_require__(3289), module.exports);
+__reExport(type_exports, __webpack_require__(7093), module.exports);
+__reExport(type_exports, __webpack_require__(5375), module.exports);
+__reExport(type_exports, __webpack_require__(8074), module.exports);
+__reExport(type_exports, __webpack_require__(4077), module.exports);
+__reExport(type_exports, __webpack_require__(1317), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8745:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2024:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$trim = void 0;
-const _internal_1 = __webpack_require__(3421);
-/**
- * Removes whitespace characters, including null, or the specified characters from the beginning and end of a string.
- *
- * @param obj
- * @param expr
- */
-const $trim = (obj, expr, options) => {
-    return (0, _internal_1.trimString)(obj, expr, options, { left: true, right: true });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isNumber_exports = {};
+__export(isNumber_exports, {
+  $isNumber: () => $isNumber
+});
+module.exports = __toCommonJS(isNumber_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $isNumber = (obj, expr, options) => {
+  const n = (0, import_core.computeValue)(obj, expr, null, options);
+  return (0, import_util.isNumber)(n);
 };
-exports.$trim = $trim;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 725:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 448:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createTrignometryOperator = void 0;
-const core_1 = __webpack_require__(9587);
-const FIXED_POINTS = {
-    undefined: null,
-    null: null,
-    NaN: NaN,
-    Infinity: new Error(),
-    "-Infinity": new Error()
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Returns an operator for a given trignometric function
- *
- * @param f The trignometric function
- */
-function createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {
-    const fp = Object.assign({}, FIXED_POINTS, fixedPoints);
-    const keySet = new Set(Object.keys(fp));
-    return (obj, expr, options) => {
-        const n = (0, core_1.computeValue)(obj, expr, null, options);
-        if (keySet.has(`${n}`)) {
-            const res = fp[`${n}`];
-            if (res instanceof Error) {
-                throw new Error(`cannot apply $${f.name} to -inf, value must in (-inf,inf)`);
-            }
-            return res;
-        }
-        return f(n);
-    };
-}
-exports.createTrignometryOperator = createTrignometryOperator;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toBool_exports = {};
+__export(toBool_exports, {
+  $toBool: () => $toBool
+});
+module.exports = __toCommonJS(toBool_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $toBool = (obj, expr, options) => {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isString)(val)) return true;
+  return Boolean(val);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4349:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2848:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$acos = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse cosine (arc cosine) of a value in radians. */
-exports.$acos = (0, _internal_1.createTrignometryOperator)(Math.acos, {
-    Infinity: Infinity,
-    0: new Error(),
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toDate_exports = {};
+__export(toDate_exports, {
+  $toDate: () => $toDate
 });
+module.exports = __toCommonJS(toDate_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(5281);
+const $toDate = (obj, expr, options) => {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isDate)(val)) return val;
+  if ((0, import_util.isNil)(val)) return null;
+  const d = new Date(val);
+  const n = d.getTime();
+  if (!isNaN(n)) return d;
+  throw new import_internal.TypeConvertError(`cannot convert '${val}' to date`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1699:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3289:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$acosh = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse hyperbolic cosine (hyperbolic arc cosine) of a value in radians. */
-exports.$acosh = (0, _internal_1.createTrignometryOperator)(Math.acosh, {
-    Infinity: Infinity,
-    0: new Error(),
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toDecimal_exports = {};
+__export(toDecimal_exports, {
+  $toDecimal: () => $toDecimal
 });
+module.exports = __toCommonJS(toDecimal_exports);
+var import_toDouble = __webpack_require__(7093);
+const $toDecimal = import_toDouble.$toDouble;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 160:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7093:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$asin = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse sin (arc sine) of a value in radians. */
-exports.$asin = (0, _internal_1.createTrignometryOperator)(Math.asin);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toDouble_exports = {};
+__export(toDouble_exports, {
+  $toDouble: () => $toDouble
+});
+module.exports = __toCommonJS(toDouble_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(5281);
+const $toDouble = (obj, expr, options) => {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) return val.getTime();
+  if (val === true) return 1;
+  if (val === false) return 0;
+  const n = Number(val);
+  if ((0, import_util.isNumber)(n)) return n;
+  throw new import_internal.TypeConvertError(`cannot convert '${val}' to double/decimal`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5805:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5375:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$asinh = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse hyperbolic sine (hyperbolic arc sine) of a value in radians. */
-exports.$asinh = (0, _internal_1.createTrignometryOperator)(Math.asinh, {
-    Infinity: Infinity,
-    "-Infinity": -Infinity,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toInt_exports = {};
+__export(toInt_exports, {
+  $toInt: () => $toInt
 });
+module.exports = __toCommonJS(toInt_exports);
+var import_internal = __webpack_require__(5281);
+const $toInt = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_INT, import_internal.MAX_INT);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8335:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8074:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$atan = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse tangent (arc tangent) of a value in radians. */
-exports.$atan = (0, _internal_1.createTrignometryOperator)(Math.atan);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toLong_exports = {};
+__export(toLong_exports, {
+  $toLong: () => $toLong
+});
+module.exports = __toCommonJS(toLong_exports);
+var import_internal = __webpack_require__(5281);
+const $toLong = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_LONG, import_internal.MAX_LONG);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5106:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4077:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$atan2 = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns the inverse tangent (arc tangent) of y / x in radians, where y and x are the first and second values passed to the expression respectively. */
-const $atan2 = (obj, expr, options) => {
-    const [y, x] = (0, core_1.computeValue)(obj, expr, null, options);
-    if (isNaN(y) || (0, util_1.isNil)(y))
-        return y;
-    if (isNaN(x) || (0, util_1.isNil)(x))
-        return x;
-    return Math.atan2(y, x);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toString_exports = {};
+__export(toString_exports, {
+  $toString: () => $toString
+});
+module.exports = __toCommonJS(toString_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_dateToString = __webpack_require__(7165);
+const $toString = (obj, expr, options) => {
+  const val = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(val)) return null;
+  if ((0, import_util.isDate)(val)) {
+    return (0, import_dateToString.$dateToString)(
+      obj,
+      {
+        date: expr,
+        format: "%Y-%m-%dT%H:%M:%S.%LZ"
+      },
+      options
+    );
+  }
+  return val.toString();
 };
-exports.$atan2 = $atan2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5133:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1317:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$atanh = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the inverse hyperbolic tangent (hyperbolic arc tangent) of a value in radians. */
-exports.$atanh = (0, _internal_1.createTrignometryOperator)(Math.atanh, {
-    1: Infinity,
-    "-1": -Infinity,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+__export(type_exports, {
+  $type: () => $type
 });
+module.exports = __toCommonJS(type_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(5281);
+const $type = (obj, expr, options) => {
+  const v = (0, import_core.computeValue)(obj, expr, null, options);
+  if (options.useStrictMode) {
+    if (v === void 0) return "missing";
+    if (v === true || v === false) return "bool";
+    if ((0, import_util.isNumber)(v)) {
+      if (v % 1 != 0) return "double";
+      return v >= import_internal.MIN_INT && v <= import_internal.MAX_INT ? "int" : "long";
+    }
+    if ((0, import_util.isRegExp)(v)) return "regex";
+  }
+  return (0, import_util.typeOf)(v);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4925:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2537:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$cos = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the cosine of a value that is measured in radians. */
-exports.$cos = (0, _internal_1.createTrignometryOperator)(Math.cos);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var variable_exports = {};
+module.exports = __toCommonJS(variable_exports);
+__reExport(variable_exports, __webpack_require__(7544), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3138:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7544:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$cosh = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the hyperbolic cosine of a value that is measured in radians. */
-exports.$cosh = (0, _internal_1.createTrignometryOperator)(Math.cosh, {
-    "-Infinity": Infinity,
-    Infinity: Infinity,
-    // [Math.PI]: -1,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var let_exports = {};
+__export(let_exports, {
+  $let: () => $let
 });
+module.exports = __toCommonJS(let_exports);
+var import_core = __webpack_require__(2760);
+const $let = (obj, expr, options) => {
+  const variables = {};
+  for (const [key, val] of Object.entries(expr.vars)) {
+    variables[key] = (0, import_core.computeValue)(obj, val, null, options);
+  }
+  return (0, import_core.computeValue)(
+    obj,
+    expr.in,
+    null,
+    import_core.ComputeOptions.init(options, obj, { variables })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2989:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2088:
+/***/ ((module) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$degreesToRadians = void 0;
-const _internal_1 = __webpack_require__(725);
-const RADIANS_FACTOR = Math.PI / 180;
-/** Converts a value from degrees to radians. */
-exports.$degreesToRadians = (0, _internal_1.createTrignometryOperator)((n) => n * RADIANS_FACTOR, {
-    Infinity: Infinity,
-    "-Infinity": Infinity,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  isUnbounded: () => isUnbounded
 });
+module.exports = __toCommonJS(internal_exports);
+const isUnbounded = (window) => {
+  const boundary = window?.documents || window?.range;
+  return !boundary || boundary[0] === "unbounded" && boundary[1] === "unbounded";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4441:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 5770:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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]; } };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addFields_exports = {};
+__export(addFields_exports, {
+  $addFields: () => $addFields
+});
+module.exports = __toCommonJS(addFields_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $addFields = (collection, expr, options) => {
+  const newFields = Object.keys(expr);
+  if (newFields.length === 0) return collection;
+  return collection.map((obj) => {
+    const newObj = { ...obj };
+    for (const field of newFields) {
+      const newValue = (0, import_core.computeValue)(obj, expr[field], null, options);
+      if (newValue !== void 0) {
+        (0, import_util.setValue)(newObj, field, newValue);
+      } else {
+        (0, import_util.removeValue)(newObj, field);
+      }
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    return newObj;
+  });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(4349), exports);
-__exportStar(__webpack_require__(1699), exports);
-__exportStar(__webpack_require__(160), exports);
-__exportStar(__webpack_require__(5805), exports);
-__exportStar(__webpack_require__(8335), exports);
-__exportStar(__webpack_require__(5106), exports);
-__exportStar(__webpack_require__(5133), exports);
-__exportStar(__webpack_require__(4925), exports);
-__exportStar(__webpack_require__(3138), exports);
-__exportStar(__webpack_require__(2989), exports);
-__exportStar(__webpack_require__(6019), exports);
-__exportStar(__webpack_require__(8534), exports);
-__exportStar(__webpack_require__(4738), exports);
-__exportStar(__webpack_require__(5295), exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6019:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 308:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$radiansToDegrees = void 0;
-const _internal_1 = __webpack_require__(725);
-const DEGREES_FACTOR = 180 / Math.PI;
-/** Converts a value from radians to degrees. */
-exports.$radiansToDegrees = (0, _internal_1.createTrignometryOperator)((n) => n * DEGREES_FACTOR, {
-    Infinity: Infinity,
-    "-Infinity": -Infinity,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bucket_exports = {};
+__export(bucket_exports, {
+  $bucket: () => $bucket
 });
+module.exports = __toCommonJS(bucket_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+const $bucket = (collection, expr, options) => {
+  const bounds = [...expr.boundaries];
+  const defaultKey = expr.default;
+  const lower = bounds[0];
+  const upper = bounds[bounds.length - 1];
+  const outputExpr = expr.output || { count: { $sum: 1 } };
+  (0, import_util.assert)(bounds.length > 1, "$bucket must specify at least two boundaries.");
+  const isValid = bounds.every(
+    (v, i) => i === 0 || (0, import_util.typeOf)(v) === (0, import_util.typeOf)(bounds[i - 1]) && (0, import_util.compare)(v, bounds[i - 1]) > 0
+  );
+  (0, import_util.assert)(
+    isValid,
+    `$bucket: bounds must be of same type and in ascending order`
+  );
+  if (!(0, import_util.isNil)(defaultKey) && (0, import_util.typeOf)(defaultKey) === (0, import_util.typeOf)(lower)) {
+    (0, import_util.assert)(
+      (0, import_util.compare)(defaultKey, upper) >= 0 || (0, import_util.compare)(defaultKey, lower) < 0,
+      "$bucket 'default' expression must be out of boundaries range"
+    );
+  }
+  const createBuckets = () => {
+    const buckets = /* @__PURE__ */ new Map();
+    for (let i = 0; i < bounds.length - 1; i++) {
+      buckets.set(bounds[i], []);
+    }
+    if (!(0, import_util.isNil)(defaultKey)) buckets.set(defaultKey, []);
+    collection.each((obj) => {
+      const key = (0, import_core.computeValue)(obj, expr.groupBy, null, options);
+      if ((0, import_util.isNil)(key) || (0, import_util.compare)(key, lower) < 0 || (0, import_util.compare)(key, upper) >= 0) {
+        (0, import_util.assert)(
+          !(0, import_util.isNil)(defaultKey),
+          "$bucket require a default for out of range values"
+        );
+        buckets.get(defaultKey).push(obj);
+      } else {
+        (0, import_util.assert)(
+          (0, import_util.compare)(key, lower) >= 0 && (0, import_util.compare)(key, upper) < 0,
+          "$bucket 'groupBy' expression must resolve to a value in range of boundaries"
+        );
+        const index = (0, import_util.findInsertIndex)(bounds, key);
+        const boundKey = bounds[Math.max(0, index - 1)];
+        buckets.get(boundKey).push(obj);
+      }
+    });
+    bounds.pop();
+    if (!(0, import_util.isNil)(defaultKey)) bounds.push(defaultKey);
+    (0, import_util.assert)(
+      buckets.size === bounds.length,
+      "bounds and groups must be of equal size."
+    );
+    return (0, import_lazy.Lazy)(bounds).map((key) => {
+      return {
+        ...(0, import_core.computeValue)(
+          buckets.get(key),
+          outputExpr,
+          null,
+          options
+        ),
+        _id: key
+      };
+    });
+  };
+  let iterator;
+  return (0, import_lazy.Lazy)(() => {
+    if (!iterator) iterator = createBuckets();
+    return iterator.next();
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8534:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sin = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the sine of a value that is measured in radians. */
-exports.$sin = (0, _internal_1.createTrignometryOperator)(Math.sin);
-
-
-/***/ }),
-
-/***/ 4738:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7267:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sinh = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the hyperbolic sine of a value that is measured in radians. */
-exports.$sinh = (0, _internal_1.createTrignometryOperator)(Math.sinh, {
-    "-Infinity": -Infinity,
-    Infinity: Infinity,
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bucketAuto_exports = {};
+__export(bucketAuto_exports, {
+  $bucketAuto: () => $bucketAuto
+});
+module.exports = __toCommonJS(bucketAuto_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+const $bucketAuto = (collection, expr, options) => {
+  const {
+    buckets: bucketCount,
+    groupBy: groupByExpr,
+    output: optOutputExpr,
+    // Available only if the all groupBy values are numeric and none of them are NaN.
+    granularity
+  } = expr;
+  const outputExpr = optOutputExpr ?? { count: { $sum: 1 } };
+  (0, import_util.assert)(
+    bucketCount > 0,
+    `$bucketAuto: 'buckets' field must be greater than 0, but found: ${bucketCount}`
+  );
+  if (granularity) {
+    (0, import_util.assert)(
+      /^POWERSOF2|1-2-5|E(6|12|24|48|96|192)|R(5|10|20|40|80)$/.test(
+        granularity
+      ),
+      `$bucketAuto: invalid granularity '${granularity}'.`
+    );
+  }
+  const keyMap = /* @__PURE__ */ new Map();
+  const setKey = !granularity ? (o, k) => keyMap.set(o, k) : (_, _2) => {
+  };
+  const sorted = collection.map((o) => {
+    const k = (0, import_core.computeValue)(o, groupByExpr, null, options) ?? null;
+    (0, import_util.assert)(
+      !granularity || (0, import_util.isNumber)(k),
+      "$bucketAuto: groupBy values must be numeric when granularity is specified."
+    );
+    setKey(o, k ?? null);
+    return [k ?? null, o];
+  }).value();
+  sorted.sort((x, y) => {
+    if ((0, import_util.isNil)(x[0])) return -1;
+    if ((0, import_util.isNil)(y[0])) return 1;
+    return (0, import_util.compare)(x[0], y[0]);
+  });
+  let getNext;
+  if (!granularity) {
+    getNext = granularityDefault(sorted, bucketCount, keyMap);
+  } else if (granularity == "POWERSOF2") {
+    getNext = granularityPowerOfTwo(
+      sorted,
+      bucketCount
+    );
+  } else {
+    getNext = granularityPreferredSeries(
+      sorted,
+      bucketCount,
+      granularity
+    );
+  }
+  let terminate = false;
+  return (0, import_lazy.Lazy)(() => {
+    if (terminate) return { done: true };
+    const { min, max, bucket, done } = getNext();
+    terminate = done;
+    const outFields = (0, import_core.computeValue)(
+      bucket,
+      outputExpr,
+      null,
+      options
+    );
+    for (const [k, v] of Object.entries(outFields)) {
+      if ((0, import_util.isArray)(v)) outFields[k] = v.filter((v2) => v2 !== void 0);
+    }
+    return {
+      done: false,
+      value: {
+        ...outFields,
+        _id: { min, max }
+      }
+    };
+  });
+};
+function granularityDefault(sorted, bucketCount, keyMap) {
+  const size = sorted.length;
+  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));
+  let index = 0;
+  let nBuckets = 0;
+  return () => {
+    const isLastBucket = ++nBuckets == bucketCount;
+    const bucket = new Array();
+    while (index < size && (isLastBucket || bucket.length < approxBucketSize || index > 0 && (0, import_util.isEqual)(sorted[index - 1][0], sorted[index][0]))) {
+      bucket.push(sorted[index++][1]);
+    }
+    const min = keyMap.get(bucket[0]);
+    let max;
+    if (index < size) {
+      max = sorted[index][0];
+    } else {
+      max = keyMap.get(bucket[bucket.length - 1]);
+    }
+    (0, import_util.assert)(
+      (0, import_util.isNil)(max) || (0, import_util.isNil)(min) || min <= max,
+      `error: $bucketAuto boundary must be in order.`
+    );
+    return {
+      min,
+      max,
+      bucket,
+      done: index >= size
+    };
+  };
+}
+function granularityPowerOfTwo(sorted, bucketCount) {
+  const size = sorted.length;
+  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));
+  const roundUp2 = (n) => n === 0 ? 0 : 2 ** (Math.floor(Math.log2(n)) + 1);
+  let index = 0;
+  let min = 0;
+  let max = 0;
+  return () => {
+    const bucket = new Array();
+    const boundValue = roundUp2(max);
+    min = index > 0 ? max : 0;
+    while (bucket.length < approxBucketSize && index < size && (max === 0 || sorted[index][0] < boundValue)) {
+      bucket.push(sorted[index++][1]);
+    }
+    max = max == 0 ? roundUp2(sorted[index - 1][0]) : boundValue;
+    while (index < size && sorted[index][0] < max) {
+      bucket.push(sorted[index++][1]);
+    }
+    return {
+      min,
+      max,
+      bucket,
+      done: index >= size
+    };
+  };
+}
+const PREFERRED_NUMBERS = Object.freeze({
+  // "Least rounded" Renard number series, taken from Wikipedia page on preferred
+  // numbers: https://en.wikipedia.org/wiki/Preferred_number#Renard_numbers
+  R5: [10, 16, 25, 40, 63],
+  R10: [100, 125, 160, 200, 250, 315, 400, 500, 630, 800],
+  R20: [
+    100,
+    112,
+    125,
+    140,
+    160,
+    180,
+    200,
+    224,
+    250,
+    280,
+    315,
+    355,
+    400,
+    450,
+    500,
+    560,
+    630,
+    710,
+    800,
+    900
+  ],
+  R40: [
+    100,
+    106,
+    112,
+    118,
+    125,
+    132,
+    140,
+    150,
+    160,
+    170,
+    180,
+    190,
+    200,
+    212,
+    224,
+    236,
+    250,
+    265,
+    280,
+    300,
+    315,
+    355,
+    375,
+    400,
+    425,
+    450,
+    475,
+    500,
+    530,
+    560,
+    600,
+    630,
+    670,
+    710,
+    750,
+    800,
+    850,
+    900,
+    950
+  ],
+  R80: [
+    103,
+    109,
+    115,
+    122,
+    128,
+    136,
+    145,
+    155,
+    165,
+    175,
+    185,
+    195,
+    206,
+    218,
+    230,
+    243,
+    258,
+    272,
+    290,
+    307,
+    325,
+    345,
+    365,
+    387,
+    412,
+    437,
+    462,
+    487,
+    515,
+    545,
+    575,
+    615,
+    650,
+    690,
+    730,
+    775,
+    825,
+    875,
+    925,
+    975
+  ],
+  // https://en.wikipedia.org/wiki/Preferred_number#1-2-5_series
+  "1-2-5": [10, 20, 50],
+  // E series, taken from Wikipedia page on preferred numbers:
+  // https://en.wikipedia.org/wiki/Preferred_number#E_series
+  E6: [10, 15, 22, 33, 47, 68],
+  E12: [10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82],
+  E24: [
+    10,
+    11,
+    12,
+    13,
+    15,
+    16,
+    18,
+    20,
+    22,
+    24,
+    27,
+    30,
+    33,
+    36,
+    39,
+    43,
+    47,
+    51,
+    56,
+    62,
+    68,
+    75,
+    82,
+    91
+  ],
+  E48: [
+    100,
+    105,
+    110,
+    115,
+    121,
+    127,
+    133,
+    140,
+    147,
+    154,
+    162,
+    169,
+    178,
+    187,
+    196,
+    205,
+    215,
+    226,
+    237,
+    249,
+    261,
+    274,
+    287,
+    301,
+    316,
+    332,
+    348,
+    365,
+    383,
+    402,
+    422,
+    442,
+    464,
+    487,
+    511,
+    536,
+    562,
+    590,
+    619,
+    649,
+    681,
+    715,
+    750,
+    787,
+    825,
+    866,
+    909,
+    953
+  ],
+  E96: [
+    100,
+    102,
+    105,
+    107,
+    110,
+    113,
+    115,
+    118,
+    121,
+    124,
+    127,
+    130,
+    133,
+    137,
+    140,
+    143,
+    147,
+    150,
+    154,
+    158,
+    162,
+    165,
+    169,
+    174,
+    178,
+    182,
+    187,
+    191,
+    196,
+    200,
+    205,
+    210,
+    215,
+    221,
+    226,
+    232,
+    237,
+    243,
+    249,
+    255,
+    261,
+    267,
+    274,
+    280,
+    287,
+    294,
+    301,
+    309,
+    316,
+    324,
+    332,
+    340,
+    348,
+    357,
+    365,
+    374,
+    383,
+    392,
+    402,
+    412,
+    422,
+    432,
+    442,
+    453,
+    464,
+    475,
+    487,
+    499,
+    511,
+    523,
+    536,
+    549,
+    562,
+    576,
+    590,
+    604,
+    619,
+    634,
+    649,
+    665,
+    681,
+    698,
+    715,
+    732,
+    750,
+    768,
+    787,
+    806,
+    825,
+    845,
+    866,
+    887,
+    909,
+    931,
+    953,
+    976
+  ],
+  E192: [
+    100,
+    101,
+    102,
+    104,
+    105,
+    106,
+    107,
+    109,
+    110,
+    111,
+    113,
+    114,
+    115,
+    117,
+    118,
+    120,
+    121,
+    123,
+    124,
+    126,
+    127,
+    129,
+    130,
+    132,
+    133,
+    135,
+    137,
+    138,
+    140,
+    142,
+    143,
+    145,
+    147,
+    149,
+    150,
+    152,
+    154,
+    156,
+    158,
+    160,
+    162,
+    164,
+    165,
+    167,
+    169,
+    172,
+    174,
+    176,
+    178,
+    180,
+    182,
+    184,
+    187,
+    189,
+    191,
+    193,
+    196,
+    198,
+    200,
+    203,
+    205,
+    208,
+    210,
+    213,
+    215,
+    218,
+    221,
+    223,
+    226,
+    229,
+    232,
+    234,
+    237,
+    240,
+    243,
+    246,
+    249,
+    252,
+    255,
+    258,
+    261,
+    264,
+    267,
+    271,
+    274,
+    277,
+    280,
+    284,
+    287,
+    291,
+    294,
+    298,
+    301,
+    305,
+    309,
+    312,
+    316,
+    320,
+    324,
+    328,
+    332,
+    336,
+    340,
+    344,
+    348,
+    352,
+    357,
+    361,
+    365,
+    370,
+    374,
+    379,
+    383,
+    388,
+    392,
+    397,
+    402,
+    407,
+    412,
+    417,
+    422,
+    427,
+    432,
+    437,
+    442,
+    448,
+    453,
+    459,
+    464,
+    470,
+    475,
+    481,
+    487,
+    493,
+    499,
+    505,
+    511,
+    517,
+    523,
+    530,
+    536,
+    542,
+    549,
+    556,
+    562,
+    569,
+    576,
+    583,
+    590,
+    597,
+    604,
+    612,
+    619,
+    626,
+    634,
+    642,
+    649,
+    657,
+    665,
+    673,
+    681,
+    690,
+    698,
+    706,
+    715,
+    723,
+    732,
+    741,
+    750,
+    759,
+    768,
+    777,
+    787,
+    796,
+    806,
+    816,
+    825,
+    835,
+    845,
+    856,
+    866,
+    876,
+    887,
+    898,
+    909,
+    920,
+    931,
+    942,
+    953,
+    965,
+    976,
+    988
+  ]
 });
+const roundUp = (n, granularity) => {
+  if (n == 0) return 0;
+  const series = PREFERRED_NUMBERS[granularity];
+  const first = series[0];
+  const last = series[series.length - 1];
+  let multiplier = 1;
+  while (n >= last * multiplier) {
+    multiplier *= 10;
+  }
+  let previousMin = 0;
+  while (n < first * multiplier) {
+    previousMin = first * multiplier;
+    multiplier /= 10;
+    if (n >= last * multiplier) {
+      return previousMin;
+    }
+  }
+  (0, import_util.assert)(
+    n >= first * multiplier && n < last * multiplier,
+    "$bucketAuto: number out of range of series."
+  );
+  const i = (0, import_util.findInsertIndex)(series, n, (a, b) => {
+    b *= multiplier;
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  });
+  const seriesNumber = series[i] * multiplier;
+  return n == seriesNumber ? series[i + 1] * multiplier : seriesNumber;
+};
+function granularityPreferredSeries(sorted, bucketCount, granularity) {
+  const size = sorted.length;
+  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));
+  let index = 0;
+  let nBuckets = 0;
+  let min = 0;
+  let max = 0;
+  return () => {
+    const isLastBucket = ++nBuckets == bucketCount;
+    const bucket = new Array();
+    min = index > 0 ? max : 0;
+    while (index < size && (isLastBucket || bucket.length < approxBucketSize)) {
+      bucket.push(sorted[index++][1]);
+    }
+    max = roundUp(sorted[index - 1][0], granularity);
+    const nItems = bucket.length;
+    while (index < size && (isLastBucket || sorted[index][0] < max)) {
+      bucket.push(sorted[index++][1]);
+    }
+    if (nItems != bucket.length) {
+      max = roundUp(sorted[index - 1][0], granularity);
+    }
+    (0, import_util.assert)(min < max, `$bucketAuto: ${min} < ${max}.`);
+    return {
+      min,
+      max,
+      bucket,
+      done: index >= size
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5295:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 11:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$tan = void 0;
-const _internal_1 = __webpack_require__(725);
-/** Returns the tangent of a value that is measured in radians. */
-exports.$tan = (0, _internal_1.createTrignometryOperator)(Math.tan);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var count_exports = {};
+__export(count_exports, {
+  $count: () => $count
+});
+module.exports = __toCommonJS(count_exports);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+const $count = (collection, expr, _options) => {
+  (0, import_util.assert)(
+    (0, import_util.isString)(expr) && !(0, import_util.isEmpty)(expr) && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
+    "Invalid expression value for $count"
+  );
+  return (0, import_lazy.Lazy)([
+    {
+      [expr]: collection.size()
+    }
+  ]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1288:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3710:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.toInteger = exports.TypeConvertError = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-class TypeConvertError extends Error {
-    constructor(message) {
-        super(message);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var densify_exports = {};
+__export(densify_exports, {
+  $densify: () => $densify
+});
+module.exports = __toCommonJS(densify_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_types = __webpack_require__(486);
+var import_util = __webpack_require__(7839);
+var import_dateAdd = __webpack_require__(8410);
+var import_sort = __webpack_require__(4290);
+const EMPTY_OBJECT = Object.freeze({});
+const $densify = (collection, expr, options) => {
+  const { step, bounds, unit } = expr.range;
+  if (unit) {
+    (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), "");
+    (0, import_util.assert)(
+      Number.isInteger(step) && step > 0,
+      "The step parameter in a range statement must be a whole number when densifying a date range."
+    );
+  } else {
+    (0, import_util.assert)(
+      (0, import_util.isNumber)(step) && step > 0,
+      "The step parameter in a range statement must be a strictly positive numeric value."
+    );
+  }
+  if ((0, import_util.isArray)(bounds)) {
+    (0, import_util.assert)(
+      !!bounds && bounds.length === 2,
+      "A bounding array in a range statement must have exactly two elements."
+    );
+    (0, import_util.assert)(
+      (bounds.every(import_util.isNumber) || bounds.every(import_util.isDate)) && bounds[0] < bounds[1],
+      "A bounding array must be an ascending array of either two dates or two numbers."
+    );
+    (0, import_util.assert)(
+      unit && !bounds.some(import_util.isNumber),
+      "Numeric bounds may not have unit parameter."
+    );
+  }
+  if (expr.partitionByFields) {
+    (0, import_util.assert)(
+      (0, import_util.isArray)(expr.partitionByFields),
+      "$densify: `partitionByFields` must be an array of strings"
+    );
+  }
+  collection = (0, import_sort.$sort)(collection, { [expr.field]: 1 }, options);
+  const nilOptions = import_core.ComputeOptions.init(options, null);
+  const computeNextValue = (value) => {
+    return (0, import_util.isNumber)(value) ? value + step : (0, import_dateAdd.$dateAdd)(
+      EMPTY_OBJECT,
+      { startDate: value, unit, amount: step },
+      nilOptions
+    );
+  };
+  const isValidUnit = !!unit && import_types.TIME_UNITS.includes(unit);
+  const getFieldValue = (o) => {
+    const v = (0, import_util.resolve)(o, expr.field);
+    if ((0, import_util.isNil)(v)) return v;
+    if ((0, import_util.isNumber)(v)) {
+      (0, import_util.assert)(
+        !isValidUnit,
+        "$densify: Encountered non-date value in collection when step has a date unit."
+      );
+    } else if ((0, import_util.isDate)(v)) {
+      (0, import_util.assert)(
+        isValidUnit,
+        "$densify: Encountered date value in collection when step does not have a date unit."
+      );
+    } else {
+      (0, import_util.assert)(false, "$densify: Densify field type must be numeric or a date");
     }
-}
-exports.TypeConvertError = TypeConvertError;
-function toInteger(obj, expr, options, max, min, typename) {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(val))
-        return null;
-    if (val instanceof Date)
-        return val.getTime();
-    if (val === true)
-        return 1;
-    if (val === false)
-        return 0;
-    const n = Number(val);
-    if ((0, util_1.isNumber)(n) && n >= min && n <= max) {
-        // weirdly a decimal in string format cannot be converted to int.
-        // so we must check input if not string or if it is, not in decimal format
-        if (!(0, util_1.isString)(val) || n.toString().indexOf(".") === -1) {
-            return Math.trunc(n);
+    return v;
+  };
+  const peekItem = new Array();
+  const nilFieldsIterator = (0, import_lazy.Lazy)(() => {
+    const item = collection.next();
+    const fieldValue = getFieldValue(item.value);
+    if ((0, import_util.isNil)(fieldValue)) return item;
+    peekItem.push(item);
+    return { done: true };
+  });
+  const nextDensifyValueMap = import_util.ValueMap.init(
+    options.hashFunction
+  );
+  const [lower, upper] = (0, import_util.isArray)(bounds) ? bounds : [bounds, bounds];
+  let maxFieldValue = void 0;
+  const updateMaxFieldValue = (value) => {
+    maxFieldValue = maxFieldValue === void 0 || maxFieldValue < value ? value : maxFieldValue;
+  };
+  const rootKey = [];
+  const densifyIterator = (0, import_lazy.Lazy)(() => {
+    const item = peekItem.length > 0 ? peekItem.pop() : collection.next();
+    if (item.done) return item;
+    let partitionKey = rootKey;
+    if ((0, import_util.isArray)(expr.partitionByFields)) {
+      partitionKey = expr.partitionByFields.map(
+        (k) => (0, import_util.resolve)(item.value, k)
+      );
+      (0, import_util.assert)(
+        partitionKey.every(import_util.isString),
+        "$densify: Partition fields must evaluate to string values."
+      );
+    }
+    (0, import_util.assert)((0, import_util.isObject)(item.value), "$densify: collection must contain documents");
+    const itemValue = getFieldValue(item.value);
+    if (!nextDensifyValueMap.has(partitionKey)) {
+      if (lower == "full") {
+        if (!nextDensifyValueMap.has(rootKey)) {
+          nextDensifyValueMap.set(rootKey, itemValue);
         }
+        nextDensifyValueMap.set(partitionKey, nextDensifyValueMap.get(rootKey));
+      } else if (lower == "partition") {
+        nextDensifyValueMap.set(partitionKey, itemValue);
+      } else {
+        nextDensifyValueMap.set(partitionKey, lower);
+      }
     }
-    throw new TypeConvertError(`cannot convert '${val}' to ${typename}`);
-}
-exports.toInteger = toInteger;
+    const densifyValue = nextDensifyValueMap.get(partitionKey);
+    if (
+      // current item field value is lower than current densify value.
+      itemValue <= densifyValue || // range value equals or exceeds upper bound
+      upper != "full" && upper != "partition" && densifyValue >= upper
+    ) {
+      if (densifyValue <= itemValue) {
+        nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));
+      }
+      updateMaxFieldValue(itemValue);
+      return item;
+    }
+    nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));
+    updateMaxFieldValue(densifyValue);
+    const denseObj = { [expr.field]: densifyValue };
+    if (partitionKey) {
+      partitionKey.forEach((v, i) => {
+        denseObj[expr.partitionByFields[i]] = v;
+      });
+    }
+    peekItem.push(item);
+    return { done: false, value: denseObj };
+  });
+  if (lower !== "full") return (0, import_lazy.concat)(nilFieldsIterator, densifyIterator);
+  let paritionIndex = -1;
+  let partitionKeysSet = void 0;
+  const fullBoundsIterator = (0, import_lazy.Lazy)(() => {
+    if (paritionIndex === -1) {
+      const fullDensifyValue = nextDensifyValueMap.get(rootKey);
+      nextDensifyValueMap.delete(rootKey);
+      partitionKeysSet = Array.from(nextDensifyValueMap.keys());
+      if (partitionKeysSet.length === 0) {
+        partitionKeysSet.push(rootKey);
+        nextDensifyValueMap.set(rootKey, fullDensifyValue);
+      }
+      paritionIndex++;
+    }
+    do {
+      const partitionKey = partitionKeysSet[paritionIndex];
+      const partitionMaxValue = nextDensifyValueMap.get(partitionKey);
+      if (partitionMaxValue < maxFieldValue) {
+        nextDensifyValueMap.set(
+          partitionKey,
+          computeNextValue(partitionMaxValue)
+        );
+        const denseObj = { [expr.field]: partitionMaxValue };
+        partitionKey.forEach((v, i) => {
+          denseObj[expr.partitionByFields[i]] = v;
+        });
+        return { done: false, value: denseObj };
+      }
+      paritionIndex++;
+    } while (paritionIndex < partitionKeysSet.length);
+    return { done: true };
+  });
+  return (0, import_lazy.concat)(nilFieldsIterator, densifyIterator, fullBoundsIterator);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4910:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2543:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$convert = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(1288);
-const toBool_1 = __webpack_require__(4586);
-const toDate_1 = __webpack_require__(7309);
-const toDouble_1 = __webpack_require__(1753);
-const toInt_1 = __webpack_require__(3706);
-const toLong_1 = __webpack_require__(6488);
-const toString_1 = __webpack_require__(6617);
-/**
- * Converts a value to a specified type.
- *
- * @param obj
- * @param expr
- */
-const $convert = (obj, expr, options) => {
-    const args = (0, core_1.computeValue)(obj, expr, null, options);
-    args.onNull = args.onNull === undefined ? null : args.onNull;
-    if ((0, util_1.isNil)(args.input))
-        return args.onNull;
-    try {
-        switch (args.to) {
-            case 2:
-            case "string":
-                return (0, toString_1.$toString)(obj, args.input, options);
-            case 8:
-            case "boolean":
-            case "bool":
-                return (0, toBool_1.$toBool)(obj, args.input, options);
-            case 9:
-            case "date":
-                return (0, toDate_1.$toDate)(obj, args.input, options);
-            case 1:
-            case 19:
-            case "double":
-            case "decimal":
-            case "number":
-                return (0, toDouble_1.$toDouble)(obj, args.input, options);
-            case 16:
-            case "int":
-                return (0, toInt_1.$toInt)(obj, args.input, options);
-            case 18:
-            case "long":
-                return (0, toLong_1.$toLong)(obj, args.input, options);
-        }
-    }
-    catch (e) {
-        /*nothing to do*/
-    }
-    if (args.onError !== undefined)
-        return args.onError;
-    throw new _internal_1.TypeConvertError(`could not convert to type ${args.to}.`);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$convert = $convert;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var facet_exports = {};
+__export(facet_exports, {
+  $facet: () => $facet
+});
+module.exports = __toCommonJS(facet_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+const $facet = (collection, expr, options) => {
+  return collection.transform((array) => {
+    const o = {};
+    for (const [k, pipeline] of Object.entries(expr)) {
+      o[k] = new import_aggregator.Aggregator(pipeline, {
+        ...options,
+        processingMode: import_core.ProcessingMode.CLONE_INPUT
+      }).run(array);
+    }
+    return [o];
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1146:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 2343:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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]; } };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fill_exports = {};
+__export(fill_exports, {
+  $fill: () => $fill
+});
+module.exports = __toCommonJS(fill_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_ifNull = __webpack_require__(3653);
+var import_linearFill = __webpack_require__(4276);
+var import_locf = __webpack_require__(4140);
+var import_addFields = __webpack_require__(5770);
+var import_setWindowFields = __webpack_require__(3805);
+const FILL_METHODS = {
+  locf: "$locf",
+  linear: "$linearFill"
+};
+const $fill = (collection, expr, options) => {
+  (0, import_util.assert)(!expr.sortBy || (0, import_util.isObject)(expr.sortBy), "sortBy must be an object.");
+  (0, import_util.assert)(
+    !!expr.sortBy || Object.values(expr.output).every((m) => (0, import_util.has)(m, "value")),
+    "sortBy required if any output field specifies a 'method'."
+  );
+  (0, import_util.assert)(
+    !(expr.partitionBy && expr.partitionByFields),
+    "specify either partitionBy or partitionByFields."
+  );
+  (0, import_util.assert)(
+    !expr.partitionByFields || expr?.partitionByFields?.every((s) => s[0] !== "$"),
+    "fields in partitionByFields cannot begin with '$'."
+  );
+  options = (0, import_core.initOptions)(options);
+  options.context.addExpressionOps({ $ifNull: import_ifNull.$ifNull });
+  options.context.addWindowOps({ $locf: import_locf.$locf, $linearFill: import_linearFill.$linearFill });
+  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => `$${s}`);
+  const valueExpr = {};
+  const methodExpr = {};
+  for (const [k, m] of Object.entries(expr.output)) {
+    if ((0, import_util.has)(m, "value")) {
+      valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m["value"]] };
+    } else {
+      const fillOp = FILL_METHODS[m["method"]];
+      (0, import_util.assert)(!!fillOp, `invalid fill method '${m["method"]}'.`);
+      methodExpr[k] = { [fillOp]: "$" + k };
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  }
+  if (Object.keys(methodExpr).length > 0) {
+    collection = (0, import_setWindowFields.$setWindowFields)(
+      collection,
+      {
+        sortBy: expr.sortBy || {},
+        partitionBy: partitionExpr,
+        output: methodExpr
+      },
+      options
+    );
+  }
+  if (Object.keys(valueExpr).length > 0) {
+    collection = (0, import_addFields.$addFields)(collection, valueExpr, options);
+  }
+  return collection;
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(4910), exports);
-__exportStar(__webpack_require__(3429), exports);
-__exportStar(__webpack_require__(4586), exports);
-__exportStar(__webpack_require__(7309), exports);
-__exportStar(__webpack_require__(9239), exports);
-__exportStar(__webpack_require__(1753), exports);
-__exportStar(__webpack_require__(3706), exports);
-__exportStar(__webpack_require__(6488), exports);
-__exportStar(__webpack_require__(6617), exports);
-__exportStar(__webpack_require__(4446), exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3429:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8194:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$isNumber = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Checks if the specified expression resolves to a numeric value
- *
- * @param obj
- * @param expr
- */
-const $isNumber = (obj, expr, options) => {
-    const n = (0, core_1.computeValue)(obj, expr, null, options);
-    return (0, util_1.isNumber)(n);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphLookup_exports = {};
+__export(graphLookup_exports, {
+  $graphLookup: () => $graphLookup
+});
+module.exports = __toCommonJS(graphLookup_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+var import_lookup = __webpack_require__(3704);
+const $graphLookup = (collection, expr, options) => {
+  const fromColl = (0, import_util.isString)(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
+  const {
+    connectFromField,
+    connectToField,
+    as: asField,
+    maxDepth,
+    depthField,
+    restrictSearchWithMatch: matchExpr
+  } = expr;
+  const pipelineExpr = matchExpr ? { pipeline: [{ $match: matchExpr }] } : {};
+  return collection.map((obj) => {
+    const matchObj = {};
+    (0, import_util.setValue)(
+      matchObj,
+      connectFromField,
+      (0, import_core.computeValue)(obj, expr.startWith, null, options)
+    );
+    let matches = [matchObj];
+    let i = -1;
+    const map = import_util.ValueMap.init(options.hashFunction);
+    do {
+      i++;
+      matches = (0, import_util.flatten)(
+        (0, import_lookup.$lookup)(
+          (0, import_lazy.Lazy)(matches),
+          {
+            from: fromColl,
+            localField: connectFromField,
+            foreignField: connectToField,
+            as: asField,
+            ...pipelineExpr
+          },
+          options
+        ).map((o) => o[asField]).value()
+      );
+      const oldSize = map.size;
+      matches.forEach((k) => map.set(k, map.get(k) ?? i));
+      if (oldSize == map.size) break;
+    } while ((0, import_util.isNil)(maxDepth) || i < maxDepth);
+    const result = new Array(map.size);
+    let n = 0;
+    map.forEach((v, k) => {
+      result[n++] = Object.assign(depthField ? { [depthField]: v } : {}, k);
+    });
+    return { ...obj, [asField]: result };
+  });
 };
-exports.$isNumber = $isNumber;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4586:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9723:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toBool = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Converts a value to a boolean.
- *
- * @param obj
- * @param expr
- */
-const $toBool = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(val))
-        return null;
-    if ((0, util_1.isString)(val))
-        return true;
-    return Boolean(val);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var group_exports = {};
+__export(group_exports, {
+  $group: () => $group
+});
+module.exports = __toCommonJS(group_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const ID_KEY = "_id";
+const $group = (collection, expr, options) => {
+  (0, import_util.assert)((0, import_util.has)(expr, ID_KEY), "$group specification must include an '_id'");
+  const idExpr = expr[ID_KEY];
+  const copts = import_core.ComputeOptions.init(options);
+  const newFields = Object.keys(expr).filter((k) => k != ID_KEY);
+  return collection.transform((coll) => {
+    const partitions = (0, import_util.groupBy)(
+      coll,
+      (obj) => (0, import_core.computeValue)(obj, idExpr, null, options),
+      options.hashFunction
+    );
+    let i = -1;
+    const partitionKeys = Array.from(partitions.keys());
+    return () => {
+      if (++i === partitions.size) return { done: true };
+      const groupId = partitionKeys[i];
+      const obj = {};
+      if (groupId !== void 0) {
+        obj[ID_KEY] = groupId;
+      }
+      for (const key of newFields) {
+        obj[key] = (0, import_core.computeValue)(
+          partitions.get(groupId),
+          expr[key],
+          null,
+          copts.update(null, { groupId })
+        );
+      }
+      return { value: obj, done: false };
+    };
+  });
 };
-exports.$toBool = $toBool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7309:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 6936:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pipeline_exports = {};
+module.exports = __toCommonJS(pipeline_exports);
+__reExport(pipeline_exports, __webpack_require__(5770), module.exports);
+__reExport(pipeline_exports, __webpack_require__(308), module.exports);
+__reExport(pipeline_exports, __webpack_require__(7267), module.exports);
+__reExport(pipeline_exports, __webpack_require__(11), module.exports);
+__reExport(pipeline_exports, __webpack_require__(3710), module.exports);
+__reExport(pipeline_exports, __webpack_require__(2543), module.exports);
+__reExport(pipeline_exports, __webpack_require__(2343), module.exports);
+__reExport(pipeline_exports, __webpack_require__(8194), module.exports);
+__reExport(pipeline_exports, __webpack_require__(9723), module.exports);
+__reExport(pipeline_exports, __webpack_require__(4483), module.exports);
+__reExport(pipeline_exports, __webpack_require__(3704), module.exports);
+__reExport(pipeline_exports, __webpack_require__(593), module.exports);
+__reExport(pipeline_exports, __webpack_require__(3508), module.exports);
+__reExport(pipeline_exports, __webpack_require__(6276), module.exports);
+__reExport(pipeline_exports, __webpack_require__(2401), module.exports);
+__reExport(pipeline_exports, __webpack_require__(7191), module.exports);
+__reExport(pipeline_exports, __webpack_require__(31), module.exports);
+__reExport(pipeline_exports, __webpack_require__(824), module.exports);
+__reExport(pipeline_exports, __webpack_require__(9060), module.exports);
+__reExport(pipeline_exports, __webpack_require__(9640), module.exports);
+__reExport(pipeline_exports, __webpack_require__(3805), module.exports);
+__reExport(pipeline_exports, __webpack_require__(8861), module.exports);
+__reExport(pipeline_exports, __webpack_require__(4290), module.exports);
+__reExport(pipeline_exports, __webpack_require__(7708), module.exports);
+__reExport(pipeline_exports, __webpack_require__(1347), module.exports);
+__reExport(pipeline_exports, __webpack_require__(829), module.exports);
+__reExport(pipeline_exports, __webpack_require__(3143), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 4483:
+/***/ ((module) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toDate = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(1288);
-/**
- * Converts a value to a date. If the value cannot be converted to a date, $toDate errors. If the value is null or missing, $toDate returns null.
- *
- * @param obj
- * @param expr
- */
-const $toDate = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if (val instanceof Date)
-        return val;
-    if ((0, util_1.isNil)(val))
-        return null;
-    const d = new Date(val);
-    const n = d.getTime();
-    if (!isNaN(n))
-        return d;
-    throw new _internal_1.TypeConvertError(`cannot convert '${val}' to date`);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$toDate = $toDate;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var limit_exports = {};
+__export(limit_exports, {
+  $limit: () => $limit
+});
+module.exports = __toCommonJS(limit_exports);
+const $limit = (collection, expr, _options) => collection.take(expr);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9239:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3704:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toDecimal = void 0;
-const toDouble_1 = __webpack_require__(1753);
-/**
- * Converts a value to a decimal. If the value cannot be converted to a decimal, $toDecimal errors.
- * If the value is null or missing, $toDecimal returns null.
- * This is just an alias for `$toDouble` in this library.
- */
-exports.$toDecimal = toDouble_1.$toDouble;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lookup_exports = {};
+__export(lookup_exports, {
+  $lookup: () => $lookup
+});
+module.exports = __toCommonJS(lookup_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $lookup = (collection, expr, options) => {
+  const joinColl = (0, import_util.isString)(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
+  const { let: letExpr, pipeline, foreignField, localField } = expr;
+  const subQueryPipeline = pipeline || [];
+  let lookupEq = (_) => [true, []];
+  if (foreignField && localField) {
+    const map = import_util.ValueMap.init(options.hashFunction);
+    for (const doc of joinColl) {
+      (0, import_util.ensureArray)((0, import_util.resolve)(doc, foreignField) ?? null).forEach((v) => {
+        const xs = map.get(v);
+        const arr = xs ?? [];
+        arr.push(doc);
+        if (arr !== xs) map.set(v, arr);
+      });
+    }
+    lookupEq = (o) => {
+      const local = (0, import_util.resolve)(o, localField) ?? null;
+      if ((0, import_util.isArray)(local)) {
+        if (subQueryPipeline.length) {
+          return [local.some((v) => map.has(v)), null];
+        }
+        const result2 = Array.from(
+          new Set((0, import_util.flatten)(local.map((v) => map.get(v), options.hashFunction)))
+        );
+        return [result2.length > 0, result2];
+      }
+      const result = map.get(local) ?? null;
+      return [result !== null, result ?? []];
+    };
+    if (subQueryPipeline.length === 0) {
+      return collection.map((obj) => {
+        return {
+          ...obj,
+          [expr.as]: lookupEq(obj).pop()
+        };
+      });
+    }
+  }
+  const agg = new import_aggregator.Aggregator(subQueryPipeline, options);
+  return collection.map((obj) => {
+    const variables = (0, import_core.computeValue)(obj, letExpr, null, options);
+    const opts = Object.assign({}, options, {
+      variables: { ...options.variables, ...variables }
+    });
+    const [ok, res] = lookupEq(obj);
+    return {
+      ...obj,
+      [expr.as]: ok ? agg.run(joinColl, opts) : res
+    };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1753:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ 593:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var match_exports = {};
+__export(match_exports, {
+  $match: () => $match
+});
+module.exports = __toCommonJS(match_exports);
+var import_query = __webpack_require__(6535);
+const $match = (collection, expr, options) => {
+  const q = new import_query.Query(expr, options);
+  return collection.filter((o) => q.test(o));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toDouble = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(1288);
-/**
- * Converts a value to a double. If the value cannot be converted to an double, $toDouble errors. If the value is null or missing, $toDouble returns null.
- *
- * @param obj
- * @param expr
- */
-const $toDouble = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(val))
-        return null;
-    if (val instanceof Date)
-        return val.getTime();
-    if (val === true)
-        return 1;
-    if (val === false)
-        return 0;
-    const n = Number(val);
-    if ((0, util_1.isNumber)(n))
-        return n;
-    throw new _internal_1.TypeConvertError(`cannot convert '${val}' to double/decimal`);
+
+/***/ }),
+
+/***/ 3508:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var merge_exports = {};
+__export(merge_exports, {
+  $merge: () => $merge
+});
+module.exports = __toCommonJS(merge_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+var import_expression = __webpack_require__(5764);
+const $merge = (collection, expr, options) => {
+  const output = (0, import_util.isString)(expr.into) ? options?.collectionResolver(expr.into) : expr.into;
+  (0, import_util.assert)((0, import_util.isArray)(output), `$merge: option 'into' must resolve to an array`);
+  const onField = expr.on || options.idKey;
+  const getHash = (0, import_util.isString)(onField) ? (o) => (0, import_util.hashCode)((0, import_util.resolve)(o, onField), options.hashFunction) : (o) => (0, import_util.hashCode)(onField.map((s) => (0, import_util.resolve)(o, s), options.hashFunction));
+  const map = import_util.ValueMap.init();
+  for (let i = 0; i < output.length; i++) {
+    const obj = output[i];
+    const k = getHash(obj);
+    (0, import_util.assert)(
+      !map.has(k),
+      "$merge: 'into' collection must have unique entries for the 'on' field."
+    );
+    map.set(k, [obj, i]);
+  }
+  const copts = import_core.ComputeOptions.init(options);
+  return collection.map((o) => {
+    const k = getHash(o);
+    if (map.has(k)) {
+      const [target, i] = map.get(k);
+      const variables = (0, import_core.computeValue)(
+        target,
+        expr.let || { new: "$$ROOT" },
+        null,
+        // 'root' is the item from the iteration.
+        copts.update(o)
+      );
+      if ((0, import_util.isArray)(expr.whenMatched)) {
+        const aggregator = new import_aggregator.Aggregator(expr.whenMatched, {
+          ...options,
+          variables
+        });
+        output[i] = aggregator.run([target])[0];
+      } else {
+        switch (expr.whenMatched) {
+          case "replace":
+            output[i] = o;
+            break;
+          case "fail":
+            throw new import_util.MingoError(
+              "$merge: failed due to matching as specified by 'whenMatched' option."
+            );
+          case "keepExisting":
+            break;
+          case "merge":
+          default:
+            output[i] = (0, import_expression.$mergeObjects)(
+              target,
+              [target, o],
+              // 'root' is the item from the iteration.
+              copts.update(o, { variables })
+            );
+            break;
+        }
+      }
+    } else {
+      switch (expr.whenNotMatched) {
+        case "discard":
+          break;
+        case "fail":
+          throw new import_util.MingoError(
+            "$merge: failed due to matching as specified by 'whenMatched' option."
+          );
+        case "insert":
+        default:
+          output.push(o);
+          break;
+      }
+    }
+    return o;
+  });
 };
-exports.$toDouble = $toDouble;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3706:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6276:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toInt = void 0;
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(1288);
-/**
- * Converts a value to an integer. If the value cannot be converted to an integer, $toInt errors. If the value is null or missing, $toInt returns null.
- * @param obj
- * @param expr
- */
-const $toInt = (obj, expr, options) => {
-    return (0, _internal_1.toInteger)(obj, expr, options, util_1.MAX_INT, util_1.MIN_INT, "int");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$toInt = $toInt;
-
-
-/***/ }),
-
-/***/ 6488:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toLong = void 0;
-const util_1 = __webpack_require__(7216);
-const _internal_1 = __webpack_require__(1288);
-/**
- * Converts a value to a long. If the value cannot be converted to a long, $toLong errors. If the value is null or missing, $toLong returns null.
- * @param obj
- * @param expr
- */
-const $toLong = (obj, expr, options) => {
-    return (0, _internal_1.toInteger)(obj, expr, options, util_1.MAX_LONG, util_1.MIN_LONG, "long");
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var out_exports = {};
+__export(out_exports, {
+  $out: () => $out
+});
+module.exports = __toCommonJS(out_exports);
+var import_util = __webpack_require__(7839);
+const $out = (collection, expr, options) => {
+  const outputColl = (0, import_util.isString)(expr) ? options?.collectionResolver(expr) : expr;
+  (0, import_util.assert)((0, import_util.isArray)(outputColl), `expression must resolve to an array`);
+  return collection.map((o) => {
+    outputColl.push((0, import_util.cloneDeep)(o));
+    return o;
+  });
 };
-exports.$toLong = $toLong;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6617:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2401:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$toString = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const dateToString_1 = __webpack_require__(1300);
-const $toString = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    if ((0, util_1.isNil)(val))
-        return null;
-    if (val instanceof Date) {
-        const dateExpr = {
-            date: expr,
-            format: "%Y-%m-%dT%H:%M:%S.%LZ"
-        };
-        return (0, dateToString_1.$dateToString)(obj, dateExpr, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_exports = {};
+__export(project_exports, {
+  $project: () => $project
+});
+module.exports = __toCommonJS(project_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const DESCRIPTORS = new Set(Array.from([0, 1, false, true]));
+const $project = (collection, expr, options) => {
+  if ((0, import_util.isEmpty)(expr)) return collection;
+  const expressionKeys = Object.keys(expr);
+  validateExpression(expr, options);
+  const ID_KEY = options.idKey;
+  if (!expressionKeys.includes(ID_KEY)) {
+    expressionKeys.push(ID_KEY);
+  }
+  const copts = import_core.ComputeOptions.init(options);
+  return collection.map((obj) => processObject(obj, expr, copts.update(obj), expressionKeys));
+};
+function processObject(obj, expr, options, expressionKeys) {
+  let newObj = {};
+  let foundSlice = false;
+  let foundExclusion = false;
+  const idOnlyExcluded = expr[options.idKey] === 0 && expressionKeys.length === 1;
+  const dropKeys = [];
+  if (idOnlyExcluded) {
+    dropKeys.push(options.idKey);
+  }
+  for (const key of expressionKeys) {
+    let value = void 0;
+    const subExpr = expr[key];
+    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {
+      foundExclusion = true;
+    }
+    if (key === options.idKey && (0, import_util.isEmpty)(subExpr)) {
+      value = obj[key];
+    } else if ((0, import_util.isString)(subExpr)) {
+      value = (0, import_core.computeValue)(obj, subExpr, key, options);
+    } else if (subExpr === 1 || subExpr === true) {
+    } else if ((0, import_util.isArray)(subExpr)) {
+      value = subExpr.map((v) => {
+        const r = (0, import_core.computeValue)(obj, v, null, options);
+        if ((0, import_util.isNil)(r)) return null;
+        return r;
+      });
+    } else if ((0, import_util.isObject)(subExpr)) {
+      const subExprObj = subExpr;
+      const subExprKeys = Object.keys(subExpr);
+      const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
+      const call = (0, import_core.getOperator)(
+        "projection",
+        operator,
+        options
+      );
+      if (call) {
+        if (operator === "$slice") {
+          if ((0, import_util.ensureArray)(subExprObj[operator]).every(import_util.isNumber)) {
+            value = call(obj, subExprObj[operator], key, options);
+            foundSlice = true;
+          } else {
+            value = (0, import_core.computeValue)(obj, subExprObj, key, options);
+          }
+        } else {
+          value = call(obj, subExprObj[operator], key, options);
+        }
+      } else if ((0, import_util.isOperator)(operator)) {
+        value = (0, import_core.computeValue)(obj, subExprObj[operator], operator, options);
+      } else if ((0, import_util.has)(obj, key)) {
+        validateExpression(subExprObj, options);
+        let target = obj[key];
+        if ((0, import_util.isArray)(target)) {
+          value = target.map(
+            (o) => processObject(o, subExprObj, options, subExprKeys)
+          );
+        } else {
+          target = (0, import_util.isObject)(target) ? target : obj;
+          value = processObject(
+            target,
+            subExprObj,
+            options,
+            subExprKeys
+          );
+        }
+      } else {
+        value = (0, import_core.computeValue)(obj, subExpr, null, options);
+      }
+    } else {
+      dropKeys.push(key);
+      continue;
     }
-    else {
-        return val.toString();
+    const objPathGraph = (0, import_util.resolveGraph)(obj, key, {
+      preserveMissing: true
+    });
+    if ((0, import_util.isObject)(objPathGraph)) {
+      (0, import_util.merge)(newObj, objPathGraph);
     }
-};
-exports.$toString = $toString;
+    if (!DESCRIPTORS.has(subExpr)) {
+      if (value === void 0) {
+        (0, import_util.removeValue)(newObj, key, { descendArray: true });
+      } else {
+        (0, import_util.setValue)(newObj, key, value);
+      }
+    }
+  }
+  (0, import_util.filterMissing)(newObj);
+  if (foundSlice || foundExclusion || idOnlyExcluded) {
+    newObj = (0, import_util.into)({}, obj, newObj);
+    if (dropKeys.length > 0) {
+      for (const k of dropKeys) {
+        (0, import_util.removeValue)(newObj, k, { descendArray: true });
+      }
+    }
+  }
+  return newObj;
+}
+function validateExpression(expr, options) {
+  const check = [false, false];
+  for (const [k, v] of Object.entries(expr)) {
+    if (k === options?.idKey) return;
+    if (v === 0 || v === false) {
+      check[0] = true;
+    } else if (v === 1 || v === true) {
+      check[1] = true;
+    }
+    (0, import_util.assert)(
+      !(check[0] && check[1]),
+      "Projection cannot have a mix of inclusion and exclusion."
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4446:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7191:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$type = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const $type = (obj, expr, options) => {
-    const val = (0, core_1.computeValue)(obj, expr, null, options);
-    const typename = (0, util_1.getType)(val);
-    const nativeType = typename.toLowerCase();
-    switch (nativeType) {
-        case "boolean":
-            return "bool";
-        case "number":
-            if (val.toString().indexOf(".") >= 0)
-                return "double";
-            return val >= util_1.MIN_INT && val <= util_1.MAX_INT ? "int" : "long";
-        case "regexp":
-            return "regex";
-        default:
-            return nativeType;
-    }
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redact_exports = {};
+__export(redact_exports, {
+  $redact: () => $redact
+});
+module.exports = __toCommonJS(redact_exports);
+var import_core = __webpack_require__(2760);
+const $redact = (collection, expr, options) => {
+  const copts = import_core.ComputeOptions.init(options);
+  return collection.map(
+    (obj) => (0, import_core.redact)(obj, expr, copts.update(obj))
+  );
 };
-exports.$type = $type;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4354:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 31:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(9442), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replaceRoot_exports = {};
+__export(replaceRoot_exports, {
+  $replaceRoot: () => $replaceRoot
+});
+module.exports = __toCommonJS(replaceRoot_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $replaceRoot = (collection, expr, options) => {
+  return collection.map((obj) => {
+    obj = (0, import_core.computeValue)(obj, expr.newRoot, null, options);
+    (0, import_util.assert)((0, import_util.isObject)(obj), "$replaceRoot expression must return an object");
+    return obj;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9442:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 824:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Variable Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#variable-expression-operators
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$let = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Defines variables for use within the scope of a sub-expression and returns the result of the sub-expression.
- *
- * @param obj The target object for this expression
- * @param expr The right-hand side of the operator
- * @param options Options to use for this operattion
- * @returns {*}
- */
-const $let = (obj, expr, options) => {
-    // resolve vars
-    const variables = {};
-    for (const [key, val] of Object.entries(expr.vars)) {
-        variables[key] = (0, core_1.computeValue)(obj, val, null, options);
-    }
-    return (0, core_1.computeValue)(obj, expr.in, null, core_1.ComputeOptions.init(options, obj, { variables }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$let = $let;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replaceWith_exports = {};
+__export(replaceWith_exports, {
+  $replaceWith: () => $replaceWith
+});
+module.exports = __toCommonJS(replaceWith_exports);
+var import_core = __webpack_require__(2760);
+var import_util = __webpack_require__(7839);
+const $replaceWith = (collection, expr, options) => {
+  return collection.map((obj) => {
+    obj = (0, import_core.computeValue)(obj, expr, null, options);
+    (0, import_util.assert)((0, import_util.isObject)(obj), "$replaceWith expression must return an object");
+    return obj;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2899:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 9060:
+/***/ ((module) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isUnbounded = void 0;
-/** Checks whether the specified window is unbounded. */
-const isUnbounded = (window) => {
-    const boundary = (window === null || window === void 0 ? void 0 : window.documents) || (window === null || window === void 0 ? void 0 : window.range);
-    return (!boundary || (boundary[0] === "unbounded" && boundary[1] === "unbounded"));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sample_exports = {};
+__export(sample_exports, {
+  $sample: () => $sample
+});
+module.exports = __toCommonJS(sample_exports);
+const $sample = (collection, expr, _options) => {
+  return collection.transform((xs) => {
+    const len = xs.length;
+    let i = -1;
+    return () => {
+      if (++i === expr.size) return { done: true };
+      const n = Math.floor(Math.random() * len);
+      return { value: xs[n], done: false };
+    };
+  });
 };
-exports.isUnbounded = isUnbounded;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1692:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9640:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$addFields = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Adds new fields to documents.
- * Outputs documents that contain all existing fields from the input documents and newly added fields.
- *
- * @param {Iterator} collection
- * @param {Object} expr
- * @param {Options} options
- */
-const $addFields = (collection, expr, options) => {
-    const newFields = Object.keys(expr);
-    if (newFields.length === 0)
-        return collection;
-    return collection.map(((obj) => {
-        const newObj = Object.assign({}, obj);
-        for (const field of newFields) {
-            const newValue = (0, core_1.computeValue)(obj, expr[field], null, options);
-            if (newValue !== undefined) {
-                (0, util_1.setValue)(newObj, field, newValue);
-            }
-            else {
-                (0, util_1.removeValue)(newObj, field);
-            }
-        }
-        return newObj;
-    }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$addFields = $addFields;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  $set: () => $set
+});
+module.exports = __toCommonJS(set_exports);
+var import_addFields = __webpack_require__(5770);
+const $set = import_addFields.$addFields;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2985:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3805:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bucket = void 0;
-const core_1 = __webpack_require__(9587);
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Categorizes incoming documents into groups, called buckets, based on a specified expression and bucket boundaries.
- * https://docs.mongodb.com/manual/reference/operator/aggregation/bucket/
- *
- * @param {*} collection
- * @param {*} expr
- * @param {Options} opt Pipeline options
- */
-const $bucket = (collection, expr, options) => {
-    const boundaries = [...expr.boundaries];
-    const defaultKey = expr.default;
-    const lower = boundaries[0]; // inclusive
-    const upper = boundaries[boundaries.length - 1]; // exclusive
-    const outputExpr = expr.output || { count: { $sum: 1 } };
-    (0, util_1.assert)(expr.boundaries.length > 2, "$bucket 'boundaries' expression must have at least 3 elements");
-    const boundType = (0, util_1.getType)(lower);
-    for (let i = 0, len = boundaries.length - 1; i < len; i++) {
-        (0, util_1.assert)(boundType === (0, util_1.getType)(boundaries[i + 1]), "$bucket 'boundaries' must all be of the same type");
-        (0, util_1.assert)((0, util_1.compare)(boundaries[i], boundaries[i + 1]) < 0, "$bucket 'boundaries' must be sorted in ascending order");
-    }
-    !(0, util_1.isNil)(defaultKey) &&
-        (0, util_1.getType)(expr.default) === (0, util_1.getType)(lower) &&
-        (0, util_1.assert)((0, util_1.compare)(expr.default, upper) >= 0 || (0, util_1.compare)(expr.default, lower) < 0, "$bucket 'default' expression must be out of boundaries range");
-    const grouped = {};
-    for (const k of boundaries) {
-        grouped[k] = [];
-    }
-    // add default key if provided
-    if (!(0, util_1.isNil)(defaultKey))
-        grouped[defaultKey] = [];
-    let iterator;
-    return (0, lazy_1.Lazy)(() => {
-        if (!iterator) {
-            collection.each(((obj) => {
-                const key = (0, core_1.computeValue)(obj, expr.groupBy, null, options);
-                if ((0, util_1.isNil)(key) || (0, util_1.compare)(key, lower) < 0 || (0, util_1.compare)(key, upper) >= 0) {
-                    (0, util_1.assert)(!(0, util_1.isNil)(defaultKey), "$bucket require a default for out of range values");
-                    grouped[defaultKey].push(obj);
-                }
-                else {
-                    (0, util_1.assert)((0, util_1.compare)(key, lower) >= 0 && (0, util_1.compare)(key, upper) < 0, "$bucket 'groupBy' expression must resolve to a value in range of boundaries");
-                    const index = findInsertIndex(boundaries, key);
-                    const boundKey = boundaries[Math.max(0, index - 1)];
-                    grouped[boundKey].push(obj);
-                }
-            }));
-            // upper bound is exclusive so we remove it
-            boundaries.pop();
-            if (!(0, util_1.isNil)(defaultKey))
-                boundaries.push(defaultKey);
-            iterator = (0, lazy_1.Lazy)(boundaries).map(((key) => {
-                const acc = (0, core_1.computeValue)(grouped[key], outputExpr, null, options);
-                return (0, util_1.into)(acc, { _id: key });
-            }));
-        }
-        return iterator.next();
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$bucket = $bucket;
-/**
- * Find the insert index for the given key in a sorted array.
- *
- * @param {*} sorted The sorted array to search
- * @param {*} item The search key
- */
-function findInsertIndex(sorted, item) {
-    // uses binary search
-    let lo = 0;
-    let hi = sorted.length - 1;
-    while (lo <= hi) {
-        const mid = Math.round(lo + (hi - lo) / 2);
-        if ((0, util_1.compare)(item, sorted[mid]) < 0) {
-            hi = mid - 1;
-        }
-        else if ((0, util_1.compare)(item, sorted[mid]) > 0) {
-            lo = mid + 1;
-        }
-        else {
-            return mid;
-        }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setWindowFields_exports = {};
+__export(setWindowFields_exports, {
+  $setWindowFields: () => $setWindowFields
+});
+module.exports = __toCommonJS(setWindowFields_exports);
+var import_core = __webpack_require__(2760);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+var import_function = __webpack_require__(3388);
+var import_dateAdd = __webpack_require__(8410);
+var import_internal = __webpack_require__(2088);
+var import_addFields = __webpack_require__(5770);
+var import_group = __webpack_require__(9723);
+var import_sort = __webpack_require__(4290);
+const SORT_REQUIRED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$documentNumber",
+  "$first",
+  "$last",
+  "$linearFill",
+  "$rank",
+  "$shift"
+]);
+const WINDOW_UNBOUNDED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$expMovingAvg",
+  "$linearFill",
+  "$locf",
+  "$rank",
+  "$shift"
+]);
+const $setWindowFields = (collection, expr, options) => {
+  options = (0, import_core.initOptions)(options);
+  options.context.addExpressionOps({ $function: import_function.$function });
+  for (const outputExpr of Object.values(expr.output)) {
+    const keys = Object.keys(outputExpr);
+    const op = keys.find(import_util.isOperator);
+    (0, import_util.assert)(
+      !!(0, import_core.getOperator)("window", op, options) || !!(0, import_core.getOperator)("accumulator", op, options),
+      `'${op}' is not a valid window operator`
+    );
+    (0, import_util.assert)(
+      keys.length > 0 && keys.length <= 2 && (keys.length == 1 || keys.includes("window")),
+      "'output' option should have a single window operator."
+    );
+    if (outputExpr?.window) {
+      const { documents, range } = outputExpr.window;
+      (0, import_util.assert)(
+        !!documents && !range || !documents && !!range || !documents && !range,
+        "'window' option supports only one of 'documents' or 'range'."
+      );
     }
-    return lo;
-}
-
-
-/***/ }),
-
-/***/ 8683:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bucketAuto = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Categorizes incoming documents into a specific number of groups, called buckets,
- * based on a specified expression. Bucket boundaries are automatically determined
- * in an attempt to evenly distribute the documents into the specified number of buckets.
- * https://docs.mongodb.com/manual/reference/operator/aggregation/bucketAuto/
- *
- * @param {*} collection
- * @param {*} expr
- * @param {*} options
- */
-const $bucketAuto = (collection, expr, options) => {
-    const outputExpr = expr.output || { count: { $sum: 1 } };
-    const groupByExpr = expr.groupBy;
-    const bucketCount = expr.buckets;
-    (0, util_1.assert)(bucketCount > 0, `The $bucketAuto 'buckets' field must be greater than 0, but found: ${bucketCount}`);
-    const ID_KEY = "_id";
-    return collection.transform((coll) => {
-        const approxBucketSize = Math.max(1, Math.round(coll.length / bucketCount));
-        const computeValueOptimized = (0, util_1.memoize)(core_1.computeValue, options === null || options === void 0 ? void 0 : options.hashFunction);
-        const grouped = new Map();
-        const remaining = [];
-        const sorted = (0, util_1.sortBy)(coll, o => {
-            const key = computeValueOptimized(o, groupByExpr, null, options);
-            if ((0, util_1.isNil)(key)) {
-                remaining.push(o);
-            }
-            else {
-                if (!grouped.has(key))
-                    grouped.set(key, []);
-                grouped.get(key).push(o);
-            }
-            return key;
-        });
-        const result = [];
-        let index = 0; // counter for sorted collection
-        for (let i = 0, len = sorted.length; i < bucketCount && index < len; i++) {
-            const boundaries = {};
-            const bucketItems = [];
-            for (let j = 0; j < approxBucketSize && index < len; j++) {
-                let key = computeValueOptimized(sorted[index], groupByExpr, null, options);
-                if ((0, util_1.isNil)(key))
-                    key = null;
-                // populate current bucket with all values for current key
-                (0, util_1.into)(bucketItems, (0, util_1.isNil)(key) ? remaining : grouped.get(key));
-                // increase sort index by number of items added
-                index += (0, util_1.isNil)(key) ? remaining.length : grouped.get(key).length;
-                // set the min key boundary if not already present
-                if (!(0, util_1.has)(boundaries, "min"))
-                    boundaries.min = key;
-                if (result.length > 0) {
-                    const lastBucket = result[result.length - 1];
-                    lastBucket[ID_KEY].max = boundaries.min;
-                }
-            }
-            // if is last bucket add remaining items
-            if (i == bucketCount - 1) {
-                (0, util_1.into)(bucketItems, sorted.slice(index));
+  }
+  if (expr.sortBy) {
+    collection = (0, import_sort.$sort)(collection, expr.sortBy, options);
+  }
+  collection = (0, import_group.$group)(
+    collection,
+    {
+      _id: expr.partitionBy,
+      items: { $push: "$$CURRENT" }
+    },
+    options
+  );
+  return collection.transform((partitions) => {
+    const iterators = [];
+    const outputConfig = [];
+    for (const [field, outputExpr] of Object.entries(expr.output)) {
+      const op = Object.keys(outputExpr).find(import_util.isOperator);
+      const config = {
+        operatorName: op,
+        func: {
+          left: (0, import_core.getOperator)("accumulator", op, options),
+          right: (0, import_core.getOperator)("window", op, options)
+        },
+        args: outputExpr[op],
+        field,
+        window: outputExpr.window
+      };
+      (0, import_util.assert)(
+        !!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window),
+        `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : "bounded window operation"} requires a sortBy.`
+      );
+      (0, import_util.assert)(
+        !config.window || !WINDOW_UNBOUNDED_OPS.has(op),
+        `${op} does not accept a 'window' field.`
+      );
+      outputConfig.push(config);
+    }
+    partitions.forEach((group) => {
+      const items = group.items;
+      let iterator = (0, import_lazy.Lazy)(items);
+      const windowResultMap = {};
+      for (const config of outputConfig) {
+        const { func, args, field, window } = config;
+        const makeResultFunc = (getItemsFn) => {
+          let index = -1;
+          return (obj) => {
+            ++index;
+            if (func.left) {
+              return func.left(getItemsFn(obj, index), args, options);
+            } else if (func.right) {
+              return func.right(
+                obj,
+                getItemsFn(obj, index),
+                {
+                  parentExpr: expr,
+                  inputExpr: args,
+                  documentNumber: index + 1,
+                  field
+                },
+                // must use raw options only since it operates over a collection.
+                options
+              );
             }
-            const values = (0, core_1.computeValue)(bucketItems, outputExpr, null, options);
-            result.push((0, util_1.into)(values, {
-                _id: boundaries
-            }));
+          };
+        };
+        if (window) {
+          const { documents, range, unit } = window;
+          const boundary = documents || range;
+          if (!(0, import_internal.isUnbounded)(window)) {
+            const [begin, end] = boundary;
+            const toBeginIndex = (currentIndex) => {
+              if (begin == "current") return currentIndex;
+              if (begin == "unbounded") return 0;
+              return Math.max(begin + currentIndex, 0);
+            };
+            const toEndIndex = (currentIndex) => {
+              if (end == "current") return currentIndex + 1;
+              if (end == "unbounded") return items.length;
+              return end + currentIndex + 1;
+            };
+            const getItems = (current, index) => {
+              if (!!documents || boundary.every(import_util.isString)) {
+                return items.slice(toBeginIndex(index), toEndIndex(index));
+              }
+              const sortKey = Object.keys(expr.sortBy)[0];
+              let lower;
+              let upper;
+              if (unit) {
+                const getTime = (amount) => {
+                  return (0, import_dateAdd.$dateAdd)(
+                    current,
+                    {
+                      startDate: new Date(current[sortKey]),
+                      unit,
+                      amount
+                    },
+                    options
+                  ).getTime();
+                };
+                lower = (0, import_util.isNumber)(begin) ? getTime(begin) : -Infinity;
+                upper = (0, import_util.isNumber)(end) ? getTime(end) : Infinity;
+              } else {
+                const currentValue = current[sortKey];
+                lower = (0, import_util.isNumber)(begin) ? currentValue + begin : -Infinity;
+                upper = (0, import_util.isNumber)(end) ? currentValue + end : Infinity;
+              }
+              let array = items;
+              if (begin == "current") array = items.slice(index);
+              if (end == "current") array = items.slice(0, index + 1);
+              return array.filter((o) => {
+                const n = +o[sortKey];
+                return n >= lower && n <= upper;
+              });
+            };
+            windowResultMap[field] = makeResultFunc(getItems);
+          }
         }
-        if (result.length > 0) {
-            result[result.length - 1][ID_KEY].max =
-                computeValueOptimized(sorted[sorted.length - 1], groupByExpr, null, options);
+        if (!windowResultMap[field]) {
+          windowResultMap[field] = makeResultFunc((_) => items);
         }
-        return result;
+        iterator = (0, import_addFields.$addFields)(
+          iterator,
+          {
+            [field]: {
+              $function: {
+                body: (obj) => windowResultMap[field](obj),
+                args: ["$$CURRENT"]
+              }
+            }
+          },
+          options
+        );
+      }
+      iterators.push(iterator);
     });
+    return (0, import_lazy.concat)(...iterators);
+  });
 };
-exports.$bucketAuto = $bucketAuto;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8980:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$count = void 0;
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Returns a document that contains a count of the number of documents input to the stage.
- *
- * @param {Array} collection
- * @param {String} expr
- * @param {Options} options
- * @return {Object}
- */
-const $count = (collection, expr, _) => {
-    (0, util_1.assert)((0, util_1.isString)(expr) &&
-        expr.trim() !== "" &&
-        expr.indexOf(".") === -1 &&
-        expr.trim()[0] !== "$", "Invalid expression value for $count");
-    return (0, lazy_1.Lazy)([
-        {
-            [expr]: collection.size()
-        }
-    ]);
+/***/ 8861:
+/***/ ((module) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$count = $count;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var skip_exports = {};
+__export(skip_exports, {
+  $skip: () => $skip
+});
+module.exports = __toCommonJS(skip_exports);
+const $skip = (collection, expr, _options) => {
+  return collection.drop(expr);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 10:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4290:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$facet = void 0;
-const aggregator_1 = __webpack_require__(7268);
-const core_1 = __webpack_require__(9587);
-/**
- * Processes multiple aggregation pipelines within a single stage on the same set of input documents.
- * Enables the creation of multi-faceted aggregations capable of characterizing data across multiple dimensions, or facets, in a single stage.
- */
-const $facet = (collection, expr, options) => {
-    return collection.transform(((array) => {
-        const o = {};
-        for (const [k, pipeline] of Object.entries(expr)) {
-            o[k] = new aggregator_1.Aggregator(pipeline, Object.assign(Object.assign({}, options), { processingMode: core_1.ProcessingMode.CLONE_INPUT })).run(array);
-        }
-        return [o];
-    }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sort_exports = {};
+__export(sort_exports, {
+  $sort: () => $sort
+});
+module.exports = __toCommonJS(sort_exports);
+var import_util = __webpack_require__(7839);
+const $sort = (collection, sortKeys, options) => {
+  if ((0, import_util.isEmpty)(sortKeys) || !(0, import_util.isObject)(sortKeys)) return collection;
+  let cmp = import_util.compare;
+  const collationSpec = options.collation;
+  if ((0, import_util.isObject)(collationSpec) && (0, import_util.isString)(collationSpec.locale)) {
+    cmp = collationComparator(collationSpec);
+  }
+  return collection.transform((coll) => {
+    const modifiers = Object.keys(sortKeys);
+    for (const key of modifiers.reverse()) {
+      const groups = (0, import_util.groupBy)(
+        coll,
+        (obj) => (0, import_util.resolve)(obj, key),
+        options.hashFunction
+      );
+      const sortedKeys = Array.from(groups.keys()).sort(cmp);
+      if (sortKeys[key] === -1) sortedKeys.reverse();
+      let i = 0;
+      for (const k of sortedKeys) for (const v of groups.get(k)) coll[i++] = v;
+      (0, import_util.assert)(i == coll.length, "bug: counter must match collection size.");
+    }
+    return coll;
+  });
 };
-exports.$facet = $facet;
+const COLLATION_STRENGTH = {
+  // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.
+  1: "base",
+  //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.
+  // Examples: a ≠ b, a ≠ á, a = A.
+  2: "accent",
+  // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.
+  // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A
+  3: "variant"
+  // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.
+};
+function collationComparator(spec) {
+  const localeOpt = {
+    sensitivity: COLLATION_STRENGTH[spec.strength || 3],
+    caseFirst: spec.caseFirst === "off" ? "false" : spec.caseFirst || "false",
+    numeric: spec.numericOrdering || false,
+    ignorePunctuation: spec.alternate === "shifted"
+  };
+  if ((spec.caseLevel || false) === true) {
+    if (localeOpt.sensitivity === "base") localeOpt.sensitivity = "case";
+    if (localeOpt.sensitivity === "accent") localeOpt.sensitivity = "variant";
+  }
+  const collator = new Intl.Collator(spec.locale, localeOpt);
+  return (a, b) => {
+    if (!(0, import_util.isString)(a) || !(0, import_util.isString)(b)) return (0, import_util.compare)(a, b);
+    const i = collator.compare(a, b);
+    if (i < 0) return -1;
+    if (i > 0) return 1;
+    return 0;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3090:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7708:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$fill = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const ifNull_1 = __webpack_require__(419);
-const linearFill_1 = __webpack_require__(5120);
-const locf_1 = __webpack_require__(8242);
-const addFields_1 = __webpack_require__(1692);
-const setWindowFields_1 = __webpack_require__(8515);
-const FILL_METHODS = {
-    locf: "$locf",
-    linear: "$linearFill"
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-/**
- * Populates null and missing field values within documents.
- *
- * @param {Iterator} collection
- * @param {Object} expr
- * @param {Options} options
- */
-const $fill = (collection, expr, options) => {
-    var _a, _b;
-    (0, util_1.assert)(!expr.sortBy || (0, util_1.isObject)(expr.sortBy), "sortBy must be an object.");
-    (0, util_1.assert)(!!expr.sortBy || Object.values(expr.output).every(m => (0, util_1.has)(m, "value")), "sortBy required if any output field specifies a 'method'.");
-    (0, util_1.assert)(!(expr.partitionBy && expr.partitionByFields), "specify either partitionBy or partitionByFields.");
-    (0, util_1.assert)(!expr.partitionByFields ||
-        ((_a = expr === null || expr === void 0 ? void 0 : expr.partitionByFields) === null || _a === void 0 ? void 0 : _a.every(s => s[0] !== "$")), "fields in partitionByFields cannot begin with '$'.");
-    options = (0, core_1.initOptions)(options);
-    options.context.addExpressionOps({ $ifNull: ifNull_1.$ifNull });
-    options.context.addWindowOps({ $locf: locf_1.$locf, $linearFill: linearFill_1.$linearFill });
-    const partitionExpr = expr.partitionBy || ((_b = expr === null || expr === void 0 ? void 0 : expr.partitionByFields) === null || _b === void 0 ? void 0 : _b.map(s => `$${s}`));
-    // collect and remove all output fields using 'value' instead of 'method'.
-    // if there are any fields remaining, process collection using $setWindowFields.
-    // if the collected output fields is non-empty, use $addFields to add them to their respective partitions.
-    const valueExpr = {};
-    const methodExpr = {};
-    for (const [k, m] of Object.entries(expr.output)) {
-        if ((0, util_1.has)(m, "value")) {
-            // translate to expression for $addFields
-            valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m["value"]] };
-        }
-        else {
-            // translate to output expression for $setWindowFields.
-            const fillOp = FILL_METHODS[m["method"]];
-            (0, util_1.assert)(!!fillOp, `invalid fill method '${m["method"]}'.`);
-            methodExpr[k] = { [fillOp]: "$" + k };
-        }
-    }
-    // perform filling with $setWindowFields
-    if (Object.keys(methodExpr).length > 0) {
-        collection = (0, setWindowFields_1.$setWindowFields)(collection, {
-            sortBy: expr.sortBy || {},
-            partitionBy: partitionExpr,
-            output: methodExpr
-        }, options);
-    }
-    // fill with values
-    if (Object.keys(valueExpr).length > 0) {
-        collection = (0, addFields_1.$addFields)(collection, valueExpr, options);
-    }
-    return collection;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sortByCount_exports = {};
+__export(sortByCount_exports, {
+  $sortByCount: () => $sortByCount
+});
+module.exports = __toCommonJS(sortByCount_exports);
+var import_group = __webpack_require__(9723);
+var import_sort = __webpack_require__(4290);
+const $sortByCount = (collection, expr, options) => {
+  return (0, import_sort.$sort)(
+    (0, import_group.$group)(collection, { _id: expr, count: { $sum: 1 } }, options),
+    { count: -1 },
+    options
+  );
 };
-exports.$fill = $fill;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2683:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1347:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$group = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-// lookup key for grouping
-const ID_KEY = "_id";
-/**
- * Groups documents together for the purpose of calculating aggregate values based on a collection of documents.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {Array}
- */
-const $group = (collection, expr, options) => {
-    (0, util_1.assert)((0, util_1.has)(expr, ID_KEY), "a group specification must include an _id");
-    const idExpr = expr[ID_KEY];
-    const copts = core_1.ComputeOptions.init(options);
-    return collection.transform(((coll) => {
-        const partitions = (0, util_1.groupBy)(coll, obj => (0, core_1.computeValue)(obj, idExpr, null, options), options.hashFunction);
-        // remove the group key
-        expr = Object.assign({}, expr);
-        delete expr[ID_KEY];
-        let i = -1;
-        const partitionKeys = Array.from(partitions.keys());
-        const size = partitions.size;
-        return () => {
-            if (++i === size)
-                return { done: true };
-            const groupId = partitionKeys[i];
-            const obj = {};
-            // exclude undefined key value
-            if (groupId !== undefined) {
-                obj[ID_KEY] = groupId;
-            }
-            // compute remaining keys in expression
-            for (const [key, val] of Object.entries(expr)) {
-                obj[key] = (0, core_1.computeValue)(partitions.get(groupId), val, key, copts.update(null, { groupId }));
-            }
-            return { value: obj, done: false };
-        };
-    }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unionWith_exports = {};
+__export(unionWith_exports, {
+  $unionWith: () => $unionWith
+});
+module.exports = __toCommonJS(unionWith_exports);
+var import_aggregator = __webpack_require__(6878);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+const $unionWith = (collection, expr, options) => {
+  const array = (0, import_util.isString)(expr.coll) ? options.collectionResolver(expr.coll) : expr.coll;
+  const iterators = [collection];
+  iterators.push(
+    expr.pipeline ? new import_aggregator.Aggregator(expr.pipeline, options).stream(array) : (0, import_lazy.Lazy)(array)
+  );
+  return (0, import_lazy.concat)(...iterators);
 };
-exports.$group = $group;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6582:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 829:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Pipeline Aggregation Stages. https://docs.mongodb.com/manual/reference/operator/aggregation-
- */
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(1692), exports);
-__exportStar(__webpack_require__(2985), exports);
-__exportStar(__webpack_require__(8683), exports);
-__exportStar(__webpack_require__(8980), exports);
-__exportStar(__webpack_require__(10), exports);
-__exportStar(__webpack_require__(3090), exports);
-__exportStar(__webpack_require__(2683), exports);
-__exportStar(__webpack_require__(9749), exports);
-__exportStar(__webpack_require__(954), exports);
-__exportStar(__webpack_require__(9157), exports);
-__exportStar(__webpack_require__(159), exports);
-__exportStar(__webpack_require__(6212), exports);
-__exportStar(__webpack_require__(7911), exports);
-__exportStar(__webpack_require__(6402), exports);
-__exportStar(__webpack_require__(6366), exports);
-__exportStar(__webpack_require__(8755), exports);
-__exportStar(__webpack_require__(8027), exports);
-__exportStar(__webpack_require__(4707), exports);
-__exportStar(__webpack_require__(8515), exports);
-__exportStar(__webpack_require__(8377), exports);
-__exportStar(__webpack_require__(5396), exports);
-__exportStar(__webpack_require__(2311), exports);
-__exportStar(__webpack_require__(1655), exports);
-__exportStar(__webpack_require__(3871), exports);
-__exportStar(__webpack_require__(9789), exports);
-
-
-/***/ }),
-
-/***/ 9749:
-/***/ ((__unused_webpack_module, exports) => {
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unset_exports = {};
+__export(unset_exports, {
+  $unset: () => $unset
+});
+module.exports = __toCommonJS(unset_exports);
+var import_util = __webpack_require__(7839);
+var import_project = __webpack_require__(2401);
+const $unset = (collection, expr, options) => {
+  expr = (0, import_util.ensureArray)(expr);
+  const doc = {};
+  for (const k of expr) doc[k] = 0;
+  return (0, import_project.$project)(collection, doc, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-"use strict";
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$limit = void 0;
-/**
- * Restricts the number of documents in an aggregation pipeline.
- *
- * @param collection
- * @param value
- * @param options
- * @returns {Object|*}
- */
-const $limit = (collection, expr, options) => {
-    return collection.take(expr);
+/***/ }),
+
+/***/ 3143:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unwind_exports = {};
+__export(unwind_exports, {
+  $unwind: () => $unwind
+});
+module.exports = __toCommonJS(unwind_exports);
+var import_lazy = __webpack_require__(8625);
+var import_util = __webpack_require__(7839);
+const $unwind = (collection, expr, _options) => {
+  if ((0, import_util.isString)(expr)) expr = { path: expr };
+  const path = expr.path;
+  const field = path.substring(1);
+  const includeArrayIndex = expr?.includeArrayIndex || false;
+  const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;
+  const format = (o, i) => {
+    if (includeArrayIndex !== false) o[includeArrayIndex] = i;
+    return o;
+  };
+  let value;
+  return (0, import_lazy.Lazy)(() => {
+    for (; ; ) {
+      if (value instanceof import_lazy.Iterator) {
+        const tmp = value.next();
+        if (!tmp.done) return tmp;
+      }
+      const wrapper = collection.next();
+      if (wrapper.done) return wrapper;
+      const obj = wrapper.value;
+      value = (0, import_util.resolve)(obj, field);
+      if ((0, import_util.isArray)(value)) {
+        if (value.length === 0 && preserveNullAndEmptyArrays === true) {
+          value = null;
+          (0, import_util.removeValue)(obj, field);
+          return { value: format(obj, null), done: false };
+        } else {
+          value = (0, import_lazy.Lazy)(value).map((item, i) => {
+            const newObj = (0, import_util.resolveGraph)(obj, field, {
+              preserveKeys: true
+            });
+            (0, import_util.setValue)(newObj, field, item);
+            return format(newObj, i);
+          });
+        }
+      } else if (!(0, import_util.isEmpty)(value) || preserveNullAndEmptyArrays === true) {
+        return { value: format(obj, null), done: false };
+      }
+    }
+  });
 };
-exports.$limit = $limit;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 954:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5975:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lookup = void 0;
-const util_1 = __webpack_require__(7216);
-/**
- * Performs a left outer join to another collection in the same database to filter in documents from the “joined” collection for processing.
- *
- * @param collection
- * @param expr
- * @param opt
- */
-const $lookup = (collection, expr, options) => {
-    const joinColl = (0, util_1.isString)(expr.from)
-        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr.from)
-        : expr.from;
-    (0, util_1.assert)(joinColl instanceof Array, `'from' field must resolve to an array`);
-    const hash = {};
-    for (const obj of joinColl) {
-        const k = (0, util_1.hashCode)((0, util_1.resolve)(obj, expr.foreignField), options === null || options === void 0 ? void 0 : options.hashFunction);
-        hash[k] = hash[k] || [];
-        hash[k].push(obj);
-    }
-    return collection.map((obj) => {
-        const k = (0, util_1.hashCode)((0, util_1.resolve)(obj, expr.localField), options === null || options === void 0 ? void 0 : options.hashFunction);
-        const newObj = (0, util_1.into)({}, obj);
-        newObj[expr.as] = hash[k] || [];
-        return newObj;
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elemMatch_exports = {};
+__export(elemMatch_exports, {
+  $elemMatch: () => $elemMatch
+});
+module.exports = __toCommonJS(elemMatch_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+const $elemMatch = (obj, expr, field, options) => {
+  const arr = (0, import_util.resolve)(obj, field);
+  const query = new import_query.Query(expr, options);
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$elemMatch: argument must resolve to array");
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (query.test(arr[i])) {
+      if (options.useStrictMode) return [arr[i]];
+      result.push(arr[i]);
+    }
+  }
+  return result.length > 0 ? result : void 0;
 };
-exports.$lookup = $lookup;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9157:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4487:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$match = void 0;
-const query_1 = __webpack_require__(809);
-/**
- * Filters the document stream, and only allows matching documents to pass into the next pipeline stage.
- * $match uses standard MongoDB queries.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {Array|*}
- */
-const $match = (collection, expr, options) => {
-    const q = new query_1.Query(expr, options);
-    return collection.filter((o) => q.test(o));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$match = $match;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var projection_exports = {};
+module.exports = __toCommonJS(projection_exports);
+__reExport(projection_exports, __webpack_require__(5975), module.exports);
+__reExport(projection_exports, __webpack_require__(2169), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 159:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2169:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$merge = void 0;
-const aggregator_1 = __webpack_require__(7268);
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-const expression_1 = __webpack_require__(8985);
-/**
- * Writes the resulting documents of the aggregation pipeline to a collection.
- *
- * The stage can incorporate (insert new documents, merge documents, replace documents,
- * keep existing documents, fail the operation, process documents with a custom update pipeline)
- * the results into an output collection. To use the $merge stage, it must be the last stage in the pipeline.
- *
- * Note: Object are deep cloned for outputing regardless of the ProcessingMode.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {*}
- */
-const $merge = (collection, expr, options) => {
-    const output = (0, util_1.isString)(expr.into)
-        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr.into)
-        : expr.into;
-    (0, util_1.assert)(output instanceof Array, `$merge: option 'into' must resolve to an array`);
-    const onField = expr.on || options.idKey;
-    const getHash = (o) => {
-        const val = (0, util_1.isString)(onField)
-            ? (0, util_1.resolve)(o, onField)
-            : onField.map(s => (0, util_1.resolve)(o, s));
-        return (0, util_1.hashCode)(val, options.hashFunction);
-    };
-    const hash = {};
-    // we assuming the lookup expressions are unique
-    for (let i = 0; i < output.length; i++) {
-        const obj = output[i];
-        const k = getHash(obj);
-        (0, util_1.assert)(!hash[k], "$merge: 'into' collection must have unique entries for the 'on' field.");
-        hash[k] = [obj, i];
-    }
-    const copts = core_1.ComputeOptions.init(options);
-    return collection.map((o) => {
-        const k = getHash(o);
-        if (hash[k]) {
-            const [target, i] = hash[k];
-            // compute variables
-            const variables = (0, core_1.computeValue)(target, expr.let || { new: "$$ROOT" }, null, 
-            // 'root' is the item from the iteration.
-            copts.update(o));
-            if ((0, util_1.isArray)(expr.whenMatched)) {
-                const aggregator = new aggregator_1.Aggregator(expr.whenMatched, Object.assign(Object.assign({}, options), { variables }));
-                output[i] = aggregator.run([target])[0];
-            }
-            else {
-                switch (expr.whenMatched) {
-                    case "replace":
-                        output[i] = o;
-                        break;
-                    case "fail":
-                        throw new Error("$merge: failed due to matching as specified by 'whenMatched' option.");
-                    case "keepExisting":
-                        break;
-                    case "merge":
-                    default:
-                        output[i] = (0, expression_1.$mergeObjects)(target, [target, o], 
-                        // 'root' is the item from the iteration.
-                        copts.update(o, { variables }));
-                        break;
-                }
-            }
-        }
-        else {
-            switch (expr.whenNotMatched) {
-                case "discard":
-                    break;
-                case "fail":
-                    throw new Error("$merge: failed due to matching as specified by 'whenMatched' option.");
-                case "insert":
-                default:
-                    output.push(o);
-                    break;
-            }
-        }
-        return o; // passthrough
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var slice_exports = {};
+__export(slice_exports, {
+  $slice: () => $slice
+});
+module.exports = __toCommonJS(slice_exports);
+var import_util = __webpack_require__(7839);
+var import_slice = __webpack_require__(7292);
+const $slice = (obj, expr, field, options) => {
+  const xs = (0, import_util.resolve)(obj, field);
+  const exprAsArray = expr;
+  if (!(0, import_util.isArray)(xs)) return xs;
+  return (0, import_slice.$slice)(
+    obj,
+    (0, import_util.isArray)(expr) ? [xs, ...exprAsArray] : [xs, expr],
+    options
+  );
 };
-exports.$merge = $merge;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6212:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6007:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$out = void 0;
-const util_1 = __webpack_require__(7216);
-/**
- * Takes the documents returned by the aggregation pipeline and writes them to a specified collection.
- *
- * Unlike the $out operator in MongoDB, this operator can appear in any position in the pipeline and is
- * useful for collecting intermediate results of an aggregation operation.
- *
- * Note: Object are deep cloned for outputing regardless of the ProcessingMode.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {*}
- */
-const $out = (collection, expr, options) => {
-    const outputColl = (0, util_1.isString)(expr)
-        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr)
-        : expr;
-    (0, util_1.assert)(outputColl instanceof Array, `expression must resolve to an array`);
-    return collection.map((o) => {
-        outputColl.push((0, util_1.cloneDeep)(o));
-        return o; // passthrough
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$out = $out;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var all_exports = {};
+__export(all_exports, {
+  $all: () => $all
+});
+module.exports = __toCommonJS(all_exports);
+var import_predicates = __webpack_require__(4330);
+const $all = (0, import_predicates.createQueryOperator)(import_predicates.$all);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7911:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2604:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$project = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Reshapes a document stream.
- * $project can rename, add, or remove fields as well as create computed values and sub-documents.
- *
- * @param collection
- * @param expr
- * @param opt
- * @returns {Array}
- */
-const $project = (collection, expr, options) => {
-    if ((0, util_1.isEmpty)(expr))
-        return collection;
-    // result collection
-    let expressionKeys = Object.keys(expr);
-    let idOnlyExcluded = false;
-    // validate inclusion and exclusion
-    validateExpression(expr, options);
-    const ID_KEY = options.idKey;
-    if ((0, util_1.inArray)(expressionKeys, ID_KEY)) {
-        const id = expr[ID_KEY];
-        if (id === 0 || id === false) {
-            expressionKeys = expressionKeys.filter(util_1.notInArray.bind(null, [ID_KEY]));
-            idOnlyExcluded = expressionKeys.length == 0;
-        }
-    }
-    else {
-        // if not specified the add the ID field
-        expressionKeys.push(ID_KEY);
-    }
-    const copts = core_1.ComputeOptions.init(options);
-    return collection.map(((obj) => processObject(obj, expr, copts.update(obj), expressionKeys, idOnlyExcluded)));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$project = $project;
-/**
- * Process the expression value for $project operators
- *
- * @param {Object} obj The object to use as options
- * @param {Object} expr The experssion object of $project operator
- * @param {Array} expressionKeys The key in the 'expr' object
- * @param {Boolean} idOnlyExcluded Boolean value indicating whether only the ID key is excluded
- */
-function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
-    let newObj = {};
-    let foundSlice = false;
-    let foundExclusion = false;
-    const dropKeys = [];
-    if (idOnlyExcluded) {
-        dropKeys.push(options.idKey);
-    }
-    for (const key of expressionKeys) {
-        // final computed value of the key
-        let value = undefined;
-        // expression to associate with key
-        const subExpr = expr[key];
-        if (key !== options.idKey && (0, util_1.inArray)([0, false], subExpr)) {
-            foundExclusion = true;
-        }
-        if (key === options.idKey && (0, util_1.isEmpty)(subExpr)) {
-            // tiny optimization here to skip over id
-            value = obj[key];
-        }
-        else if ((0, util_1.isString)(subExpr)) {
-            value = (0, core_1.computeValue)(obj, subExpr, key, options);
-        }
-        else if ((0, util_1.inArray)([1, true], subExpr)) {
-            // For direct projections, we use the resolved object value
-        }
-        else if (subExpr instanceof Array) {
-            value = subExpr.map(v => {
-                const r = (0, core_1.computeValue)(obj, v, null, options);
-                if ((0, util_1.isNil)(r))
-                    return null;
-                return r;
-            });
-        }
-        else if ((0, util_1.isObject)(subExpr)) {
-            const subExprObj = subExpr;
-            const subExprKeys = Object.keys(subExpr);
-            const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
-            // first try a projection operator
-            const call = (0, core_1.getOperator)(core_1.OperatorType.PROJECTION, operator, options);
-            if (call) {
-                // apply the projection operator on the operator expression for the key
-                if (operator === "$slice") {
-                    // $slice is handled differently for aggregation and projection operations
-                    if ((0, util_1.ensureArray)(subExprObj[operator]).every(util_1.isNumber)) {
-                        // $slice for projection operation
-                        value = call(obj, subExprObj[operator], key, options);
-                        foundSlice = true;
-                    }
-                    else {
-                        // $slice for aggregation operation
-                        value = (0, core_1.computeValue)(obj, subExprObj, key, options);
-                    }
-                }
-                else {
-                    value = call(obj, subExprObj[operator], key, options);
-                }
-            }
-            else if ((0, util_1.isOperator)(operator)) {
-                // compute if operator key
-                value = (0, core_1.computeValue)(obj, subExprObj[operator], operator, options);
-            }
-            else if ((0, util_1.has)(obj, key)) {
-                // compute the value for the sub expression for the key
-                validateExpression(subExprObj, options);
-                let target = obj[key];
-                if (target instanceof Array) {
-                    value = target.map((o) => processObject(o, subExprObj, options, subExprKeys, false));
-                }
-                else {
-                    target = (0, util_1.isObject)(target) ? target : obj;
-                    value = processObject(target, subExprObj, options, subExprKeys, false);
-                }
-            }
-            else {
-                // compute the value for the sub expression for the key
-                value = (0, core_1.computeValue)(obj, subExpr, null, options);
-            }
-        }
-        else {
-            dropKeys.push(key);
-            continue;
-        }
-        // get value with object graph
-        const objPathGraph = (0, util_1.resolveGraph)(obj, key, {
-            preserveMissing: true
-        });
-        // add the value at the path
-        if (objPathGraph !== undefined) {
-            (0, util_1.merge)(newObj, objPathGraph, {
-                flatten: true
-            });
-        }
-        // if computed add/or remove accordingly
-        if ((0, util_1.notInArray)([0, 1, false, true], subExpr)) {
-            if (value === undefined) {
-                (0, util_1.removeValue)(newObj, key, { descendArray: true });
-            }
-            else {
-                (0, util_1.setValue)(newObj, key, value);
-            }
-        }
-    }
-    // filter out all missing values preserved to support correct merging
-    (0, util_1.filterMissing)(newObj);
-    // For the following cases we include all keys on the object that were not explicitly excluded.
-    //
-    // 1. projection included $slice operator
-    // 2. some fields were explicitly excluded
-    // 3. only the id field was excluded
-    if (foundSlice || foundExclusion || idOnlyExcluded) {
-        newObj = (0, util_1.into)({}, obj, newObj);
-        if (dropKeys.length > 0) {
-            for (const k of dropKeys) {
-                (0, util_1.removeValue)(newObj, k, { descendArray: true });
-            }
-        }
-    }
-    return newObj;
-}
-/**
- * Validate inclusion and exclusion values in expression
- *
- * @param {Object} expr The expression given for the projection
- */
-function validateExpression(expr, options) {
-    const check = [false, false];
-    for (const [k, v] of Object.entries(expr)) {
-        if (k === (options === null || options === void 0 ? void 0 : options.idKey))
-            return;
-        if (v === 0 || v === false) {
-            check[0] = true;
-        }
-        else if (v === 1 || v === true) {
-            check[1] = true;
-        }
-        (0, util_1.assert)(!(check[0] && check[1]), "Projection cannot have a mix of inclusion and exclusion.");
-    }
-}
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elemMatch_exports = {};
+__export(elemMatch_exports, {
+  $elemMatch: () => $elemMatch
+});
+module.exports = __toCommonJS(elemMatch_exports);
+var import_predicates = __webpack_require__(4330);
+const $elemMatch = (0, import_predicates.createQueryOperator)(import_predicates.$elemMatch);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6402:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4748:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$redact = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Restricts the contents of the documents based on information stored in the documents themselves.
- *
- * https://docs.mongodb.com/manual/reference/operator/aggregation/redact/
- */
-const $redact = (collection, expr, options) => {
-    const copts = core_1.ComputeOptions.init(options);
-    return collection.map(((obj) => (0, core_1.redact)(obj, expr, copts.update(obj))));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$redact = $redact;
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var array_exports = {};
+module.exports = __toCommonJS(array_exports);
+__reExport(array_exports, __webpack_require__(6007), module.exports);
+__reExport(array_exports, __webpack_require__(2604), module.exports);
+__reExport(array_exports, __webpack_require__(6143), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6366:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6143:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$replaceRoot = void 0;
-const core_1 = __webpack_require__(9587);
-const util_1 = __webpack_require__(7216);
-/**
- * Replaces a document with the specified embedded document or new one.
- * The replacement document can be any valid expression that resolves to a document.
- *
- * https://docs.mongodb.com/manual/reference/operator/aggregation/replaceRoot/
- *
- * @param  {Iterator} collection
- * @param  {Object} expr
- * @param  {Object} options
- * @return {*}
- */
-const $replaceRoot = (collection, expr, options) => {
-    return collection.map(obj => {
-        obj = (0, core_1.computeValue)(obj, expr.newRoot, null, options);
-        (0, util_1.assert)((0, util_1.isObject)(obj), "$replaceRoot expression must return an object");
-        return obj;
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$replaceRoot = $replaceRoot;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var size_exports = {};
+__export(size_exports, {
+  $size: () => $size
+});
+module.exports = __toCommonJS(size_exports);
+var import_predicates = __webpack_require__(4330);
+const $size = (0, import_predicates.createQueryOperator)(import_predicates.$size);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8755:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5450:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$replaceWith = void 0;
-const replaceRoot_1 = __webpack_require__(6366);
-/**
- * Alias for $replaceRoot
- */
-exports.$replaceWith = replaceRoot_1.$replaceRoot;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  createBitwiseOperator: () => createBitwiseOperator
+});
+module.exports = __toCommonJS(internal_exports);
+var import_util = __webpack_require__(7839);
+var import_predicates = __webpack_require__(4330);
+const createBitwiseOperator = (predicate) => {
+  return (0, import_predicates.createQueryOperator)(
+    (value, mask, _options) => {
+      let b = 0;
+      if ((0, import_util.isArray)(mask)) {
+        for (const n of mask) b = b | 1 << n;
+      } else {
+        b = mask;
+      }
+      return predicate(value & b, b);
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8027:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 1996:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// $sample operator -  https://docs.mongodb.com/manual/reference/operator/aggregation/sample/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sample = void 0;
-/**
- * Randomly selects the specified number of documents from its input. The given iterator must have finite values
- *
- * @param  {Iterator} collection
- * @param  {Object} expr
- * @param  {Options} _options
- * @return {*}
- */
-const $sample = (collection, expr, _options) => {
-    return collection.transform(((xs) => {
-        const len = xs.length;
-        let i = -1;
-        return () => {
-            if (++i === expr.size)
-                return { done: true };
-            const n = Math.floor(Math.random() * len);
-            return { value: xs[n], done: false };
-        };
-    }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$sample = $sample;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitsAllClear_exports = {};
+__export(bitsAllClear_exports, {
+  $bitsAllClear: () => $bitsAllClear
+});
+module.exports = __toCommonJS(bitsAllClear_exports);
+var import_internal = __webpack_require__(5450);
+const $bitsAllClear = (0, import_internal.createBitwiseOperator)((result, _) => result == 0);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4707:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7537:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$set = void 0;
-const addFields_1 = __webpack_require__(1692);
-/**
- * Alias for $addFields.
- */
-exports.$set = addFields_1.$addFields;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitsAllSet_exports = {};
+__export(bitsAllSet_exports, {
+  $bitsAllSet: () => $bitsAllSet
+});
+module.exports = __toCommonJS(bitsAllSet_exports);
+var import_internal = __webpack_require__(5450);
+const $bitsAllSet = (0, import_internal.createBitwiseOperator)(
+  (result, mask) => result == mask
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8515:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6864:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// $setWindowFields -  https://docs.mongodb.com/manual/reference/operator/aggregation/setWindowFields/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$setWindowFields = void 0;
-const core_1 = __webpack_require__(9587);
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-const expression_1 = __webpack_require__(8985);
-const dateAdd_1 = __webpack_require__(9784);
-const _internal_1 = __webpack_require__(2899);
-const addFields_1 = __webpack_require__(1692);
-const group_1 = __webpack_require__(2683);
-const sort_1 = __webpack_require__(5396);
-// Operators that require 'sortBy' option.
-const SORT_REQUIRED_OPS = new Set([
-    "$denseRank",
-    "$documentNumber",
-    "$first",
-    "$last",
-    "$linearFill",
-    "$rank",
-    "$shift"
-]);
-// Operators that require unbounded 'window' option.
-const WINDOW_UNBOUNDED_OPS = new Set([
-    "$denseRank",
-    "$expMovingAvg",
-    "$linearFill",
-    "$locf",
-    "$rank",
-    "$shift"
-]);
-/**
- * Randomly selects the specified number of documents from its input. The given iterator must have finite values
- *
- * @param  {Iterator} collection
- * @param  {Object} expr
- * @param  {Options} options
- * @return {*}
- */
-const $setWindowFields = (collection, expr, options) => {
-    options = (0, core_1.initOptions)(options);
-    options.context.addExpressionOps({ $function: expression_1.$function });
-    // validate inputs early since this can be an expensive operation.
-    for (const outputExpr of Object.values(expr.output)) {
-        const keys = Object.keys(outputExpr);
-        const op = keys.find(util_1.isOperator);
-        (0, util_1.assert)(!!(0, core_1.getOperator)(core_1.OperatorType.WINDOW, op, options) ||
-            !!(0, core_1.getOperator)(core_1.OperatorType.ACCUMULATOR, op, options), `'${op}' is not a valid window operator`);
-        (0, util_1.assert)(keys.length > 0 &&
-            keys.length <= 2 &&
-            (keys.length == 1 || keys.includes("window")), "'output' option should have a single window operator.");
-        if (outputExpr === null || outputExpr === void 0 ? void 0 : outputExpr.window) {
-            const { documents, range } = outputExpr.window;
-            (0, util_1.assert)((!!documents && !range) ||
-                (!documents && !!range) ||
-                (!documents && !range), "'window' option supports only one of 'documents' or 'range'.");
-        }
-    }
-    // we sort first if required
-    if (expr.sortBy) {
-        collection = (0, sort_1.$sort)(collection, expr.sortBy, options);
-    }
-    // then partition collection
-    collection = (0, group_1.$group)(collection, {
-        _id: expr.partitionBy,
-        items: { $push: "$$CURRENT" }
-    }, options);
-    // transform values
-    return collection.transform(((partitions) => {
-        // let iteratorIndex = 0;
-        const iterators = [];
-        const outputConfig = [];
-        for (const [field, outputExpr] of Object.entries(expr.output)) {
-            const op = Object.keys(outputExpr).find(util_1.isOperator);
-            const config = {
-                operatorName: op,
-                func: {
-                    left: (0, core_1.getOperator)(core_1.OperatorType.ACCUMULATOR, op, options),
-                    right: (0, core_1.getOperator)(core_1.OperatorType.WINDOW, op, options)
-                },
-                args: outputExpr[op],
-                field: field,
-                window: outputExpr.window
-            };
-            // sortBy option required for specific operators or bounded window.
-            (0, util_1.assert)(!!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window), `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : "bounded window operation"} requires a sortBy.`);
-            // window must be unbounded for specific operators.
-            (0, util_1.assert)(!config.window || !WINDOW_UNBOUNDED_OPS.has(op), `${op} does not accept a 'window' field.`);
-            outputConfig.push(config);
-        }
-        // each parition maintains its own closure to process the documents in the window.
-        partitions.forEach(((group) => {
-            // get the items to process
-            const items = group.items;
-            // create an iterator per group.
-            // we need the index of each document so we track it using a special field.
-            let iterator = (0, lazy_1.Lazy)(items);
-            // results map
-            const windowResultMap = {};
-            for (const config of outputConfig) {
-                const { func, args, field, window } = config;
-                const makeResultFunc = (getItemsFn) => {
-                    // closure for object index within the partition
-                    let index = -1;
-                    return (obj) => {
-                        ++index;
-                        // process accumulator function
-                        if (func.left) {
-                            return func.left(getItemsFn(obj, index), args, options);
-                        }
-                        else if (func.right) {
-                            // OR process 'window' function
-                            return func.right(obj, getItemsFn(obj, index), {
-                                parentExpr: expr,
-                                inputExpr: args,
-                                documentNumber: index + 1,
-                                field
-                            }, 
-                            // must use raw options only since it operates over a collection.
-                            options);
-                        }
-                    };
-                };
-                if (window) {
-                    const { documents, range, unit } = window;
-                    // TODO: fix the meaning of numeric values in range.
-                    //  See definition: https://www.mongodb.com/docs/manual/reference/operator/aggregation/setWindowFields/#std-label-setWindowFields-range
-                    //  - A number to add to the value of the sortBy field for the current document.
-                    //  - A document is in the window if the sortBy field value is inclusively within the lower and upper boundaries.
-                    // TODO: Need to reconcile the two above statments from the doc to implement 'range' option correctly.
-                    const boundary = documents || range;
-                    if (!(0, _internal_1.isUnbounded)(window)) {
-                        const [begin, end] = boundary;
-                        const toBeginIndex = (currentIndex) => {
-                            if (begin == "current")
-                                return currentIndex;
-                            if (begin == "unbounded")
-                                return 0;
-                            return Math.max(begin + currentIndex, 0);
-                        };
-                        const toEndIndex = (currentIndex) => {
-                            if (end == "current")
-                                return currentIndex + 1;
-                            if (end == "unbounded")
-                                return items.length;
-                            return end + currentIndex + 1;
-                        };
-                        const getItems = (current, index) => {
-                            // handle string boundaries or documents
-                            if (!!documents || boundary.every(util_1.isString)) {
-                                return items.slice(toBeginIndex(index), toEndIndex(index));
-                            }
-                            // handle range with numeric boundary values
-                            const sortKey = Object.keys(expr.sortBy)[0];
-                            let lower;
-                            let upper;
-                            if (unit) {
-                                // we are dealing with datetimes
-                                const getTime = (amount) => {
-                                    return (0, dateAdd_1.$dateAdd)(current, {
-                                        startDate: new Date(current[sortKey]),
-                                        unit,
-                                        amount
-                                    }, options).getTime();
-                                };
-                                lower = (0, util_1.isNumber)(begin) ? getTime(begin) : -Infinity;
-                                upper = (0, util_1.isNumber)(end) ? getTime(end) : Infinity;
-                            }
-                            else {
-                                const currentValue = current[sortKey];
-                                lower = (0, util_1.isNumber)(begin) ? currentValue + begin : -Infinity;
-                                upper = (0, util_1.isNumber)(end) ? currentValue + end : Infinity;
-                            }
-                            let array = items;
-                            if (begin == "current")
-                                array = items.slice(index);
-                            if (end == "current")
-                                array = items.slice(0, index + 1);
-                            // look within the boundary and filter down
-                            return array.filter((o) => {
-                                const value = o[sortKey];
-                                const n = +value;
-                                return n >= lower && n <= upper;
-                            });
-                        };
-                        windowResultMap[field] = makeResultFunc(getItems);
-                    }
-                }
-                // default action is to utilize the entire set of items
-                if (!windowResultMap[field]) {
-                    windowResultMap[field] = makeResultFunc(_ => items);
-                }
-                // invoke add fields to get the desired behaviour using a custom function.
-                iterator = (0, addFields_1.$addFields)(iterator, {
-                    [field]: {
-                        $function: {
-                            body: (obj) => windowResultMap[field](obj),
-                            args: ["$$CURRENT"]
-                        }
-                    }
-                }, options);
-            }
-            // add to iterator list
-            iterators.push(iterator);
-        }));
-        return (0, lazy_1.compose)(...iterators);
-    }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$setWindowFields = $setWindowFields;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitsAnyClear_exports = {};
+__export(bitsAnyClear_exports, {
+  $bitsAnyClear: () => $bitsAnyClear
+});
+module.exports = __toCommonJS(bitsAnyClear_exports);
+var import_internal = __webpack_require__(5450);
+const $bitsAnyClear = (0, import_internal.createBitwiseOperator)(
+  (result, mask) => result < mask
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8377:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 4010:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$skip = void 0;
-/**
- * Skips over a specified number of documents from the pipeline and returns the rest.
- *
- * @param collection An iterator
- * @param expr
- * @param  {Options} options
- * @returns {*}
- */
-const $skip = (collection, expr, options) => {
-    return collection.drop(expr);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$skip = $skip;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitsAnySet_exports = {};
+__export(bitsAnySet_exports, {
+  $bitsAnySet: () => $bitsAnySet
+});
+module.exports = __toCommonJS(bitsAnySet_exports);
+var import_internal = __webpack_require__(5450);
+const $bitsAnySet = (0, import_internal.createBitwiseOperator)((result, _) => result > 0);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5396:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8286:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sort = void 0;
-const util_1 = __webpack_require__(7216);
-/**
- * Takes all input documents and returns them in a stream of sorted documents.
- *
- * @param collection
- * @param sortKeys
- * @param  {Object} options
- * @returns {*}
- */
-const $sort = (collection, sortKeys, options) => {
-    if ((0, util_1.isEmpty)(sortKeys) || !(0, util_1.isObject)(sortKeys))
-        return collection;
-    let cmp = util_1.compare;
-    // check for collation spec on the options
-    const collationSpec = options.collation;
-    // use collation comparator if provided
-    if ((0, util_1.isObject)(collationSpec) && (0, util_1.isString)(collationSpec.locale)) {
-        cmp = collationComparator(collationSpec);
-    }
-    return collection.transform((coll) => {
-        const modifiers = Object.keys(sortKeys);
-        for (const key of modifiers.reverse()) {
-            const groups = (0, util_1.groupBy)(coll, (obj) => (0, util_1.resolve)(obj, key), options.hashFunction);
-            const sortedKeys = Array.from(groups.keys()).sort(cmp);
-            if (sortKeys[key] === -1)
-                sortedKeys.reverse();
-            // reuse collection so the data is available for the next iteration of the sort modifiers.
-            coll = [];
-            sortedKeys.reduce((acc, key) => (0, util_1.into)(acc, groups.get(key)), coll);
-        }
-        return coll;
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$sort = $sort;
-// MongoDB collation strength to JS localeCompare sensitivity mapping.
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare
-const COLLATION_STRENGTH = {
-    // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.
-    1: "base",
-    //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.
-    // Examples: a ≠ b, a ≠ á, a = A.
-    2: "accent",
-    // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.
-    // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A
-    3: "variant"
-    // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-/**
- * Creates a comparator function for the given collation spec. See https://docs.mongodb.com/manual/reference/collation/
- *
- * @param spec {Object} The MongoDB collation spec.
- * {
- *   locale: string,
- *   caseLevel: boolean,
- *   caseFirst: string,
- *   strength: int,
- *   numericOrdering: boolean,
- *   alternate: string,
- *   maxVariable: string, // unsupported
- *   backwards: boolean // unsupported
- * }
- */
-function collationComparator(spec) {
-    const localeOpt = {
-        sensitivity: COLLATION_STRENGTH[spec.strength || 3],
-        caseFirst: spec.caseFirst === "off" ? "false" : spec.caseFirst || "false",
-        numeric: spec.numericOrdering || false,
-        ignorePunctuation: spec.alternate === "shifted"
-    };
-    // when caseLevel is true for strength  1:base and 2:accent, bump sensitivity to the nearest that supports case comparison
-    if ((spec.caseLevel || false) === true) {
-        if (localeOpt.sensitivity === "base")
-            localeOpt.sensitivity = "case";
-        if (localeOpt.sensitivity === "accent")
-            localeOpt.sensitivity = "variant";
-    }
-    const collator = new Intl.Collator(spec.locale, localeOpt);
-    return (a, b) => {
-        // non strings
-        if (!(0, util_1.isString)(a) || !(0, util_1.isString)(b))
-            return (0, util_1.compare)(a, b);
-        // only for strings
-        const i = collator.compare(a, b);
-        if (i < 0)
-            return -1;
-        if (i > 0)
-            return 1;
-        return 0;
-    };
-}
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bitwise_exports = {};
+__export(bitwise_exports, {
+  $bitsAllClear: () => import_bitsAllClear.$bitsAllClear,
+  $bitsAllSet: () => import_bitsAllSet.$bitsAllSet,
+  $bitsAnyClear: () => import_bitsAnyClear.$bitsAnyClear,
+  $bitsAnySet: () => import_bitsAnySet.$bitsAnySet
+});
+module.exports = __toCommonJS(bitwise_exports);
+var import_bitsAllClear = __webpack_require__(1996);
+var import_bitsAllSet = __webpack_require__(7537);
+var import_bitsAnyClear = __webpack_require__(6864);
+var import_bitsAnySet = __webpack_require__(4010);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2311:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7586:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$sortByCount = void 0;
-const group_1 = __webpack_require__(2683);
-const sort_1 = __webpack_require__(5396);
-/**
- * Groups incoming documents based on the value of a specified expression,
- * then computes the count of documents in each distinct group.
- *
- * https://docs.mongodb.com/manual/reference/operator/aggregation/sortByCount/
- *
- * @param  {Array} collection
- * @param  {Object} expr
- * @param  {Object} options
- * @return {*}
- */
-const $sortByCount = (collection, expr, options) => {
-    const newExpr = { count: { $sum: 1 } };
-    newExpr["_id"] = expr;
-    return (0, sort_1.$sort)((0, group_1.$group)(collection, newExpr, options), { count: -1 }, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$sortByCount = $sortByCount;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eq_exports = {};
+__export(eq_exports, {
+  $eq: () => $eq
+});
+module.exports = __toCommonJS(eq_exports);
+var import_predicates = __webpack_require__(4330);
+const $eq = (0, import_predicates.createQueryOperator)(import_predicates.$eq);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1655:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1855:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$unionWith = void 0;
-const aggregator_1 = __webpack_require__(7268);
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Performs a union of two collections.
- *
- * @param collection
- * @param expr
- * @param opt
- */
-const $unionWith = (collection, expr, options) => {
-    const array = (0, util_1.isString)(expr.coll)
-        ? options.collectionResolver(expr.coll)
-        : expr.coll;
-    const iterators = [collection];
-    iterators.push(expr.pipeline
-        ? new aggregator_1.Aggregator(expr.pipeline, options).stream(array)
-        : (0, lazy_1.Lazy)(array));
-    return (0, lazy_1.compose)(...iterators);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$unionWith = $unionWith;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gt_exports = {};
+__export(gt_exports, {
+  $gt: () => $gt
+});
+module.exports = __toCommonJS(gt_exports);
+var import_predicates = __webpack_require__(4330);
+const $gt = (0, import_predicates.createQueryOperator)(import_predicates.$gt);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3871:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4268:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$unset = void 0;
-const util_1 = __webpack_require__(7216);
-const project_1 = __webpack_require__(7911);
-/**
- * Removes/excludes fields from documents.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {Iterator}
- */
-const $unset = (collection, expr, options) => {
-    expr = (0, util_1.ensureArray)(expr);
-    const doc = {};
-    for (const k of expr)
-        doc[k] = 0;
-    return (0, project_1.$project)(collection, doc, options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$unset = $unset;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gte_exports = {};
+__export(gte_exports, {
+  $gte: () => $gte
+});
+module.exports = __toCommonJS(gte_exports);
+var import_predicates = __webpack_require__(4330);
+const $gte = (0, import_predicates.createQueryOperator)(import_predicates.$gte);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 9789:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4399:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$unwind = void 0;
-const lazy_1 = __webpack_require__(9176);
-const util_1 = __webpack_require__(7216);
-/**
- * Takes an array of documents and returns them as a stream of documents.
- *
- * @param collection
- * @param expr
- * @param options
- * @returns {Array}
- */
-const $unwind = (collection, expr, _options) => {
-    if ((0, util_1.isString)(expr))
-        expr = { path: expr };
-    const path = expr.path;
-    const field = path.substring(1);
-    const includeArrayIndex = (expr === null || expr === void 0 ? void 0 : expr.includeArrayIndex) || false;
-    const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;
-    const format = (o, i) => {
-        if (includeArrayIndex !== false)
-            o[includeArrayIndex] = i;
-        return o;
-    };
-    let value;
-    return (0, lazy_1.Lazy)(() => {
-        for (;;) {
-            // take from lazy sequence if available
-            if (value instanceof lazy_1.Iterator) {
-                const tmp = value.next();
-                if (!tmp.done)
-                    return tmp;
-            }
-            // fetch next object
-            const wrapper = collection.next();
-            if (wrapper.done)
-                return wrapper;
-            // unwrap value
-            const obj = wrapper.value;
-            // get the value of the field to unwind
-            value = (0, util_1.resolve)(obj, field);
-            // throw error if value is not an array???
-            if (value instanceof Array) {
-                if (value.length === 0 && preserveNullAndEmptyArrays === true) {
-                    value = null; // reset unwind value
-                    (0, util_1.removeValue)(obj, field);
-                    return { value: format(obj, null), done: false };
-                }
-                else {
-                    // construct a lazy sequence for elements per value
-                    value = (0, lazy_1.Lazy)(value).map(((item, i) => {
-                        const newObj = (0, util_1.resolveGraph)(obj, field, {
-                            preserveKeys: true
-                        });
-                        (0, util_1.setValue)(newObj, field, item);
-                        return format(newObj, i);
-                    }));
-                }
-            }
-            else if (!(0, util_1.isEmpty)(value) || preserveNullAndEmptyArrays === true) {
-                return { value: format(obj, null), done: false };
-            }
-        }
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$unwind = $unwind;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var in_exports = {};
+__export(in_exports, {
+  $in: () => $in
+});
+module.exports = __toCommonJS(in_exports);
+var import_predicates = __webpack_require__(4330);
+const $in = (0, import_predicates.createQueryOperator)(import_predicates.$in);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2781:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3338:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// $elemMatch operator. https://docs.mongodb.com/manual/reference/operator/projection/elemMatch/#proj._S_elemMatch
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$elemMatch = void 0;
-const query_1 = __webpack_require__(809);
-const util_1 = __webpack_require__(7216);
-/**
- * Projects only the first element from an array that matches the specified $elemMatch condition.
- *
- * @param obj
- * @param field
- * @param expr
- * @returns {*}
- */
-const $elemMatch = (obj, expr, field, options) => {
-    const arr = (0, util_1.resolve)(obj, field);
-    const query = new query_1.Query(expr, options);
-    (0, util_1.assert)(arr instanceof Array, "$elemMatch: argument must resolve to array");
-    const result = [];
-    for (let i = 0; i < arr.length; i++) {
-        if (query.test(arr[i])) {
-            // MongoDB projects only the first nested document when using this operator.
-            // For some use cases this can lead to complicated queries to selectively project nested documents.
-            // When strict mode is disabled, we return all matching nested documents.
-            if (options.useStrictMode)
-                return [arr[i]];
-            result.push(arr[i]);
-        }
-    }
-    return result.length > 0 ? result : undefined;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$elemMatch = $elemMatch;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var comparison_exports = {};
+__export(comparison_exports, {
+  $eq: () => import_eq.$eq,
+  $gt: () => import_gt.$gt,
+  $gte: () => import_gte.$gte,
+  $in: () => import_in.$in,
+  $lt: () => import_lt.$lt,
+  $lte: () => import_lte.$lte,
+  $ne: () => import_ne.$ne,
+  $nin: () => import_nin.$nin
+});
+module.exports = __toCommonJS(comparison_exports);
+var import_eq = __webpack_require__(7586);
+var import_gt = __webpack_require__(1855);
+var import_gte = __webpack_require__(4268);
+var import_in = __webpack_require__(4399);
+var import_lt = __webpack_require__(7768);
+var import_lte = __webpack_require__(3525);
+var import_ne = __webpack_require__(4793);
+var import_nin = __webpack_require__(819);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3791:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 7768:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Projection Operators. https://docs.mongodb.com/manual/reference/operator/projection/
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(2781), exports);
-__exportStar(__webpack_require__(8083), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lt_exports = {};
+__export(lt_exports, {
+  $lt: () => $lt
+});
+module.exports = __toCommonJS(lt_exports);
+var import_predicates = __webpack_require__(4330);
+const $lt = (0, import_predicates.createQueryOperator)(import_predicates.$lt);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8083:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3525:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// $slice operator. https://docs.mongodb.com/manual/reference/operator/projection/slice/#proj._S_slice
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$slice = void 0;
-const util_1 = __webpack_require__(7216);
-const slice_1 = __webpack_require__(5000);
-/**
- * Limits the number of elements projected from an array. Supports skip and limit slices.
- *
- * @param obj
- * @param field
- * @param expr
- */
-const $slice = (obj, expr, field, options) => {
-    const xs = (0, util_1.resolve)(obj, field);
-    const exprAsArray = expr;
-    if (!(0, util_1.isArray)(xs))
-        return xs;
-    return (0, slice_1.$slice)(obj, expr instanceof Array ? [xs, ...exprAsArray] : [xs, expr], options);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$slice = $slice;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lte_exports = {};
+__export(lte_exports, {
+  $lte: () => $lte
+});
+module.exports = __toCommonJS(lte_exports);
+var import_predicates = __webpack_require__(4330);
+const $lte = (0, import_predicates.createQueryOperator)(import_predicates.$lte);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1274:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4793:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$all = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches arrays that contain all elements specified in the query.
- */
-exports.$all = (0, _predicates_1.createQueryOperator)(_predicates_1.$all);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ne_exports = {};
+__export(ne_exports, {
+  $ne: () => $ne
+});
+module.exports = __toCommonJS(ne_exports);
+var import_predicates = __webpack_require__(4330);
+const $ne = (0, import_predicates.createQueryOperator)(import_predicates.$ne);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6242:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 819:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$elemMatch = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Selects documents if element in the array field matches all the specified $elemMatch conditions.
- */
-exports.$elemMatch = (0, _predicates_1.createQueryOperator)(_predicates_1.$elemMatch);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nin_exports = {};
+__export(nin_exports, {
+  $nin: () => $nin
+});
+module.exports = __toCommonJS(nin_exports);
+var import_predicates = __webpack_require__(4330);
+const $nin = (0, import_predicates.createQueryOperator)(import_predicates.$nin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7562:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 1917:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(1274), exports);
-__exportStar(__webpack_require__(6242), exports);
-__exportStar(__webpack_require__(6534), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exists_exports = {};
+__export(exists_exports, {
+  $exists: () => $exists
+});
+module.exports = __toCommonJS(exists_exports);
+var import_predicates = __webpack_require__(4330);
+const $exists = (0, import_predicates.createQueryOperator)(import_predicates.$exists);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6534:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2206:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$size = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Selects documents if the array field is a specified size.
- */
-exports.$size = (0, _predicates_1.createQueryOperator)(_predicates_1.$size);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var element_exports = {};
+module.exports = __toCommonJS(element_exports);
+__reExport(element_exports, __webpack_require__(1917), module.exports);
+__reExport(element_exports, __webpack_require__(3989), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2579:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3989:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createBitwiseOperator = void 0;
-const _predicates_1 = __webpack_require__(4414);
-const createBitwiseOperator = (predicate) => {
-    return (0, _predicates_1.createQueryOperator)((value, mask, options) => {
-        let b = 0;
-        if (mask instanceof Array) {
-            for (const n of mask)
-                b = b | (1 << n);
-        }
-        else {
-            b = mask;
-        }
-        return predicate(value & b, b);
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.createBitwiseOperator = createBitwiseOperator;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+__export(type_exports, {
+  $type: () => $type
+});
+module.exports = __toCommonJS(type_exports);
+var import_predicates = __webpack_require__(4330);
+const $type = (0, import_predicates.createQueryOperator)(import_predicates.$type);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8706:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9170:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bitsAllClear = void 0;
-const _internal_1 = __webpack_require__(2579);
-/**
- * Matches numeric or binary values in which a set of bit positions all have a value of 0.
- */
-exports.$bitsAllClear = (0, _internal_1.createBitwiseOperator)((result, _) => result == 0);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expr_exports = {};
+__export(expr_exports, {
+  $expr: () => $expr
+});
+module.exports = __toCommonJS(expr_exports);
+var import_core = __webpack_require__(2760);
+function $expr(_, rhs, options) {
+  return (obj) => (0, import_core.computeValue)(obj, rhs, null, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7089:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5437:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bitsAllSet = void 0;
-const _internal_1 = __webpack_require__(2579);
-/**
- * Matches numeric or binary values in which a set of bit positions all have a value of 1.
- */
-exports.$bitsAllSet = (0, _internal_1.createBitwiseOperator)((result, mask) => result == mask);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var evaluation_exports = {};
+module.exports = __toCommonJS(evaluation_exports);
+__reExport(evaluation_exports, __webpack_require__(9170), module.exports);
+__reExport(evaluation_exports, __webpack_require__(3008), module.exports);
+__reExport(evaluation_exports, __webpack_require__(1661), module.exports);
+__reExport(evaluation_exports, __webpack_require__(3130), module.exports);
+__reExport(evaluation_exports, __webpack_require__(3617), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8390:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3008:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bitsAnyClear = void 0;
-const _internal_1 = __webpack_require__(2579);
-/**
- * Matches numeric or binary values in which any bit from a set of bit positions has a value of 0.
- */
-exports.$bitsAnyClear = (0, _internal_1.createBitwiseOperator)((result, mask) => result < mask);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonSchema_exports = {};
+__export(jsonSchema_exports, {
+  $jsonSchema: () => $jsonSchema
+});
+module.exports = __toCommonJS(jsonSchema_exports);
+var import_util = __webpack_require__(7839);
+function $jsonSchema(_, schema, options) {
+  if (!options?.jsonSchemaValidator) {
+    throw new import_util.MingoError(
+      "Missing option 'jsonSchemaValidator'. Configure to use '$jsonSchema' operator."
+    );
+  }
+  const validate = options?.jsonSchemaValidator(schema);
+  return (obj) => validate(obj);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6308:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1661:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bitsAnySet = void 0;
-const _internal_1 = __webpack_require__(2579);
-/**
- * Matches numeric or binary values in which any bit from a set of bit positions has a value of 1.
- */
-exports.$bitsAnySet = (0, _internal_1.createBitwiseOperator)((result, _) => result > 0);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mod_exports = {};
+__export(mod_exports, {
+  $mod: () => $mod
+});
+module.exports = __toCommonJS(mod_exports);
+var import_predicates = __webpack_require__(4330);
+const $mod = (0, import_predicates.createQueryOperator)(import_predicates.$mod);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4167:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3130:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$bitsAnySet = exports.$bitsAnyClear = exports.$bitsAllSet = exports.$bitsAllClear = void 0;
-var bitsAllClear_1 = __webpack_require__(8706);
-Object.defineProperty(exports, "$bitsAllClear", ({ enumerable: true, get: function () { return bitsAllClear_1.$bitsAllClear; } }));
-var bitsAllSet_1 = __webpack_require__(7089);
-Object.defineProperty(exports, "$bitsAllSet", ({ enumerable: true, get: function () { return bitsAllSet_1.$bitsAllSet; } }));
-var bitsAnyClear_1 = __webpack_require__(8390);
-Object.defineProperty(exports, "$bitsAnyClear", ({ enumerable: true, get: function () { return bitsAnyClear_1.$bitsAnyClear; } }));
-var bitsAnySet_1 = __webpack_require__(6308);
-Object.defineProperty(exports, "$bitsAnySet", ({ enumerable: true, get: function () { return bitsAnySet_1.$bitsAnySet; } }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var regex_exports = {};
+__export(regex_exports, {
+  $regex: () => $regex
+});
+module.exports = __toCommonJS(regex_exports);
+var import_predicates = __webpack_require__(4330);
+const $regex = (0, import_predicates.createQueryOperator)(import_predicates.$regex);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 102:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3617:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$eq = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are equal to a specified value.
- */
-exports.$eq = (0, _predicates_1.createQueryOperator)(_predicates_1.$eq);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var where_exports = {};
+__export(where_exports, {
+  $where: () => $where
+});
+module.exports = __toCommonJS(where_exports);
+var import_util = __webpack_require__(7839);
+function $where(_, rhs, options) {
+  (0, import_util.assert)(
+    options.scriptEnabled,
+    "$where operator requires 'scriptEnabled' option to be true"
+  );
+  const f = rhs;
+  (0, import_util.assert)((0, import_util.isFunction)(f), "$where only accepts a Function object");
+  return (obj) => (0, import_util.truthy)(f.call(obj), options?.useStrictMode);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3916:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8510:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$gt = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are greater than a specified value.
- */
-exports.$gt = (0, _predicates_1.createQueryOperator)(_predicates_1.$gt);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_exports = {};
+module.exports = __toCommonJS(query_exports);
+__reExport(query_exports, __webpack_require__(4748), module.exports);
+__reExport(query_exports, __webpack_require__(8286), module.exports);
+__reExport(query_exports, __webpack_require__(3338), module.exports);
+__reExport(query_exports, __webpack_require__(2206), module.exports);
+__reExport(query_exports, __webpack_require__(5437), module.exports);
+__reExport(query_exports, __webpack_require__(7218), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 4017:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 2096:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$gte = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * 	Matches values that are greater than or equal to a specified value.
- */
-exports.$gte = (0, _predicates_1.createQueryOperator)(_predicates_1.$gte);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var and_exports = {};
+__export(and_exports, {
+  $and: () => $and
+});
+module.exports = __toCommonJS(and_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+const $and = (_, rhs, options) => {
+  (0, import_util.assert)(
+    (0, import_util.isArray)(rhs),
+    "Invalid expression: $and expects value to be an Array."
+  );
+  const queries = rhs.map((expr) => new import_query.Query(expr, options));
+  return (obj) => queries.every((q) => q.test(obj));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 220:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7218:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$in = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches any of the values that exist in an array specified in the query.
- */
-exports.$in = (0, _predicates_1.createQueryOperator)(_predicates_1.$in);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logical_exports = {};
+module.exports = __toCommonJS(logical_exports);
+__reExport(logical_exports, __webpack_require__(2096), module.exports);
+__reExport(logical_exports, __webpack_require__(737), module.exports);
+__reExport(logical_exports, __webpack_require__(1083), module.exports);
+__reExport(logical_exports, __webpack_require__(7805), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5630:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$nin = exports.$ne = exports.$lte = exports.$lt = exports.$in = exports.$gte = exports.$gt = exports.$eq = void 0;
-var eq_1 = __webpack_require__(102);
-Object.defineProperty(exports, "$eq", ({ enumerable: true, get: function () { return eq_1.$eq; } }));
-var gt_1 = __webpack_require__(3916);
-Object.defineProperty(exports, "$gt", ({ enumerable: true, get: function () { return gt_1.$gt; } }));
-var gte_1 = __webpack_require__(4017);
-Object.defineProperty(exports, "$gte", ({ enumerable: true, get: function () { return gte_1.$gte; } }));
-var in_1 = __webpack_require__(220);
-Object.defineProperty(exports, "$in", ({ enumerable: true, get: function () { return in_1.$in; } }));
-var lt_1 = __webpack_require__(6391);
-Object.defineProperty(exports, "$lt", ({ enumerable: true, get: function () { return lt_1.$lt; } }));
-var lte_1 = __webpack_require__(2126);
-Object.defineProperty(exports, "$lte", ({ enumerable: true, get: function () { return lte_1.$lte; } }));
-var ne_1 = __webpack_require__(8481);
-Object.defineProperty(exports, "$ne", ({ enumerable: true, get: function () { return ne_1.$ne; } }));
-var nin_1 = __webpack_require__(8336);
-Object.defineProperty(exports, "$nin", ({ enumerable: true, get: function () { return nin_1.$nin; } }));
-
-
-/***/ }),
-
-/***/ 6391:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 737:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lt = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are less than the value specified in the query.
- */
-exports.$lt = (0, _predicates_1.createQueryOperator)(_predicates_1.$lt);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nor_exports = {};
+__export(nor_exports, {
+  $nor: () => $nor
+});
+module.exports = __toCommonJS(nor_exports);
+var import_util = __webpack_require__(7839);
+var import_or = __webpack_require__(7805);
+const $nor = (_, rhs, options) => {
+  (0, import_util.assert)(
+    (0, import_util.isArray)(rhs),
+    "Invalid expression. $nor expects value to be an array."
+  );
+  const f = (0, import_or.$or)("$or", rhs, options);
+  return (obj) => !f(obj);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2126:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 1083:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$lte = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that are less than or equal to the value specified in the query.
- */
-exports.$lte = (0, _predicates_1.createQueryOperator)(_predicates_1.$lte);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var not_exports = {};
+__export(not_exports, {
+  $not: () => $not
+});
+module.exports = __toCommonJS(not_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+const $not = (selector, rhs, options) => {
+  const criteria = {};
+  criteria[selector] = (0, import_util.normalize)(rhs);
+  const query = new import_query.Query(criteria, options);
+  return (obj) => !query.test(obj);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8481:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7805:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$ne = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches all values that are not equal to the value specified in the query.
- */
-exports.$ne = (0, _predicates_1.createQueryOperator)(_predicates_1.$ne);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var or_exports = {};
+__export(or_exports, {
+  $or: () => $or
+});
+module.exports = __toCommonJS(or_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+const $or = (_, rhs, options) => {
+  (0, import_util.assert)((0, import_util.isArray)(rhs), "Invalid expression. $or expects value to be an Array");
+  const queries = rhs.map((expr) => new import_query.Query(expr, options));
+  return (obj) => queries.some((q) => q.test(obj));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8336:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 3695:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$nin = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches values that do not exist in an array specified to the query.
- */
-exports.$nin = (0, _predicates_1.createQueryOperator)(_predicates_1.$nin);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  applyUpdate: () => applyUpdate,
+  clone: () => clone,
+  tokenizePath: () => tokenizePath,
+  walkExpression: () => walkExpression
+});
+module.exports = __toCommonJS(internal_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+const clone = (mode, val) => {
+  switch (mode) {
+    case "deep":
+      return (0, import_util.cloneDeep)(val);
+    case "copy": {
+      if ((0, import_util.isDate)(val)) return new Date(val);
+      if ((0, import_util.isArray)(val)) return [...val];
+      if ((0, import_util.isObject)(val)) return { ...val };
+      if ((0, import_util.isRegExp)(val)) return new RegExp(val);
+      return val;
+    }
+    default:
+      return val;
+  }
+};
+const FILTER_IDENT_RE = /^[a-z]+[a-zA-Z0-9]*$/;
+function tokenizePath(selector) {
+  if (!selector.includes(".$")) {
+    return [{ parent: selector, selector }, []];
+  }
+  const begin = selector.indexOf(".$");
+  const end = selector.indexOf("]");
+  const parent = selector.substring(0, begin);
+  const child = selector.substring(begin + 3, end);
+  (0, import_util.assert)(
+    child === "" || FILTER_IDENT_RE.test(child),
+    "The filter <identifier> must begin with a lowercase letter and contain only alphanumeric characters."
+  );
+  const rest = selector.substring(end + 2);
+  const [next, elems] = rest ? tokenizePath(rest) : [];
+  return [
+    { selector, parent, child: child || "$", next },
+    [child, ...elems || []].filter(Boolean)
+  ];
+}
+const applyUpdate = (o, n, q, f, opts) => {
+  const { parent, child: c, next } = n;
+  if (!c) {
+    let b = false;
+    const g = (u, k) => b = Boolean(f(u, k)) || b;
+    (0, import_util.walk)(o, parent, g, opts);
+    return b;
+  }
+  const t = (0, import_util.resolve)(o, parent);
+  if (!(0, import_util.isArray)(t)) return false;
+  return t.map((e, i) => {
+    if (q[c] && !q[c].test({ [c]: e })) return false;
+    return next ? applyUpdate(e, next, q, f, opts) : f(t, i);
+  }).some(Boolean);
+};
+function walkExpression(expr, arrayFilter, options, callback) {
+  const res = [];
+  for (const [selector, val] of Object.entries(expr)) {
+    const [node, vars] = tokenizePath(selector);
+    if (!vars.length) {
+      if (callback(val, node, {})) res.push(node.parent);
+    } else {
+      const conditions = {};
+      arrayFilter.forEach((o) => {
+        Object.keys(o).forEach((k) => {
+          vars.forEach((w) => {
+            if (k === w || k.startsWith(w + ".")) {
+              conditions[w] = conditions[w] || {};
+              Object.assign(conditions[w], { [k]: o[k] });
+            }
+          });
+        });
+      });
+      const queries = {};
+      for (const [k, condition] of Object.entries(conditions)) {
+        queries[k] = new import_query.Query(condition, options.queryOptions);
+      }
+      if (callback(val, node, queries)) res.push(node.parent);
+    }
+  }
+  return res;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7448:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7985:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Element Operators: https://docs.mongodb.com/manual/reference/operator/query-element/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$exists = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Matches documents that have the specified field.
- */
-exports.$exists = (0, _predicates_1.createQueryOperator)(_predicates_1.$exists);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addToSet_exports = {};
+__export(addToSet_exports, {
+  $addToSet: () => $addToSet
+});
+module.exports = __toCommonJS(addToSet_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $addToSet = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    const args = { $each: [val] };
+    if ((0, import_util.isObject)(val) && (0, import_util.has)(val, "$each")) {
+      Object.assign(args, val);
+    }
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const prev = o[k] ||= [];
+        const common = (0, import_util.intersection)([prev, args.$each]);
+        if (common.length === args.$each.length) return false;
+        o[k] = (0, import_internal.clone)(options.cloneMode, (0, import_util.unique)(prev.concat(args.$each)));
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3318:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 2592:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(7448), exports);
-__exportStar(__webpack_require__(8437), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bit_exports = {};
+__export(bit_exports, {
+  $bit: () => $bit
+});
+module.exports = __toCommonJS(bit_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const BIT_OPS = /* @__PURE__ */ new Set(["and", "or", "xor"]);
+const $bit = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    const op = Object.keys(val);
+    (0, import_util.assert)(
+      op.length === 1 && BIT_OPS.has(op[0]),
+      `Invalid bit operator '${op[0]}'. Must be one of 'and', 'or', or 'xor'.`
+    );
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        let n = o[k];
+        const v = val[op[0]];
+        if (n !== void 0 && !((0, import_util.isNumber)(n) && (0, import_util.isNumber)(v))) return false;
+        n = n || 0;
+        switch (op[0]) {
+          case "and":
+            o[k] = n & v;
+            break;
+          case "or":
+            o[k] = n | v;
+            break;
+          case "xor":
+            o[k] = n ^ v;
+            break;
+        }
+        return o[k] !== n;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8437:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 7346:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Element Operators: https://docs.mongodb.com/manual/reference/operator/query-element/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$type = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Selects documents if a field is of the specified type.
- */
-exports.$type = (0, _predicates_1.createQueryOperator)(_predicates_1.$type);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var currentDate_exports = {};
+__export(currentDate_exports, {
+  $currentDate: () => $currentDate
+});
+module.exports = __toCommonJS(currentDate_exports);
+var import_internal = __webpack_require__(3695);
+const $currentDate = (obj, expr, arrayFilters = [], options = {}) => {
+  const now = Date.now();
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        o[k] = now;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5468:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8891:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$expr = void 0;
-const core_1 = __webpack_require__(9587);
-/**
- * Allows the use of aggregation expressions within the query language.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-function $expr(_, rhs, options) {
-    return obj => (0, core_1.computeValue)(obj, rhs, null, options);
-}
-exports.$expr = $expr;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inc_exports = {};
+__export(inc_exports, {
+  $inc: () => $inc
+});
+module.exports = __toCommonJS(inc_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $inc = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    if (!node.child) {
+      const n = (0, import_util.resolve)(obj, node.parent);
+      (0, import_util.assert)(
+        n === void 0 || (0, import_util.isNumber)(n),
+        `cannot apply $inc to a value of non-numeric type`
+      );
+    }
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        o[k] = (o[k] ||= 0) + val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 6738:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 2835:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+module.exports = __toCommonJS(update_exports);
+__reExport(update_exports, __webpack_require__(7985), module.exports);
+__reExport(update_exports, __webpack_require__(2592), module.exports);
+__reExport(update_exports, __webpack_require__(7346), module.exports);
+__reExport(update_exports, __webpack_require__(8891), module.exports);
+__reExport(update_exports, __webpack_require__(1929), module.exports);
+__reExport(update_exports, __webpack_require__(2619), module.exports);
+__reExport(update_exports, __webpack_require__(9017), module.exports);
+__reExport(update_exports, __webpack_require__(628), module.exports);
+__reExport(update_exports, __webpack_require__(4868), module.exports);
+__reExport(update_exports, __webpack_require__(6381), module.exports);
+__reExport(update_exports, __webpack_require__(9891), module.exports);
+__reExport(update_exports, __webpack_require__(1461), module.exports);
+__reExport(update_exports, __webpack_require__(8356), module.exports);
+__reExport(update_exports, __webpack_require__(8402), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 1929:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(5468), exports);
-__exportStar(__webpack_require__(1777), exports);
-__exportStar(__webpack_require__(2841), exports);
-__exportStar(__webpack_require__(5787), exports);
-__exportStar(__webpack_require__(3953), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_exports = {};
+__export(max_exports, {
+  $max: () => $max
+});
+module.exports = __toCommonJS(max_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $max = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) > -1) return false;
+        o[k] = val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1777:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
+/***/ 2619:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$jsonSchema = void 0;
-/**
- * Validate documents against the given JSON Schema.
- *
- * @param selector
- * @param schema
- * @returns {Function}
- */
-function $jsonSchema(_, schema, options) {
-    if (!(options === null || options === void 0 ? void 0 : options.jsonSchemaValidator)) {
-        throw new Error("Missing option 'jsonSchemaValidator'. Configure to use '$jsonSchema' operator.");
-    }
-    const validate = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator(schema);
-    return (obj) => validate(obj);
-}
-exports.$jsonSchema = $jsonSchema;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var min_exports = {};
+__export(min_exports, {
+  $min: () => $min
+});
+module.exports = __toCommonJS(min_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $min = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) < 1) return false;
+        o[k] = val;
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 2841:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9017:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$mod = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Performs a modulo operation on the value of a field and selects documents with a specified result.
- */
-exports.$mod = (0, _predicates_1.createQueryOperator)(_predicates_1.$mod);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mul_exports = {};
+__export(mul_exports, {
+  $mul: () => $mul
+});
+module.exports = __toCommonJS(mul_exports);
+var import_internal = __webpack_require__(3695);
+const $mul = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const prev = o[k];
+        o[k] = o[k] === void 0 ? 0 : o[k] * val;
+        return o[k] !== prev;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5787:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 628:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$regex = void 0;
-const _predicates_1 = __webpack_require__(4414);
-/**
- * Selects documents where values match a specified regular expression.
- */
-exports.$regex = (0, _predicates_1.createQueryOperator)(_predicates_1.$regex);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pop_exports = {};
+__export(pop_exports, {
+  $pop: () => $pop
+});
+module.exports = __toCommonJS(pop_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $pop = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      const arr = o[k];
+      (0, import_util.assert)(
+        (0, import_util.isArray)(arr),
+        `path '${node.selector}' contains an element of non-array type.`
+      );
+      if (!arr.length) return false;
+      if (val === -1) {
+        arr.splice(0, 1);
+      } else {
+        arr.pop();
+      }
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3953:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4868:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$where = void 0;
-const util_1 = __webpack_require__(7216);
-/* eslint-disable */
-/**
- * Matches documents that satisfy a JavaScript expression.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-function $where(_, rhs, options) {
-    (0, util_1.assert)(options.scriptEnabled, "$where operator requires 'scriptEnabled' option to be true");
-    const f = rhs;
-    (0, util_1.assert)((0, util_1.isFunction)(f), "$where only accepts a Function object");
-    return (obj) => (0, util_1.truthy)(f.call(obj), options === null || options === void 0 ? void 0 : options.useStrictMode);
-}
-exports.$where = $where;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pull_exports = {};
+__export(pull_exports, {
+  $pull: () => $pull
+});
+module.exports = __toCommonJS(pull_exports);
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $pull = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    const wrap = !(0, import_util.isObject)(val) || Object.keys(val).some(import_util.isOperator);
+    const query = new import_query.Query(
+      wrap ? { k: val } : val,
+      options.queryOptions
+    );
+    const pred = wrap ? (v) => query.test({ k: v }) : (v) => query.test(v);
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      const prev = o[k];
+      const curr = new Array();
+      const found = prev.map((v) => {
+        const b = pred(v);
+        if (!b) curr.push(v);
+        return b;
+      }).some(Boolean);
+      if (!found) return false;
+      o[k] = curr;
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5444:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 6381:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(7562), exports);
-__exportStar(__webpack_require__(4167), exports);
-__exportStar(__webpack_require__(5630), exports);
-__exportStar(__webpack_require__(3318), exports);
-__exportStar(__webpack_require__(6738), exports);
-__exportStar(__webpack_require__(1504), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pullAll_exports = {};
+__export(pullAll_exports, {
+  $pullAll: () => $pullAll
+});
+module.exports = __toCommonJS(pullAll_exports);
+var import_pull = __webpack_require__(4868);
+const $pullAll = (obj, expr, arrayFilters = [], options = {}) => {
+  const pullExpr = {};
+  Object.entries(expr).forEach(([k, v]) => {
+    pullExpr[k] = { $in: v };
+  });
+  return (0, import_pull.$pull)(obj, pullExpr, arrayFilters, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 476:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 9891:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$and = void 0;
-const query_1 = __webpack_require__(809);
-const util_1 = __webpack_require__(7216);
-/**
- * Joins query clauses with a logical AND returns all documents that match the conditions of both clauses.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-const $and = (_, rhs, options) => {
-    (0, util_1.assert)((0, util_1.isArray)(rhs), "Invalid expression: $and expects value to be an Array.");
-    const queries = rhs.map(expr => new query_1.Query(expr, options));
-    return (obj) => queries.every(q => q.test(obj));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var push_exports = {};
+__export(push_exports, {
+  $push: () => $push
+});
+module.exports = __toCommonJS(push_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const OPERATOR_MODIFIERS = Object.freeze([
+  "$each",
+  "$slice",
+  "$sort",
+  "$position"
+]);
+const $push = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    const args = {
+      $each: [val]
+    };
+    if ((0, import_util.isObject)(val) && OPERATOR_MODIFIERS.some((m) => (0, import_util.has)(val, m))) {
+      Object.assign(args, val);
+    }
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const arr = o[k] ||= [];
+        const prev = arr.slice(0, args.$slice || arr.length);
+        const oldsize = arr.length;
+        const pos = (0, import_util.isNumber)(args.$position) ? args.$position : arr.length;
+        arr.splice(pos, 0, ...(0, import_internal.clone)(options.cloneMode, args.$each));
+        if (args.$sort) {
+          const sortKey = (0, import_util.isObject)(args.$sort) ? Object.keys(args.$sort || {}).pop() : "";
+          const order = !sortKey ? args.$sort : args.$sort[sortKey];
+          const f = !sortKey ? (a) => a : (a) => (0, import_util.resolve)(a, sortKey);
+          arr.sort((a, b) => order * (0, import_util.compare)(f(a), f(b)));
+        }
+        if ((0, import_util.isNumber)(args.$slice)) {
+          if (args.$slice < 0) arr.splice(0, arr.length + args.$slice);
+          else arr.splice(args.$slice);
+        }
+        return oldsize != arr.length || !(0, import_util.isEqual)(prev, arr);
+      },
+      { descendArray: true, buildGraph: true }
+    );
+  });
 };
-exports.$and = $and;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 1504:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
+/***/ 1461:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var __createBinding = (this && this.__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 = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(476), exports);
-__exportStar(__webpack_require__(43), exports);
-__exportStar(__webpack_require__(8663), exports);
-__exportStar(__webpack_require__(7653), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rename_exports = {};
+__export(rename_exports, {
+  $rename: () => $rename
+});
+module.exports = __toCommonJS(rename_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+var import_set = __webpack_require__(8356);
+const $rename = (obj, expr, arrayFilters = [], options = {}) => {
+  const res = [];
+  const changed = (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      if (!(0, import_util.has)(o, k)) return false;
+      res.push(...(0, import_set.$set)(obj, { [val]: o[k] }, arrayFilters, options));
+      delete o[k];
+      return true;
+    });
+  });
+  return Array.from(new Set(changed.concat(res)));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 43:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8356:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$nor = void 0;
-const util_1 = __webpack_require__(7216);
-const or_1 = __webpack_require__(7653);
-/**
- * Joins query clauses with a logical NOR returns all documents that fail to match both clauses.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-const $nor = (_, rhs, options) => {
-    (0, util_1.assert)((0, util_1.isArray)(rhs), "Invalid expression. $nor expects value to be an array.");
-    const f = (0, or_1.$or)("$or", rhs, options);
-    return (obj) => !f(obj);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  $set: () => $set
+});
+module.exports = __toCommonJS(set_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $set = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {
+    return (0, import_internal.applyUpdate)(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        if ((0, import_util.isEqual)(o[k], val)) return false;
+        o[k] = (0, import_internal.clone)(options.cloneMode, val);
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
 };
-exports.$nor = $nor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8663:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 8402:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$not = void 0;
-const query_1 = __webpack_require__(809);
-const util_1 = __webpack_require__(7216);
-/**
- * Inverts the effect of a query expression and returns documents that do not match the query expression.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-const $not = (selector, rhs, options) => {
-    const criteria = {};
-    criteria[selector] = (0, util_1.normalize)(rhs);
-    const query = new query_1.Query(criteria, options);
-    return (obj) => !query.test(obj);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.$not = $not;
-
-
-/***/ }),
-
-/***/ 7653:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$or = void 0;
-const query_1 = __webpack_require__(809);
-const util_1 = __webpack_require__(7216);
-/**
- * Joins query clauses with a logical OR returns all documents that match the conditions of either clause.
- *
- * @param selector
- * @param rhs
- * @returns {Function}
- */
-const $or = (_, rhs, options) => {
-    (0, util_1.assert)((0, util_1.isArray)(rhs), "Invalid expression. $or expects value to be an Array");
-    const queries = rhs.map(expr => new query_1.Query(expr, options));
-    return (obj) => queries.some(q => q.test(obj));
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-exports.$or = $or;
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unset_exports = {};
+__export(unset_exports, {
+  $unset: () => $unset
+});
+module.exports = __toCommonJS(unset_exports);
+var import_util = __webpack_require__(7839);
+var import_internal = __webpack_require__(3695);
+const $unset = (obj, expr, arrayFilters = [], options = {}) => {
+  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {
+    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {
+      if (!(0, import_util.has)(o, k)) return false;
+      if ((0, import_util.isArray)(o)) {
+        o[k] = null;
+      } else {
+        delete o[k];
+      }
+      return true;
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3480:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 5914:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.rank = exports.withMemo = exports.MILLIS_PER_UNIT = void 0;
-const util_1 = __webpack_require__(7216);
-const accumulator_1 = __webpack_require__(3424);
-const _internal_1 = __webpack_require__(7974);
-const _internal_2 = __webpack_require__(2899);
-// millis map to diffirent time units
-exports.MILLIS_PER_UNIT = {
-    week: _internal_1.MILLIS_PER_DAY * 7,
-    day: _internal_1.MILLIS_PER_DAY,
-    hour: _internal_1.MILLIS_PER_DAY / 24,
-    minute: 60000,
-    second: 1000,
-    millisecond: 1
-};
-// internal cache to store precomputed series once to avoid O(N^2) calls to over the collection
-const memo = new WeakMap();
-/**
- * Caches all computed values in a window sequence for reuse.
- * This is only useful for operations with unbounded documents.
- */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  MILLIS_PER_UNIT: () => MILLIS_PER_UNIT,
+  rank: () => rank,
+  withMemo: () => withMemo
+});
+module.exports = __toCommonJS(internal_exports);
+var import_util = __webpack_require__(7839);
+var import_accumulator = __webpack_require__(1248);
+var import_internal = __webpack_require__(1277);
+var import_internal2 = __webpack_require__(2088);
+const MILLIS_PER_UNIT = {
+  week: import_internal.MILLIS_PER_DAY * 7,
+  day: import_internal.MILLIS_PER_DAY,
+  hour: import_internal.MILLIS_PER_DAY / 24,
+  minute: 6e4,
+  second: 1e3,
+  millisecond: 1
+};
+const memo = /* @__PURE__ */ new WeakMap();
 function withMemo(collection, expr, cacheFn, fn) {
-    // no caching done for bounded inputs
-    if (!(0, _internal_2.isUnbounded)(expr.parentExpr.output[expr.field].window)) {
-        return fn(cacheFn());
-    }
-    // first time using collection
-    if (!memo.has(collection)) {
-        memo.set(collection, { [expr.field]: cacheFn() });
-    }
-    const data = memo.get(collection);
-    // subsequent computations over the same collection.
-    if (data[expr.field] === undefined) {
-        data[expr.field] = cacheFn();
-    }
-    let failed = false;
-    try {
-        return fn(data[expr.field]);
-    }
-    catch (e) {
-        failed = true;
-    }
-    finally {
-        // cleanup on failure or last element in collection.
-        if (failed || expr.documentNumber === collection.length) {
-            delete data[expr.field];
-            if (Object.keys(data).length === 0)
-                memo.delete(collection);
-        }
+  if (!(0, import_internal2.isUnbounded)(expr.parentExpr.output[expr.field].window)) {
+    return fn(cacheFn());
+  }
+  if (!memo.has(collection)) {
+    memo.set(collection, { [expr.field]: cacheFn() });
+  }
+  const data = memo.get(collection);
+  if (data[expr.field] === void 0) {
+    data[expr.field] = cacheFn();
+  }
+  let failed = false;
+  try {
+    return fn(data[expr.field]);
+  } catch {
+    failed = true;
+  } finally {
+    if (failed || expr.documentNumber === collection.length) {
+      delete data[expr.field];
+      if (Object.keys(data).length === 0) memo.delete(collection);
     }
+  }
 }
-exports.withMemo = withMemo;
-/** Returns the position of a document in the $setWindowFields stage partition. */
 function rank(_, collection, expr, options, dense) {
-    return withMemo(collection, expr, () => {
-        const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
-        const values = (0, accumulator_1.$push)(collection, sortKey, options);
-        const groups = (0, util_1.groupBy)(values, ((_, n) => values[n]), options.hashFunction);
-        return { values, groups };
-    }, input => {
-        const { values, groups: partitions } = input;
-        // same number of paritions as length means all sort keys are unique
-        if (partitions.size == collection.length) {
-            return expr.documentNumber;
-        }
-        const current = values[expr.documentNumber - 1];
-        let i = 0;
-        let offset = 0;
-        // partition keys are already dense so just return the value on match
-        for (const key of partitions.keys()) {
-            if ((0, util_1.isEqual)(current, key)) {
-                return dense ? i + 1 : offset + 1;
-            }
-            i++;
-            offset += partitions.get(key).length;
+  return withMemo(
+    collection,
+    expr,
+    () => {
+      const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
+      const values = (0, import_accumulator.$push)(collection, sortKey, options);
+      const groups = (0, import_util.groupBy)(
+        values,
+        (_2, n) => values[n],
+        options.hashFunction
+      );
+      return { values, groups };
+    },
+    (input) => {
+      const { values, groups: partitions } = input;
+      if (partitions.size == collection.length) {
+        return expr.documentNumber;
+      }
+      const current = values[expr.documentNumber - 1];
+      let i = 0;
+      let offset = 0;
+      for (const key of partitions.keys()) {
+        if ((0, import_util.isEqual)(current, key)) {
+          return dense ? i + 1 : offset + 1;
         }
-        // should be unreachable
-        throw new Error("rank: invalid return value. please submit a bug report.");
-    });
+        i++;
+        offset += partitions.get(key).length;
+      }
+      throw new import_util.MingoError(
+        "rank: invalid return value. please submit a bug report."
+      );
+    }
+  );
 }
-exports.rank = rank;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 5120:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4276:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$linearFill = void 0;
-const util_1 = __webpack_require__(7216);
-const accumulator_1 = __webpack_require__(3424);
-const _internal_1 = __webpack_require__(3480);
-/**
- * Given two points (x1, y1) and (x2, y2) and a value 'x' that lies between those two points,
- * solve for 'y' with: y = y1 + (x - x1) * ((y2 - y1)/(x2 - x1)).
- * @see https://en.wikipedia.org/wiki/Linear_interpolation
- */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var linearFill_exports = {};
+__export(linearFill_exports, {
+  $linearFill: () => $linearFill
+});
+module.exports = __toCommonJS(linearFill_exports);
+var import_util = __webpack_require__(7839);
+var import_accumulator = __webpack_require__(1248);
+var import_internal = __webpack_require__(5914);
 const interpolate = (x1, y1, x2, y2, x) => y1 + (x - x1) * ((y2 - y1) / (x2 - x1));
-/**
- * Fills null and missing fields in a window using linear interpolation based on surrounding field values.
- */
-function $linearFill(_, collection, expr, options) {
-    return (0, _internal_1.withMemo)(collection, expr, (() => {
-        const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
-        const points = (0, accumulator_1.$push)(collection, [sortKey, expr.inputExpr], options).filter((([x, _]) => (0, util_1.isNumber)(+x)));
-        if (points.length !== collection.length)
-            return null;
-        let lindex = -1;
-        let rindex = 0;
-        while (rindex < points.length) {
-            // use sliding window over missing values and fill as we go.
-            // determine nearest left value index
-            while (lindex + 1 < points.length && (0, util_1.isNumber)(points[lindex + 1][1])) {
-                lindex++;
-                rindex = lindex;
-            }
-            // determine nearest right value index.
-            while (rindex + 1 < points.length && !(0, util_1.isNumber)(points[rindex + 1][1])) {
-                rindex++;
-            }
-            // we reached the end of our array. nothing more to do.
-            if (rindex + 1 >= points.length)
-                break;
-            // otherwise, we found a number so move rindex pointer to it.
-            rindex++;
-            // now fill everything between lindex and rindex by their proportions to the difference.
-            while (lindex + 1 < rindex) {
-                points[lindex + 1][1] = interpolate(points[lindex][0], points[lindex][1], points[rindex][0], points[rindex][1], points[lindex + 1][0]);
-                lindex++;
-            }
-            // move lindex to right
-            lindex = rindex;
+const $linearFill = (_, collection, expr, options) => {
+  return (0, import_internal.withMemo)(
+    collection,
+    expr,
+    () => {
+      const sortKey = "$" + Object.keys(expr.parentExpr.sortBy)[0];
+      const points = (0, import_accumulator.$push)(
+        collection,
+        [sortKey, expr.inputExpr],
+        options
+      ).filter(([x, _2]) => (0, import_util.isNumber)(+x));
+      if (points.length !== collection.length) return null;
+      let lindex = -1;
+      let rindex = 0;
+      while (rindex < points.length) {
+        while (lindex + 1 < points.length && (0, import_util.isNumber)(points[lindex + 1][1])) {
+          lindex++;
+          rindex = lindex;
         }
-        return points.map(([_, y]) => y);
-    }), (values) => values[expr.documentNumber - 1]);
-}
-exports.$linearFill = $linearFill;
+        while (rindex + 1 < points.length && !(0, import_util.isNumber)(points[rindex + 1][1])) {
+          rindex++;
+        }
+        if (rindex + 1 >= points.length) break;
+        rindex++;
+        while (lindex + 1 < rindex) {
+          points[lindex + 1][1] = interpolate(
+            points[lindex][0],
+            points[lindex][1],
+            points[rindex][0],
+            points[rindex][1],
+            points[lindex + 1][0]
+          );
+          lindex++;
+        }
+        lindex = rindex;
+      }
+      return points.map(([_2, y]) => y);
+    },
+    (values) => values[expr.documentNumber - 1]
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 8242:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 4140:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.$locf = void 0;
-const util_1 = __webpack_require__(7216);
-const push_1 = __webpack_require__(7835);
-const _internal_1 = __webpack_require__(3480);
-/**
- * Last observation carried forward. Sets values for null and missing fields in a window to the last non-null value for the field.
- */
-function $locf(_, collection, expr, options) {
-    return (0, _internal_1.withMemo)(collection, expr, () => {
-        const values = (0, push_1.$push)(collection, expr.inputExpr, options);
-        for (let i = 1; i < values.length; i++) {
-            if ((0, util_1.isNil)(values[i]))
-                values[i] = values[i - 1];
-        }
-        return values;
-    }, (series) => series[expr.documentNumber - 1]);
-}
-exports.$locf = $locf;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locf_exports = {};
+__export(locf_exports, {
+  $locf: () => $locf
+});
+module.exports = __toCommonJS(locf_exports);
+var import_util = __webpack_require__(7839);
+var import_push = __webpack_require__(4518);
+var import_internal = __webpack_require__(5914);
+const $locf = (_, collection, expr, options) => {
+  return (0, import_internal.withMemo)(
+    collection,
+    expr,
+    () => {
+      const values = (0, import_push.$push)(collection, expr.inputExpr, options);
+      for (let i = 1; i < values.length; i++) {
+        if ((0, import_util.isNil)(values[i])) values[i] = values[i - 1];
+      }
+      return values;
+    },
+    (series) => series[expr.documentNumber - 1]
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 809:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
+/***/ 6535:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Query = void 0;
-const core_1 = __webpack_require__(9587);
-const cursor_1 = __webpack_require__(3645);
-const util_1 = __webpack_require__(7216);
-/**
- * An object used to filter input documents
- *
- * @param {Object} condition The condition for constructing predicates
- * @param {Options} options Options for use by operators
- * @constructor
- */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_exports = {};
+__export(query_exports, {
+  Query: () => Query
+});
+module.exports = __toCommonJS(query_exports);
+var import_core = __webpack_require__(2760);
+var import_cursor = __webpack_require__(4529);
+var import_util = __webpack_require__(7839);
+const TOP_LEVEL_OPS = new Set(
+  Array.from(["$and", "$or", "$nor", "$expr", "$jsonSchema"])
+);
 class Query {
-    constructor(condition, options) {
-        this.condition = condition;
-        this.options = (0, core_1.initOptions)(options);
-        this.compiled = [];
-        this.compile();
-    }
-    compile() {
-        (0, util_1.assert)((0, util_1.isObject)(this.condition), "query criteria must be an object");
-        const whereOperator = {};
-        for (const [field, expr] of Object.entries(this.condition)) {
-            if ("$where" === field) {
-                Object.assign(whereOperator, { field: field, expr: expr });
-            }
-            else if ((0, util_1.inArray)(["$and", "$or", "$nor", "$expr", "$jsonSchema"], field)) {
-                this.processOperator(field, field, expr);
-            }
-            else {
-                // normalize expression
-                (0, util_1.assert)(!(0, util_1.isOperator)(field), `unknown top level operator: ${field}`);
-                for (const [operator, val] of Object.entries((0, util_1.normalize)(expr))) {
-                    this.processOperator(field, operator, val);
-                }
-            }
-            if (whereOperator.field) {
-                this.processOperator(whereOperator.field, whereOperator.field, whereOperator.expr);
-            }
-        }
-    }
-    processOperator(field, operator, value) {
-        const call = (0, core_1.getOperator)(core_1.OperatorType.QUERY, operator, this.options);
-        if (!call) {
-            throw new Error(`unknown operator ${operator}`);
-        }
-        const fn = call(field, value, this.options);
-        this.compiled.push(fn);
-    }
-    /**
-     * Checks if the object passes the query criteria. Returns true if so, false otherwise.
-     *
-     * @param obj The object to test
-     * @returns {boolean} True or false
-     */
-    test(obj) {
-        for (let i = 0, len = this.compiled.length; i < len; i++) {
-            if (!this.compiled[i](obj)) {
-                return false;
-            }
+  #compiled;
+  #options;
+  #condition;
+  constructor(condition, options) {
+    this.#condition = condition;
+    this.#options = (0, import_core.initOptions)(options);
+    this.#compiled = [];
+    this.compile();
+  }
+  compile() {
+    (0, import_util.assert)(
+      (0, import_util.isObject)(this.#condition),
+      `query criteria must be an object: ${JSON.stringify(this.#condition)}`
+    );
+    const whereOperator = {};
+    for (const [field, expr] of Object.entries(this.#condition)) {
+      if ("$where" === field) {
+        Object.assign(whereOperator, { field, expr });
+      } else if (TOP_LEVEL_OPS.has(field)) {
+        this.processOperator(field, field, expr);
+      } else {
+        (0, import_util.assert)(!(0, import_util.isOperator)(field), `unknown top level operator: ${field}`);
+        for (const [operator, val] of Object.entries(
+          (0, import_util.normalize)(expr)
+        )) {
+          this.processOperator(field, operator, val);
         }
-        return true;
+      }
+      if (whereOperator.field) {
+        this.processOperator(
+          whereOperator.field,
+          whereOperator.field,
+          whereOperator.expr
+        );
+      }
     }
-    /**
-     * Returns a cursor to select matching documents from the input source.
-     *
-     * @param source A source providing a sequence of documents
-     * @param projection An optional projection criteria
-     * @returns {Cursor} A Cursor for iterating over the results
-     */
-    find(collection, projection) {
-        return new cursor_1.Cursor(collection, ((x) => this.test(x)), projection || {}, this.options);
+  }
+  processOperator(field, operator, value) {
+    const call = (0, import_core.getOperator)("query", operator, this.#options);
+    if (!call) {
+      throw new import_util.MingoError(`unknown query operator ${operator}`);
     }
-    /**
-     * Remove matched documents from the collection returning the remainder
-     *
-     * @param collection An array of documents
-     * @returns {Array} A new array with matching elements removed
-     */
-    remove(collection) {
-        return collection.reduce((acc, obj) => {
-            if (!this.test(obj))
-                acc.push(obj);
-            return acc;
-        }, []);
+    const fn = call(field, value, this.#options);
+    this.#compiled.push(fn);
+  }
+  /**
+   * Checks if the object passes the query criteria. Returns true if so, false otherwise.
+   *
+   * @param obj The object to test
+   * @returns {boolean} True or false
+   */
+  test(obj) {
+    for (let i = 0, len = this.#compiled.length; i < len; i++) {
+      if (!this.#compiled[i](obj)) {
+        return false;
+      }
     }
+    return true;
+  }
+  /**
+   * Returns a cursor to select matching documents from the input source.
+   *
+   * @param source A source providing a sequence of documents
+   * @param projection An optional projection criteria
+   * @returns {Cursor} A Cursor for iterating over the results
+   */
+  find(collection, projection) {
+    return new import_cursor.Cursor(
+      collection,
+      (x) => this.test(x),
+      projection || {},
+      this.#options
+    );
+  }
+  /**
+   * Remove matched documents from the collection returning the remainder
+   *
+   * @param collection An array of documents
+   * @returns {Array} A new array with matching elements removed
+   */
+  remove(collection) {
+    return collection.reduce((acc, obj) => {
+      if (!this.test(obj)) acc.push(obj);
+      return acc;
+    }, []);
+  }
 }
-exports.Query = Query;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 7216:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 486:
+/***/ ((module) => {
 
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  TIME_UNITS: () => TIME_UNITS
+});
+module.exports = __toCommonJS(types_exports);
+const TIME_UNITS = [
+  "year",
+  "quarter",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute",
+  "second",
+  "millisecond"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
-/**
- * Utility constants and functions
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.normalize = exports.isOperator = exports.removeValue = exports.setValue = exports.walk = exports.filterMissing = exports.resolveGraph = exports.resolve = exports.memoize = exports.into = exports.groupBy = exports.sortBy = exports.hashCode = exports.stringify = exports.unique = exports.isEqual = exports.flatten = exports.intersection = exports.merge = exports.has = exports.ensureArray = exports.isMissing = exports.isEmpty = exports.truthy = exports.notInArray = exports.inArray = exports.isNil = exports.isFunction = exports.isRegExp = exports.isDate = exports.isObjectLike = exports.isObject = exports.isArray = exports.isNotNaN = exports.isNumber = exports.isString = exports.isBoolean = exports.getType = exports.cloneDeep = exports.assert = exports.compare = exports.MIN_LONG = exports.MAX_LONG = exports.MIN_INT = exports.MAX_INT = void 0;
-exports.MAX_INT = 2147483647;
-exports.MIN_INT = -2147483648;
-exports.MAX_LONG = Number.MAX_SAFE_INTEGER;
-exports.MIN_LONG = Number.MIN_SAFE_INTEGER;
-// special value to identify missing items. treated differently from undefined
+
+/***/ }),
+
+/***/ 3550:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updater_exports = {};
+__export(updater_exports, {
+  createUpdater: () => createUpdater,
+  update: () => update,
+  updateObject: () => updateObject
+});
+module.exports = __toCommonJS(updater_exports);
+var import_core = __webpack_require__(2760);
+var booleanOperators = __toESM(__webpack_require__(1703));
+var comparisonOperators = __toESM(__webpack_require__(3336));
+var queryOperators = __toESM(__webpack_require__(8510));
+var UPDATE_OPERATORS = __toESM(__webpack_require__(2835));
+var import_query = __webpack_require__(6535);
+var import_util = __webpack_require__(7839);
+function createUpdater(defaultOptions) {
+  defaultOptions = defaultOptions || {};
+  defaultOptions = {
+    ...defaultOptions,
+    queryOptions: (0, import_core.initOptions)(defaultOptions.queryOptions)
+  };
+  defaultOptions.queryOptions.context.addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators);
+  return (obj, expr, arrayFilters = [], condition = {}, options = {}) => {
+    const opts = Object.assign({ cloneMode: "copy" }, defaultOptions, options);
+    Object.assign(opts, {
+      queryOptions: (0, import_core.initOptions)(
+        Object.assign({ useStrictMode: false }, opts?.queryOptions)
+      )
+    });
+    const entry = Object.entries(expr);
+    (0, import_util.assert)(
+      entry.length === 1,
+      "Update expression must contain only one operator."
+    );
+    const [op, args] = entry[0];
+    (0, import_util.assert)(
+      (0, import_util.has)(UPDATE_OPERATORS, op),
+      `Update operator '${op}' is not supported.`
+    );
+    const mutate = UPDATE_OPERATORS[op];
+    if (Object.keys(condition).length) {
+      const q = condition instanceof import_query.Query ? condition : new import_query.Query(condition, opts.queryOptions);
+      if (!q.test(obj)) return [];
+    }
+    return mutate(obj, args, arrayFilters, opts);
+  };
+}
+const update = createUpdater();
+const updateObject = update;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+
+
+/***/ }),
+
+/***/ 7839:
+/***/ ((module) => {
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  MingoError: () => MingoError,
+  ValueMap: () => ValueMap,
+  assert: () => assert,
+  cloneDeep: () => cloneDeep,
+  compare: () => compare,
+  ensureArray: () => ensureArray,
+  filterMissing: () => filterMissing,
+  findInsertIndex: () => findInsertIndex,
+  flatten: () => flatten,
+  groupBy: () => groupBy,
+  has: () => has,
+  hashCode: () => hashCode,
+  intersection: () => intersection,
+  into: () => into,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isFunction: () => isFunction,
+  isNil: () => isNil,
+  isNotNaN: () => isNotNaN,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isOperator: () => isOperator,
+  isRegExp: () => isRegExp,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  merge: () => merge,
+  normalize: () => normalize,
+  removeValue: () => removeValue,
+  resolve: () => resolve,
+  resolveGraph: () => resolveGraph,
+  setValue: () => setValue,
+  stringify: () => stringify,
+  truthy: () => truthy,
+  typeOf: () => typeOf,
+  unique: () => unique,
+  walk: () => walk
+});
+module.exports = __toCommonJS(util_exports);
+class MingoError extends Error {
+}
 const MISSING = Symbol("missing");
-const OBJECT_PROTOTYPE = Object.getPrototypeOf({});
-const OBJECT_TAG = "[object Object]";
-const OBJECT_TYPE_RE = /^\[object ([a-zA-Z0-9]+)\]$/;
-/**
- * Uses the simple hash method as described in Effective Java.
- * @see https://stackoverflow.com/a/113600/1370481
- * @param value The value to hash
- * @returns {number}
- */
+const CYCLE_FOUND_ERROR = Object.freeze(
+  new Error("mingo: cycle detected while processing object/array")
+);
 const DEFAULT_HASH_FUNCTION = (value) => {
-    const s = stringify(value);
-    let hash = 0;
-    let i = s.length;
-    while (i)
-        hash = ((hash << 5) - hash) ^ s.charCodeAt(--i);
-    return hash >>> 0;
-};
-// no array, object, or function types
-const JS_SIMPLE_TYPES = new Set([
-    "null",
-    "undefined",
-    "boolean",
-    "number",
-    "string",
-    "date",
-    "regexp"
-]);
-/** MongoDB sort comparison order. https://www.mongodb.com/docs/manual/reference/bson-type-comparison-order */
-const SORT_ORDER_BY_TYPE = {
-    null: 0,
-    undefined: 0,
-    number: 1,
-    string: 2,
-    object: 3,
-    array: 4,
-    boolean: 5,
-    date: 6,
-    regexp: 7,
-    function: 8
+  const s = stringify(value);
+  let hash = 0;
+  let i = s.length;
+  while (i) hash = (hash << 5) - hash ^ s.charCodeAt(--i);
+  return hash >>> 0;
+};
+const objectProto = Object.prototype;
+const arrayProto = Array.prototype;
+const getPrototypeOf = Object.getPrototypeOf;
+const isPrimitive = (v) => typeof v !== "object" && typeof v !== "function" || v === null;
+const isScalar = (v) => isPrimitive(v) || isDate(v) || isRegExp(v);
+const SORT_ORDER = {
+  undefined: 1,
+  null: 2,
+  number: 3,
+  string: 4,
+  symbol: 5,
+  object: 6,
+  array: 7,
+  arraybuffer: 8,
+  boolean: 9,
+  date: 10,
+  regexp: 11,
+  function: 12
 };
-/**
- * Compare function which adheres to MongoDB comparison order.
- *
- * @param a The first value
- * @param b The second value
- * @returns {Number}
- */
 const compare = (a, b) => {
-    if (a === MISSING)
-        a = undefined;
-    if (b === MISSING)
-        b = undefined;
-    const [u, v] = [a, b].map(n => SORT_ORDER_BY_TYPE[(0, exports.getType)(n).toLowerCase()]);
-    if (u !== v)
-        return u - v;
-    // number | string | date
-    if (u === 1 || u === 2 || u === 6) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
-    // check for equivalence equality
-    if (isEqual(a, b))
-        return 0;
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    // if we get here we are comparing a type that does not make sense.
-    return 0;
+  if (a === MISSING) a = void 0;
+  if (b === MISSING) b = void 0;
+  const [u, v] = [a, b].map((n) => SORT_ORDER[typeOf(n)]);
+  if (u !== v) return u - v;
+  if (isEqual(a, b)) return 0;
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
 };
-exports.compare = compare;
+class ValueMap extends Map {
+  // The hash function
+  #hashFn = DEFAULT_HASH_FUNCTION;
+  // maps the hashcode to key set
+  #keyMap = /* @__PURE__ */ new Map();
+  // returns a tuple of [<masterKey>, <hash>]. Expects an object key.
+  #unpack = (key) => {
+    const hash = this.#hashFn(key);
+    return [(this.#keyMap.get(hash) || []).find((k) => isEqual(k, key)), hash];
+  };
+  constructor() {
+    super();
+  }
+  /**
+   * Returns a new {@link ValueMap} object.
+   * @param fn An optional custom hash function
+   */
+  static init(fn) {
+    const m = new ValueMap();
+    if (fn) m.#hashFn = fn;
+    return m;
+  }
+  clear() {
+    super.clear();
+    this.#keyMap.clear();
+  }
+  /**
+   * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+   */
+  delete(key) {
+    if (isPrimitive(key)) return super.delete(key);
+    const [masterKey, hash] = this.#unpack(key);
+    if (!super.delete(masterKey)) return false;
+    this.#keyMap.set(
+      hash,
+      this.#keyMap.get(hash).filter((k) => !isEqual(k, masterKey))
+    );
+    return true;
+  }
+  /**
+   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+   */
+  get(key) {
+    if (isPrimitive(key)) return super.get(key);
+    const [masterKey, _] = this.#unpack(key);
+    return super.get(masterKey);
+  }
+  /**
+   * @returns boolean indicating whether an element with the specified key exists or not.
+   */
+  has(key) {
+    if (isPrimitive(key)) return super.has(key);
+    const [masterKey, _] = this.#unpack(key);
+    return super.has(masterKey);
+  }
+  /**
+   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+   */
+  set(key, value) {
+    if (isPrimitive(key)) return super.set(key, value);
+    const [masterKey, hash] = this.#unpack(key);
+    if (super.has(masterKey)) {
+      super.set(masterKey, value);
+    } else {
+      super.set(key, value);
+      const keys = this.#keyMap.get(hash) || [];
+      keys.push(key);
+      this.#keyMap.set(hash, keys);
+    }
+    return this;
+  }
+  /**
+   * @returns the number of elements in the Map.
+   */
+  get size() {
+    return super.size;
+  }
+}
 function assert(condition, message) {
-    if (!condition)
-        throw new Error(message);
+  if (!condition) throw new MingoError(message);
 }
-exports.assert = assert;
-/**
- * Deep clone an object. Value types and immutable objects are returned as is.
- */
-const cloneDeep = (obj) => {
-    const m = new Map();
-    const add = (v) => {
-        if (m.has(v))
-            throw new Error("cycle detected during clone operation.");
-        m.set(v, true);
-    };
-    const clone = (val) => {
-        if (val instanceof Date)
-            return new Date(val);
-        if ((0, exports.isArray)(val)) {
-            add(val);
-            const res = new Array(val.length);
-            const len = val.length;
-            for (let i = 0; i < len; i++)
-                res[i] = clone(val[i]);
-            return res;
-        }
-        if ((0, exports.isObject)(val)) {
-            add(val);
-            const res = {};
-            for (const k in val)
-                res[k] = clone(val[k]);
-            return res;
-        }
-        return val;
-    };
-    return clone(obj);
-};
-exports.cloneDeep = cloneDeep;
-/**
- * Returns the name of type as specified in the tag returned by a call to Object.prototype.toString
- * @param v A value
- */
-const getType = (v) => OBJECT_TYPE_RE.exec(Object.prototype.toString.call(v))[1];
-exports.getType = getType;
+const typeOf = (v) => {
+  const s = objectProto.toString.call(v);
+  const t = s.substring(8, s.length - 1).toLowerCase();
+  if (t !== "object") return t;
+  const ctor = v.constructor;
+  return ctor == null || ctor === Object ? t : ctor.name;
+};
 const isBoolean = (v) => typeof v === "boolean";
-exports.isBoolean = isBoolean;
 const isString = (v) => typeof v === "string";
-exports.isString = isString;
+const isSymbol = (v) => typeof v === "symbol";
 const isNumber = (v) => !isNaN(v) && typeof v === "number";
-exports.isNumber = isNumber;
 const isNotNaN = (v) => !(isNaN(v) && typeof v === "number");
-exports.isNotNaN = isNotNaN;
-exports.isArray = Array.isArray;
+const isArray = Array.isArray;
 const isObject = (v) => {
-    if (!v)
-        return false;
-    const proto = Object.getPrototypeOf(v);
-    return ((proto === OBJECT_PROTOTYPE || proto === null) &&
-        OBJECT_TAG === Object.prototype.toString.call(v));
+  if (!v) return false;
+  const p = Object.getPrototypeOf(v);
+  return (p === Object.prototype || p === null) && typeOf(v) === "object";
 };
-exports.isObject = isObject;
-//  objects, arrays, functions, date, custom object
-const isObjectLike = (v) => v === Object(v);
-exports.isObjectLike = isObjectLike;
+const isObjectLike = (v) => !isPrimitive(v);
 const isDate = (v) => v instanceof Date;
-exports.isDate = isDate;
 const isRegExp = (v) => v instanceof RegExp;
-exports.isRegExp = isRegExp;
 const isFunction = (v) => typeof v === "function";
-exports.isFunction = isFunction;
-const isNil = (v) => v === null || v === undefined;
-exports.isNil = isNil;
-const inArray = (arr, item) => arr.includes(item);
-exports.inArray = inArray;
-const notInArray = (arr, item) => !(0, exports.inArray)(arr, item);
-exports.notInArray = notInArray;
-const truthy = (arg, strict = true) => !!arg || (strict && arg === "");
-exports.truthy = truthy;
-const isEmpty = (x) => (0, exports.isNil)(x) ||
-    ((0, exports.isString)(x) && !x) ||
-    (x instanceof Array && x.length === 0) ||
-    ((0, exports.isObject)(x) && Object.keys(x).length === 0);
-exports.isEmpty = isEmpty;
+const isNil = (v) => v === null || v === void 0;
+const truthy = (arg, strict = true) => !!arg || strict && arg === "";
+const isEmpty = (x) => isNil(x) || isString(x) && !x || isArray(x) && x.length === 0 || isObject(x) && Object.keys(x).length === 0;
+const ensureArray = (x) => isArray(x) ? x : [x];
+const has = (obj, prop) => !!obj && objectProto.hasOwnProperty.call(obj, prop);
+const isTypedArray = (v) => typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v);
+const cloneDeep = (v, refs) => {
+  if (isNil(v) || isBoolean(v) || isNumber(v) || isString(v)) return v;
+  if (isDate(v)) return new Date(v);
+  if (isRegExp(v)) return new RegExp(v);
+  if (isTypedArray(v)) {
+    const ctor = v.constructor;
+    return new ctor(v);
+  }
+  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();
+  if (refs.has(v)) throw CYCLE_FOUND_ERROR;
+  refs.add(v);
+  try {
+    if (isArray(v)) {
+      const arr = new Array(v.length);
+      for (let i = 0; i < v.length; i++) arr[i] = cloneDeep(v[i], refs);
+      return arr;
+    }
+    if (isObject(v)) {
+      const obj = {};
+      for (const k of Object.keys(v)) obj[k] = cloneDeep(v[k], refs);
+      return obj;
+    }
+  } finally {
+    refs.delete(v);
+  }
+  return v;
+};
 const isMissing = (v) => v === MISSING;
-exports.isMissing = isMissing;
-/** ensure a value is an array or wrapped within one. */
-const ensureArray = (x) => x instanceof Array ? x : [x];
-exports.ensureArray = ensureArray;
-const has = (obj, prop) => !!obj && Object.prototype.hasOwnProperty.call(obj, prop);
-exports.has = has;
-const mergeable = (left, right) => ((0, exports.isObject)(left) && (0, exports.isObject)(right)) || ((0, exports.isArray)(left) && (0, exports.isArray)(right));
-/**
- * Deep merge objects or arrays.
- * When the inputs have unmergeable types, the  right hand value is returned.
- * If inputs are arrays and options.flatten is set, elements in the same position are merged together. Remaining elements are appended to the target object.
- * If options.flatten is false, the right hand value is just appended to the left-hand value.
- * @param target {Object|Array} the target to merge into
- * @param obj {Object|Array} the source object
- */
-function merge(target, obj, options) {
-    // default options
-    options = options || { flatten: false };
-    // take care of missing inputs
-    if ((0, exports.isMissing)(target) || (0, exports.isNil)(target))
-        return obj;
-    if ((0, exports.isMissing)(obj) || (0, exports.isNil)(obj))
-        return target;
-    // fail only on initial input.
-    if (!mergeable(target, obj)) {
-        if (options.skipValidation)
-            return obj || target;
-        throw Error("mismatched types. must both be array or object");
-    }
-    // skip validation after initial input.
-    options.skipValidation = true;
-    if ((0, exports.isArray)(target)) {
-        const result = target;
-        const input = obj;
-        if (options.flatten) {
-            let i = 0;
-            let j = 0;
-            while (i < result.length && j < input.length) {
-                result[i] = merge(result[i++], input[j++], options);
-            }
-            while (j < input.length) {
-                result.push(obj[j++]);
-            }
-        }
-        else {
-            into(result, input);
-        }
-    }
-    else {
-        for (const k in obj) {
-            target[k] = merge(target[k], obj[k], options);
-        }
-    }
-    return target;
-}
-exports.merge = merge;
-function buildHashIndex(arr, hashFunction = DEFAULT_HASH_FUNCTION) {
-    const map = new Map();
-    arr.forEach((o, i) => {
-        const h = hashCode(o, hashFunction);
-        if (map.has(h)) {
-            if (!map.get(h).some(j => isEqual(arr[j], o))) {
-                map.get(h).push(i);
-            }
-        }
-        else {
-            map.set(h, [i]);
-        }
-    });
-    return map;
+function merge(target, input) {
+  if (isMissing(target) || isNil(target)) return input;
+  if (isMissing(input) || isNil(input)) return target;
+  if (isPrimitive(target) || isPrimitive(input)) return input;
+  if (isArray(target) && isArray(input)) {
+    assert(
+      target.length === input.length,
+      "arrays must be of equal length to merge."
+    );
+  }
+  for (const k in input) {
+    target[k] = merge(target[k], input[k]);
+  }
+  return target;
 }
-/**
- * Returns the intersection of multiple arrays.
- *
- * @param  {Array} input An array of arrays from which to find intersection.
- * @param  {Function} hashFunction Custom function to hash values, default the hashCode method
- * @return {Array} Array of intersecting values.
- */
 function intersection(input, hashFunction = DEFAULT_HASH_FUNCTION) {
-    // if any array is empty, there is no intersection
-    if (input.some(arr => arr.length == 0))
-        return [];
-    if (input.length === 1)
-        return Array.from(input);
-    // sort input arrays by to get smallest array
-    // const sorted = sortBy(input, (a: RawArray) => a.length) as RawArray[];
-    const sortedIndex = sortBy(input.map((a, i) => [i, a.length]), (a) => a[1]);
-    // get the smallest
-    const smallest = input[sortedIndex[0][0]];
-    // get hash index of smallest array
-    const map = buildHashIndex(smallest, hashFunction);
-    // hashIndex for remaining arrays.
-    const rmap = new Map();
-    // final intersection results and index of first occurrence.
-    const results = new Array();
-    map.forEach((v, k) => {
-        const lhs = v.map(j => smallest[j]);
-        const res = lhs.map(_ => 0);
-        // used to track first occurence of value in order of the original input array.
-        const stable = lhs.map(_ => [sortedIndex[0][0], 0]);
-        let found = false;
-        for (let i = 1; i < input.length; i++) {
-            const [currIndex, _] = sortedIndex[i];
-            const arr = input[currIndex];
-            if (!rmap.has(i))
-                rmap.set(i, buildHashIndex(arr));
-            // we found a match. let's confirm.
-            if (rmap.get(i).has(k)) {
-                const rhs = rmap
-                    .get(i)
-                    .get(k)
-                    .map(j => arr[j]);
-                // confirm the intersection with an equivalence check.
-                found = lhs
-                    .map((s, n) => rhs.some((t, m) => {
-                    // we expect only one to match here since these are just collisions.
-                    const p = res[n];
-                    if (isEqual(s, t)) {
-                        res[n]++;
-                        // track position of value ordering for stability.
-                        if (currIndex < stable[n][0]) {
-                            stable[n] = [currIndex, rmap.get(i).get(k)[m]];
-                        }
-                    }
-                    return p < res[n];
-                }))
-                    .some(Boolean);
-            }
-            // found nothing, so exclude value. this was just a hash collision.
-            if (!found)
-                return;
-        }
-        // extract value into result if we found an intersection.
-        // we find an intersection if the frequency counter matches the count of the remaining arrays.
-        if (found) {
-            into(results, res
-                .map((n, i) => {
-                return n === input.length - 1 ? [lhs[i], stable[i]] : MISSING;
-            })
-                .filter(n => n !== MISSING));
-        }
+  const vmaps = [ValueMap.init(hashFunction), ValueMap.init(hashFunction)];
+  if (input.length === 0) return [];
+  if (input.some((arr) => arr.length === 0)) return [];
+  if (input.length === 1) return [...input];
+  input[input.length - 1].forEach((v) => vmaps[0].set(v, true));
+  for (let i = input.length - 2; i > -1; i--) {
+    input[i].forEach((v) => {
+      if (vmaps[0].has(v)) vmaps[1].set(v, true);
     });
-    return results
-        .sort((a, b) => {
-        const [_i, [u, m]] = a;
-        const [_j, [v, n]] = b;
-        const r = (0, exports.compare)(u, v);
-        if (r !== 0)
-            return r;
-        return (0, exports.compare)(m, n);
-    })
-        .map(v => v[0]);
-}
-exports.intersection = intersection;
-/**
- * Flatten the array
- *
- * @param {Array} xs The array to flatten
- * @param {Number} depth The number of nested lists to iterate
- */
-function flatten(xs, depth = 0) {
-    const arr = new Array();
-    function flatten2(ys, n) {
-        for (let i = 0, len = ys.length; i < len; i++) {
-            if ((0, exports.isArray)(ys[i]) && (n > 0 || n < 0)) {
-                flatten2(ys[i], Math.max(-1, n - 1));
-            }
-            else {
-                arr.push(ys[i]);
-            }
-        }
+    if (vmaps[1].size === 0) return [];
+    vmaps.reverse();
+    vmaps[1].clear();
+  }
+  return Array.from(vmaps[0].keys());
+}
+function flatten(xs, depth = 1) {
+  const arr = new Array();
+  function flatten2(ys, n) {
+    for (let i = 0, len = ys.length; i < len; i++) {
+      if (isArray(ys[i]) && (n > 0 || n < 0)) {
+        flatten2(ys[i], Math.max(-1, n - 1));
+      } else {
+        arr.push(ys[i]);
+      }
     }
-    flatten2(xs, depth);
-    return arr;
+  }
+  flatten2(xs, depth);
+  return arr;
 }
-exports.flatten = flatten;
-/**
- * Determine whether two values are the same or strictly equivalent
- *
- * @param  {*}  a The first value
- * @param  {*}  b The second value
- * @return {Boolean}   Result of comparison
- */
 function isEqual(a, b) {
-    const lhs = [a];
-    const rhs = [b];
-    while (lhs.length > 0) {
-        a = lhs.pop();
-        b = rhs.pop();
-        // strictly equal must be equal.
-        if (a === b)
-            continue;
-        // unequal types and functions cannot be equal.
-        const nativeType = (0, exports.getType)(a).toLowerCase();
-        if (nativeType !== (0, exports.getType)(b).toLowerCase() || nativeType === "function") {
-            return false;
-        }
-        // leverage toString for Date and RegExp types
-        if (nativeType === "array") {
-            const xs = a;
-            const ys = b;
-            if (xs.length !== ys.length)
-                return false;
-            if (xs.length === ys.length && xs.length === 0)
-                continue;
-            into(lhs, xs);
-            into(rhs, ys);
-        }
-        else if (nativeType === "object") {
-            // deep compare objects
-            const aKeys = Object.keys(a);
-            const bKeys = Object.keys(b);
-            // check length of keys early
-            if (aKeys.length !== bKeys.length)
-                return false;
-            // compare keys
-            for (let i = 0, len = aKeys.length; i < len; i++) {
-                const k = aKeys[i];
-                // not found
-                if (!(0, exports.has)(b, k))
-                    return false;
-                // key found
-                lhs.push(a[k]);
-                rhs.push(b[k]);
-            }
-        }
-        else {
-            // compare encoded values
-            if (stringify(a) !== stringify(b))
-                return false;
-        }
-    }
-    return lhs.length === 0;
+  if (a === b || Object.is(a, b)) return true;
+  const ctor = !!a && a.constructor || a;
+  if (a === null || b === null || a === void 0 || b === void 0 || ctor !== b.constructor || ctor === Function) {
+    return false;
+  }
+  if (ctor === Array || ctor === Object) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length) return false;
+    for (const k of aKeys) if (!isEqual(a[k], b[k])) return false;
+    return true;
+  }
+  const proto = getPrototypeOf(a);
+  const cmp = isTypedArray(a) || proto !== objectProto && proto !== arrayProto && has(proto, "toString");
+  return cmp && a.toString() === b.toString();
 }
-exports.isEqual = isEqual;
-/**
- * Return a new unique version of the collection
- * @param  {Array} input The input collection
- * @return {Array}
- */
 function unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {
-    const result = input.map(_ => MISSING);
-    buildHashIndex(input, hashFunction).forEach((v, _) => {
-        v.forEach(i => (result[i] = input[i]));
-    });
-    return result.filter(v => v !== MISSING);
-}
-exports.unique = unique;
-/**
- * Encode value to string using a simple non-colliding stable scheme.
- *
- * @param value
- * @returns {*}
- */
-function stringify(value) {
-    const type = (0, exports.getType)(value).toLowerCase();
-    switch (type) {
-        case "boolean":
-        case "number":
-        case "regexp":
-            return value.toString();
-        case "string":
-            return JSON.stringify(value);
-        case "date":
-            return value.toISOString();
-        case "null":
-        case "undefined":
-            return type;
-        case "array":
-            return "[" + value.map(stringify).join(",") + "]";
-        default:
-            break;
+  const m = ValueMap.init(hashFunction);
+  input.forEach((v) => m.set(v, true));
+  return Array.from(m.keys());
+}
+const stringify = (v, refs) => {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (isString(v) || isNumber(v) || isBoolean(v)) return JSON.stringify(v);
+  if (isDate(v)) return v.toISOString();
+  if (isRegExp(v) || isSymbol(v) || isFunction(v))
+    return v.toString();
+  if (isTypedArray(v))
+    return typeOf(v) + "[" + v.toString() + "]";
+  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();
+  if (refs.has(v)) throw CYCLE_FOUND_ERROR;
+  try {
+    refs.add(v);
+    if (isArray(v)) return "[" + v.map((s) => stringify(s, refs)).join(",") + "]";
+    if (isObject(v)) {
+      const keys = Object.keys(v).sort();
+      return "{" + keys.map((k) => `${k}:${stringify(v[k], refs)}`).join() + "}";
     }
-    // default case
-    const prefix = type === "object" ? "" : `${(0, exports.getType)(value)}`;
-    const objKeys = Object.keys(value);
-    objKeys.sort();
-    return (`${prefix}{` +
-        objKeys
-            .map(k => `${stringify(k)}:${stringify(value[k])}`)
-            .join(",") +
-        "}");
-}
-exports.stringify = stringify;
-/**
- * Generate hash code
- * This selected function is the result of benchmarking various hash functions.
- * This version performs well and can hash 10^6 documents in ~3s with on average 100 collisions.
- *
- * @param value
- * @returns {number|null}
- */
-function hashCode(value, hashFunction) {
-    hashFunction = hashFunction || DEFAULT_HASH_FUNCTION;
-    if ((0, exports.isNil)(value))
-        return null;
-    return hashFunction(value).toString();
-}
-exports.hashCode = hashCode;
-/**
- * Returns a (stably) sorted copy of list, ranked in ascending order by the results of running each value through iteratee
- *
- * This implementation treats null/undefined sort keys as less than every other type
- *
- * @param {Array}   collection
- * @param {Function} keyFn The sort key function used to resolve sort keys
- * @param {Function} comparator The comparator function to use for comparing keys. Defaults to standard comparison via `compare(...)`
- * @return {Array} Returns a new sorted array by the given key and comparator function
- */
-function sortBy(collection, keyFn, comparator = exports.compare) {
-    if ((0, exports.isEmpty)(collection))
-        return collection;
-    const sorted = new Array();
-    const result = new Array();
-    for (let i = 0; i < collection.length; i++) {
-        const obj = collection[i];
-        const key = keyFn(obj, i);
-        if ((0, exports.isNil)(key)) {
-            result.push(obj);
-        }
-        else {
-            sorted.push([key, obj]);
-        }
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== objectProto && proto !== arrayProto && has(proto, "toString")) {
+      return typeOf(v) + "(" + JSON.stringify(v.toString()) + ")";
     }
-    // use native array sorting but enforce stableness
-    sorted.sort((a, b) => comparator(a[0], b[0]));
-    return into(result, sorted.map((o) => o[1]));
+    throw new Error(
+      "mingo: cannot stringify custom type without explicit toString() method."
+    );
+  } finally {
+    refs.delete(v);
+  }
+};
+function hashCode(value, hashFunction) {
+  if (isNil(value)) return null;
+  hashFunction = hashFunction || DEFAULT_HASH_FUNCTION;
+  return hashFunction(value);
 }
-exports.sortBy = sortBy;
-/**
- * Groups the collection into sets by the returned key
- *
- * @param collection
- * @param keyFn {Function} to compute the group key of an item in the collection
- * @returns {GroupByOutput}
- */
 function groupBy(collection, keyFn, hashFunction = DEFAULT_HASH_FUNCTION) {
-    if (collection.length < 1)
-        return new Map();
-    // map of hash to collided values
-    const lookup = new Map();
-    // map of raw key values to objects.
-    const result = new Map();
-    for (let i = 0; i < collection.length; i++) {
-        const obj = collection[i];
-        const key = keyFn(obj, i);
-        const hash = hashCode(key, hashFunction);
-        if (hash === null) {
-            if (result.has(null)) {
-                result.get(null).push(obj);
-            }
-            else {
-                result.set(null, [obj]);
-            }
-        }
-        else {
-            // find if we can match a hash for which the value is equivalent.
-            // this is used to deal with collisions.
-            const existingKey = lookup.has(hash)
-                ? lookup.get(hash).find(k => isEqual(k, key))
-                : null;
-            // collision detected or first time seeing key
-            if ((0, exports.isNil)(existingKey)) {
-                // collision detected or first entry so we create a new group.
-                result.set(key, [obj]);
-                // upload the lookup with the collided key
-                if (lookup.has(hash)) {
-                    lookup.get(hash).push(key);
-                }
-                else {
-                    lookup.set(hash, [key]);
-                }
-            }
-            else {
-                // key exists
-                result.get(existingKey).push(obj);
-            }
+  if (collection.length < 1) return /* @__PURE__ */ new Map();
+  const lookup = /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < collection.length; i++) {
+    const obj = collection[i];
+    const key = keyFn(obj, i);
+    const hash = hashCode(key, hashFunction);
+    if (hash === null) {
+      if (result.has(null)) {
+        result.get(null).push(obj);
+      } else {
+        result.set(null, [obj]);
+      }
+    } else {
+      const existingKey = lookup.has(hash) ? lookup.get(hash).find((k) => isEqual(k, key)) : null;
+      if (isNil(existingKey)) {
+        result.set(key, [obj]);
+        if (lookup.has(hash)) {
+          lookup.get(hash).push(key);
+        } else {
+          lookup.set(hash, [key]);
         }
+      } else {
+        result.get(existingKey).push(obj);
+      }
     }
-    return result;
+  }
+  return result;
 }
-exports.groupBy = groupBy;
-// max elements to push.
-// See argument limit https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply
-const MAX_ARRAY_PUSH = 50000;
-/**
- * Merge elements into the dest
- *
- * @param {*} target The target object
- * @param {*} rest The array of elements to merge into dest
- */
+const MAX_ARRAY_PUSH = 5e4;
 function into(target, ...rest) {
-    if (target instanceof Array) {
-        return rest.reduce(((acc, arr) => {
-            // push arrary in batches to handle large inputs
-            let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);
-            let begin = 0;
-            while (i-- > 0) {
-                Array.prototype.push.apply(acc, arr.slice(begin, begin + MAX_ARRAY_PUSH));
-                begin += MAX_ARRAY_PUSH;
-            }
-            return acc;
-        }), target);
-    }
-    else {
-        // merge objects. same behaviour as Object.assign
-        return rest.filter(exports.isObjectLike).reduce((acc, item) => {
-            Object.assign(acc, item);
-            return acc;
-        }, target);
+  if (isArray(target)) {
+    for (const arr of rest) {
+      let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);
+      let begin = 0;
+      while (i-- > 0) {
+        Array.prototype.push.apply(
+          target,
+          arr.slice(begin, begin + MAX_ARRAY_PUSH)
+        );
+        begin += MAX_ARRAY_PUSH;
+      }
     }
+    return target;
+  } else {
+    return rest.filter(isObjectLike).reduce((acc, item) => {
+      Object.assign(acc, item);
+      return acc;
+    }, target);
+  }
 }
-exports.into = into;
-/**
- * This is a generic memoization function
- *
- * This implementation uses a cache independent of the function being memoized
- * to allow old values to be garbage collected when the memoized function goes out of scope.
- *
- * @param {*} fn The function object to memoize
- */
-function memoize(fn, hashFunction = DEFAULT_HASH_FUNCTION) {
-    return ((memo) => {
-        return (...args) => {
-            const key = hashCode(args, hashFunction) || "";
-            if (!(0, exports.has)(memo, key)) {
-                memo[key] = fn.apply(this, args);
-            }
-            return memo[key];
-        };
-    })({
-    /* storage */
-    });
-}
-exports.memoize = memoize;
-// mingo internal
-/**
- * Retrieve the value of a given key on an object
- * @param obj
- * @param key
- * @returns {*}
- * @private
- */
 function getValue(obj, key) {
-    return (0, exports.isObjectLike)(obj) ? obj[key] : undefined;
+  return isArray(obj) || isObject(obj) ? obj[key] : void 0;
 }
-/**
- * Unwrap a single element array to specified depth
- * @param {Array} arr
- * @param {Number} depth
- */
 function unwrap(arr, depth) {
-    if (depth < 1)
-        return arr;
-    while (depth-- && arr.length === 1)
-        arr = arr[0];
-    return arr;
+  if (depth < 1) return arr;
+  while (depth-- && arr.length === 1) arr = arr[0];
+  return arr;
 }
-/**
- * Resolve the value of the field (dot separated) on the given object
- * @param obj {Object} the object context
- * @param selector {String} dot separated path to field
- * @returns {*}
- */
 function resolve(obj, selector, options) {
-    let depth = 0;
-    function resolve2(o, path) {
-        let value = o;
-        for (let i = 0; i < path.length; i++) {
-            const field = path[i];
-            const isText = /^\d+$/.exec(field) === null;
-            // using instanceof to aid typescript compiler
-            if (isText && value instanceof Array) {
-                // On the first iteration, we check if we received a stop flag.
-                // If so, we stop to prevent iterating over a nested array value
-                // on consecutive object keys in the selector.
-                if (i === 0 && depth > 0)
-                    break;
-                depth += 1;
-                // only look at the rest of the path
-                const subpath = path.slice(i);
-                value = value.reduce((acc, item) => {
-                    const v = resolve2(item, subpath);
-                    if (v !== undefined)
-                        acc.push(v);
-                    return acc;
-                }, []);
-                break;
-            }
-            else {
-                value = getValue(value, field);
-            }
-            if (value === undefined)
-                break;
-        }
-        return value;
+  let depth = 0;
+  function resolve2(o, path) {
+    let value = o;
+    for (let i = 0; i < path.length; i++) {
+      const field = path[i];
+      const isText = /^\d+$/.exec(field) === null;
+      if (isText && isArray(value)) {
+        if (i === 0 && depth > 0) break;
+        depth += 1;
+        const subpath = path.slice(i);
+        value = value.reduce((acc, item) => {
+          const v = resolve2(item, subpath);
+          if (v !== void 0) acc.push(v);
+          return acc;
+        }, []);
+        break;
+      } else {
+        value = getValue(value, field);
+      }
+      if (value === void 0) break;
     }
-    const result = JS_SIMPLE_TYPES.has((0, exports.getType)(obj).toLowerCase())
-        ? obj
-        : resolve2(obj, selector.split("."));
-    return result instanceof Array && (options === null || options === void 0 ? void 0 : options.unwrapArray)
-        ? unwrap(result, depth)
-        : result;
+    return value;
+  }
+  const res = isScalar(obj) ? obj : resolve2(obj, selector.split("."));
+  return isArray(res) && options?.unwrapArray ? unwrap(res, depth) : res;
 }
-exports.resolve = resolve;
-/**
- * Returns the full object to the resolved value given by the selector.
- * This function excludes empty values as they aren't practically useful.
- *
- * @param obj {Object} the object context
- * @param selector {String} dot separated path to field
- */
 function resolveGraph(obj, selector, options) {
-    const names = selector.split(".");
-    const key = names[0];
-    // get the next part of the selector
-    const next = names.slice(1).join(".");
-    const isIndex = /^\d+$/.exec(key) !== null;
-    const hasNext = names.length > 1;
-    let result;
-    let value;
-    if (obj instanceof Array) {
-        if (isIndex) {
-            result = getValue(obj, Number(key));
-            if (hasNext) {
-                result = resolveGraph(result, next, options);
-            }
-            result = [result];
-        }
-        else {
-            result = [];
-            for (const item of obj) {
-                value = resolveGraph(item, selector, options);
-                if (options === null || options === void 0 ? void 0 : options.preserveMissing) {
-                    if (value === undefined) {
-                        value = MISSING;
-                    }
-                    result.push(value);
-                }
-                else if (value !== undefined) {
-                    result.push(value);
-                }
-            }
-        }
-    }
-    else {
-        value = getValue(obj, key);
-        if (hasNext) {
-            value = resolveGraph(value, next, options);
+  const sep = selector.indexOf(".");
+  const key = sep == -1 ? selector : selector.substring(0, sep);
+  const next = selector.substring(sep + 1);
+  const hasNext = sep != -1;
+  if (isArray(obj)) {
+    const isIndex = /^\d+$/.test(key);
+    const arr = isIndex && options?.preserveIndex ? [...obj] : [];
+    if (isIndex) {
+      const index = parseInt(key);
+      let value2 = getValue(obj, index);
+      if (hasNext) {
+        value2 = resolveGraph(value2, next, options);
+      }
+      if (options?.preserveIndex) {
+        arr[index] = value2;
+      } else {
+        arr.push(value2);
+      }
+    } else {
+      for (const item of obj) {
+        const value2 = resolveGraph(item, selector, options);
+        if (options?.preserveMissing) {
+          arr.push(value2 == void 0 ? MISSING : value2);
+        } else if (value2 != void 0 || options?.preserveIndex) {
+          arr.push(value2);
         }
-        if (value === undefined)
-            return undefined;
-        result = (options === null || options === void 0 ? void 0 : options.preserveKeys) ? Object.assign({}, obj) : {};
-        result[key] = value;
+      }
     }
-    return result;
+    return arr;
+  }
+  const res = options?.preserveKeys ? { ...obj } : {};
+  let value = getValue(obj, key);
+  if (hasNext) {
+    value = resolveGraph(value, next, options);
+  }
+  if (value === void 0) return void 0;
+  res[key] = value;
+  return res;
 }
-exports.resolveGraph = resolveGraph;
-/**
- * Filter out all MISSING values from the object in-place
- *
- * @param obj The object to filter
- */
 function filterMissing(obj) {
-    if (obj instanceof Array) {
-        for (let i = obj.length - 1; i >= 0; i--) {
-            if (obj[i] === MISSING) {
-                obj.splice(i, 1);
-            }
-            else {
-                filterMissing(obj[i]);
-            }
-        }
+  if (isArray(obj)) {
+    for (let i = obj.length - 1; i >= 0; i--) {
+      if (obj[i] === MISSING) {
+        obj.splice(i, 1);
+      } else {
+        filterMissing(obj[i]);
+      }
     }
-    else if ((0, exports.isObject)(obj)) {
-        for (const k in obj) {
-            if ((0, exports.has)(obj, k)) {
-                filterMissing(obj[k]);
-            }
-        }
+  } else if (isObject(obj)) {
+    for (const k in obj) {
+      if (has(obj, k)) {
+        filterMissing(obj[k]);
+      }
     }
+  }
 }
-exports.filterMissing = filterMissing;
 const NUMBER_RE = /^\d+$/;
-/**
- * Walk the object graph and execute the given transform function
- *
- * @param  {Object|Array} obj   The object to traverse.
- * @param  {String} selector    The selector to navigate.
- * @param  {Callback} fn Callback to execute for value at the end the traversal.
- * @param  {WalkOptions} Options to use for the function.
- * @return {*}
- */
 function walk(obj, selector, fn, options) {
-    const names = selector.split(".");
-    const key = names[0];
-    const next = names.slice(1).join(".");
-    if (names.length === 1) {
-        if ((0, exports.isObject)(obj) || ((0, exports.isArray)(obj) && NUMBER_RE.test(key))) {
-            fn(obj, key);
-        }
+  const names = selector.split(".");
+  const key = names[0];
+  const next = names.slice(1).join(".");
+  if (names.length === 1) {
+    if (isObject(obj) || isArray(obj) && NUMBER_RE.test(key)) {
+      fn(obj, key);
     }
-    else {
-        // force the rest of the graph while traversing
-        if ((options === null || options === void 0 ? void 0 : options.buildGraph) && (0, exports.isNil)(obj[key])) {
-            obj[key] = {};
-        }
-        // get the next item
-        const item = obj[key];
-        // nothing more to do
-        if (!item)
-            return;
-        // we peek to see if next key is an array index.
-        const isNextArrayIndex = !!(names.length > 1 && NUMBER_RE.test(names[1]));
-        // if we have an array value but the next key is not an index and the 'descendArray' option is set,
-        // we walk each item in the array separately. This allows for handling traversing keys for objects
-        // nested within an array.
-        //
-        // Eg: Given { array: [ {k:1}, {k:2}, {k:3} ] }
-        //  - individual objecs can be traversed with "array.k"
-        //  - a specific object can be traversed with "array.1"
-        if (item instanceof Array && (options === null || options === void 0 ? void 0 : options.descendArray) && !isNextArrayIndex) {
-            item.forEach(((e) => walk(e, next, fn, options)));
-        }
-        else {
-            walk(item, next, fn, options);
-        }
+  } else {
+    if (options?.buildGraph && isNil(obj[key])) {
+      obj[key] = {};
+    }
+    const item = obj[key];
+    if (!item) return;
+    const isNextArrayIndex = !!(names.length > 1 && NUMBER_RE.test(names[1]));
+    if (isArray(item) && options?.descendArray && !isNextArrayIndex) {
+      item.forEach((e) => walk(e, next, fn, options));
+    } else {
+      walk(item, next, fn, options);
     }
+  }
 }
-exports.walk = walk;
-/**
- * Set the value of the given object field
- *
- * @param obj {Object|Array} the object context
- * @param selector {String} path to field
- * @param value {*} the value to set
- */
 function setValue(obj, selector, value) {
-    walk(obj, selector, ((item, key) => {
-        item[key] = value;
-    }), { buildGraph: true });
+  walk(
+    obj,
+    selector,
+    (item, key) => {
+      item[key] = isFunction(value) ? value(item[key]) : value;
+    },
+    { buildGraph: true }
+  );
 }
-exports.setValue = setValue;
-/**
- * Removes an element from the container.
- * If the selector resolves to an array and the leaf is a non-numeric key,
- * the remove operation will be performed on objects of the array.
- *
- * @param obj {ArrayOrObject} object or array
- * @param selector {String} dot separated path to element to remove
- */
 function removeValue(obj, selector, options) {
-    walk(obj, selector, ((item, key) => {
-        if (item instanceof Array) {
-            if (/^\d+$/.test(key)) {
-                item.splice(parseInt(key), 1);
+  walk(
+    obj,
+    selector,
+    (item, key) => {
+      if (isArray(item)) {
+        if (/^\d+$/.test(key)) {
+          item.splice(parseInt(key), 1);
+        } else if (options && options.descendArray) {
+          for (const elem of item) {
+            if (isObject(elem)) {
+              delete elem[key];
             }
-            else if (options && options.descendArray) {
-                for (const elem of item) {
-                    if ((0, exports.isObject)(elem)) {
-                        delete elem[key];
-                    }
-                }
-            }
-        }
-        else if ((0, exports.isObject)(item)) {
-            delete item[key];
+          }
         }
-    }), options);
+      } else if (isObject(item)) {
+        delete item[key];
+      }
+    },
+    options
+  );
 }
-exports.removeValue = removeValue;
 const OPERATOR_NAME_PATTERN = /^\$[a-zA-Z0-9_]+$/;
-/**
- * Check whether the given name passes for an operator. We assume AnyVal field name starting with '$' is an operator.
- * This is cheap and safe to do since keys beginning with '$' should be reserved for internal use.
- * @param {String} name
- */
 function isOperator(name) {
-    return OPERATOR_NAME_PATTERN.test(name);
+  return OPERATOR_NAME_PATTERN.test(name);
 }
-exports.isOperator = isOperator;
-/**
- * Simplify expression for easy evaluation with query operators map
- * @param expr
- * @returns {*}
- */
 function normalize(expr) {
-    // normalized primitives
-    if (JS_SIMPLE_TYPES.has((0, exports.getType)(expr).toLowerCase())) {
-        return (0, exports.isRegExp)(expr) ? { $regex: expr } : { $eq: expr };
-    }
-    // normalize object expression. using ObjectLike handles custom types
-    if ((0, exports.isObjectLike)(expr)) {
-        const exprObj = expr;
-        // no valid query operator found, so we do simple comparison
-        if (!Object.keys(exprObj).some(isOperator)) {
-            return { $eq: expr };
-        }
-        // ensure valid regex
-        if ((0, exports.has)(expr, "$regex")) {
-            return {
-                $regex: new RegExp(exprObj["$regex"], exprObj["$options"])
-            };
-        }
+  if (isScalar(expr)) {
+    return isRegExp(expr) ? { $regex: expr } : { $eq: expr };
+  }
+  if (isObjectLike(expr)) {
+    if (!Object.keys(expr).some(isOperator)) return { $eq: expr };
+    if (has(expr, "$regex")) {
+      const newExpr = { ...expr };
+      newExpr["$regex"] = new RegExp(
+        expr["$regex"],
+        expr["$options"]
+      );
+      delete newExpr["$options"];
+      return newExpr;
+    }
+  }
+  return expr;
+}
+function findInsertIndex(sorted, item, comparator = compare) {
+  let lo = 0;
+  let hi = sorted.length - 1;
+  while (lo <= hi) {
+    const mid = Math.round(lo + (hi - lo) / 2);
+    if (comparator(item, sorted[mid]) < 0) {
+      hi = mid - 1;
+    } else if (comparator(item, sorted[mid]) > 0) {
+      lo = mid + 1;
+    } else {
+      return mid;
     }
-    return expr;
+  }
+  return lo;
 }
-exports.normalize = normalize;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
 
-/***/ 3689:
+/***/ 7444:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -31533,7 +36016,7 @@ const punycode = {
 	 * @memberOf punycode
 	 * @type String
 	 */
-	'version': '2.1.0',
+	'version': '2.3.1',
 	/**
 	 * An object of methods to convert from JavaScript's internal character
 	 * representation (UCS-2) to Unicode code points, and back.
@@ -31557,60 +36040,38 @@ const punycode = {
 
 /***/ }),
 
-/***/ 9413:
-/***/ ((module) => {
-
-module.exports=/[\0-\x1F\x7F-\x9F]/
-
-/***/ }),
-
-/***/ 2326:
-/***/ ((module) => {
-
-module.exports=/[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/
-
-/***/ }),
-
-/***/ 3189:
-/***/ ((module) => {
-
-module.exports=/[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/
-
-/***/ }),
-
-/***/ 5045:
-/***/ ((module) => {
+/***/ 3492:
+/***/ ((__unused_webpack_module, exports) => {
 
-module.exports=/[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/
+"use strict";
 
-/***/ }),
 
-/***/ 4205:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+var regex$5 = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
 
-"use strict";
+var regex$4 = /[\0-\x1F\x7F-\x9F]/;
 
+var regex$3 = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u0890\u0891\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC3F]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
 
-exports.Any = __webpack_require__(9369);
-exports.Cc = __webpack_require__(9413);
-exports.Cf = __webpack_require__(2326);
-exports.P = __webpack_require__(3189);
-exports.Z = __webpack_require__(5045);
+var regex$2 = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59\uDF86-\uDF89]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDEB9\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2\uDF00-\uDF09]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDF43-\uDF4F\uDFFF]|\uD809[\uDC70-\uDC74]|\uD80B[\uDFF1\uDFF2]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
 
+var regex$1 = /[\$\+<->\^`\|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u0888\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20C0\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u31EF\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC2\uFD40-\uFD4F\uFDCF\uFDFC-\uFDFF\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD833[\uDF50-\uDFC3]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDEA\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEDC-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF76\uDF7B-\uDFD9\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDE53\uDE60-\uDE6D\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC5\uDECE-\uDEDB\uDEE0-\uDEE8\uDEF0-\uDEF8\uDF00-\uDF92\uDF94-\uDFCA]/;
 
-/***/ }),
+var regex = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
 
-/***/ 9369:
-/***/ ((module) => {
+exports.Any = regex$5;
+exports.Cc = regex$4;
+exports.Cf = regex$3;
+exports.P = regex$2;
+exports.S = regex$1;
+exports.Z = regex;
 
-module.exports=/[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
 
 /***/ }),
 
-/***/ 1201:
+/***/ 2008:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const State = __webpack_require__(5213);
+const State = __webpack_require__(9421);
 
 /**
  * @namespace History
@@ -31732,10 +36193,10 @@ module.exports = History;
 
 /***/ }),
 
-/***/ 9456:
+/***/ 3199:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const md = __webpack_require__(9980)({
+const md = __webpack_require__(383)({
   html: true, // Enable HTML tags in source
   xhtmlOut: true, // Use '/' to close single tags (<br />).
   breaks: true // Convert \n into <br />
@@ -31796,7 +36257,7 @@ module.exports = Markdown;
 
 /***/ }),
 
-/***/ 1067:
+/***/ 3204:
 /***/ ((module) => {
 
 /**
@@ -31834,10 +36295,10 @@ module.exports = Passage;
 
 /***/ }),
 
-/***/ 1675:
+/***/ 9990:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const $ = __webpack_require__(9755);
+const $ = __webpack_require__(4692);
 
 class Screen {
   /**
@@ -31864,13 +36325,13 @@ module.exports = Screen;
 
 /***/ }),
 
-/***/ 5827:
+/***/ 5465:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const ejs = __webpack_require__(7083);
-const History = __webpack_require__(1201);
-const Screen = __webpack_require__(1675);
-const Utilities = __webpack_require__(5543);
+const ejs = __webpack_require__(4155);
+const History = __webpack_require__(2008);
+const Screen = __webpack_require__(9990);
+const Utilities = __webpack_require__(5072);
 
 /**
  * @external Story
@@ -31934,11 +36395,11 @@ module.exports = Script;
 
 /***/ }),
 
-/***/ 2879:
+/***/ 7936:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const $ = __webpack_require__(9755);
-const State = __webpack_require__(5213);
+const $ = __webpack_require__(4692);
+const State = __webpack_require__(9421);
 
 class Sidebar {
   constructor () {
@@ -32048,10 +36509,10 @@ module.exports = Sidebar;
 
 /***/ }),
 
-/***/ 5213:
+/***/ 9421:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const EventEmitter = __webpack_require__(7187);
+const EventEmitter = __webpack_require__(7007);
 
 const handler = {
   get: (target, property) => {
@@ -32118,11 +36579,11 @@ module.exports = State;
 
 /***/ }),
 
-/***/ 6505:
+/***/ 3325:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const History = __webpack_require__(1201);
-const State = __webpack_require__(5213);
+const History = __webpack_require__(2008);
+const State = __webpack_require__(9421);
 
 class Storage {
   /**
@@ -32215,9 +36676,8 @@ class Storage {
       window.localStorage.setItem('testKey', 'test');
       window.localStorage.removeItem('testKey');
       result = true;
-    } catch (e) {
-      // If an error was thrown, we do nothing.
-      // The method will return false if it did not work.
+    } catch(error) {
+      console.info('Info: localStorage is not available. Error:', error);
     }
 
     // Return result
@@ -32249,23 +36709,23 @@ module.exports = Storage;
 
 /***/ }),
 
-/***/ 3213:
+/***/ 2577:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 /**
  * @external Element
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Element}
  */
-const $ = __webpack_require__(9755);
-const Passage = __webpack_require__(1067);
-const Markdown = __webpack_require__(9456);
-const State = __webpack_require__(5213);
-const History = __webpack_require__(1201);
-const Storylets = __webpack_require__(2444);
-const Script = __webpack_require__(5827);
-const Sidebar = __webpack_require__(2879);
-const Screen = __webpack_require__(1675);
-const Storage = __webpack_require__(6505);
+const $ = __webpack_require__(4692);
+const Passage = __webpack_require__(3204);
+const Markdown = __webpack_require__(3199);
+const State = __webpack_require__(9421);
+const History = __webpack_require__(2008);
+const Storylets = __webpack_require__(9715);
+const Script = __webpack_require__(5465);
+const Sidebar = __webpack_require__(7936);
+const Screen = __webpack_require__(9990);
+const Storage = __webpack_require__(3325);
 
 /**
  * An object representing the entire story. After the document has completed
@@ -32739,11 +37199,11 @@ module.exports = Story;
 
 /***/ }),
 
-/***/ 2444:
+/***/ 9715:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const { Query } = __webpack_require__(6090);
-const State = __webpack_require__(5213);
+const { Query } = __webpack_require__(8543);
+const State = __webpack_require__(9421);
 
 /**
  * An object containing none, one, or multiple passages based
@@ -32774,7 +37234,8 @@ class Storylets {
           try {
             // Try to parse string into object
             passageRequirements = JSON.parse(captured);
-          } catch (e) {
+          } catch (error) {
+            console.info('INFO: Failed to parse passage requirements. Error:', error);
             // Ignore the error
           }
 
@@ -32930,10 +37391,10 @@ module.exports = Storylets;
 
 /***/ }),
 
-/***/ 5543:
+/***/ 5072:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const $ = __webpack_require__(9755);
+const $ = __webpack_require__(4692);
 
 class Utilities {
   /**
@@ -33034,33 +37495,25 @@ module.exports = Utilities;
 
 /***/ }),
 
-/***/ 7790:
+/***/ 7280:
 /***/ (() => {
 
 /* (ignored) */
 
 /***/ }),
 
-/***/ 5272:
+/***/ 7024:
 /***/ (() => {
 
 /* (ignored) */
 
 /***/ }),
 
-/***/ 3558:
-/***/ ((module) => {
-
-"use strict";
-module.exports = {"i8":"3.1.9"};
-
-/***/ }),
-
-/***/ 9323:
+/***/ 3840:
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"Aacute":"Á","aacute":"á","Abreve":"Ă","abreve":"ă","ac":"∾","acd":"∿","acE":"∾̳","Acirc":"Â","acirc":"â","acute":"´","Acy":"А","acy":"а","AElig":"Æ","aelig":"æ","af":"⁡","Afr":"𝔄","afr":"𝔞","Agrave":"À","agrave":"à","alefsym":"ℵ","aleph":"ℵ","Alpha":"Α","alpha":"α","Amacr":"Ā","amacr":"ā","amalg":"⨿","amp":"&","AMP":"&","andand":"⩕","And":"⩓","and":"∧","andd":"⩜","andslope":"⩘","andv":"⩚","ang":"∠","ange":"⦤","angle":"∠","angmsdaa":"⦨","angmsdab":"⦩","angmsdac":"⦪","angmsdad":"⦫","angmsdae":"⦬","angmsdaf":"⦭","angmsdag":"⦮","angmsdah":"⦯","angmsd":"∡","angrt":"∟","angrtvb":"⊾","angrtvbd":"⦝","angsph":"∢","angst":"Å","angzarr":"⍼","Aogon":"Ą","aogon":"ą","Aopf":"𝔸","aopf":"𝕒","apacir":"⩯","ap":"≈","apE":"⩰","ape":"≊","apid":"≋","apos":"\'","ApplyFunction":"⁡","approx":"≈","approxeq":"≊","Aring":"Å","aring":"å","Ascr":"𝒜","ascr":"𝒶","Assign":"≔","ast":"*","asymp":"≈","asympeq":"≍","Atilde":"Ã","atilde":"ã","Auml":"Ä","auml":"ä","awconint":"∳","awint":"⨑","backcong":"≌","backepsilon":"϶","backprime":"‵","backsim":"∽","backsimeq":"⋍","Backslash":"∖","Barv":"⫧","barvee":"⊽","barwed":"⌅","Barwed":"⌆","barwedge":"⌅","bbrk":"⎵","bbrktbrk":"⎶","bcong":"≌","Bcy":"Б","bcy":"б","bdquo":"„","becaus":"∵","because":"∵","Because":"∵","bemptyv":"⦰","bepsi":"϶","bernou":"ℬ","Bernoullis":"ℬ","Beta":"Β","beta":"β","beth":"ℶ","between":"≬","Bfr":"𝔅","bfr":"𝔟","bigcap":"⋂","bigcirc":"◯","bigcup":"⋃","bigodot":"⨀","bigoplus":"⨁","bigotimes":"⨂","bigsqcup":"⨆","bigstar":"★","bigtriangledown":"▽","bigtriangleup":"△","biguplus":"⨄","bigvee":"⋁","bigwedge":"⋀","bkarow":"⤍","blacklozenge":"⧫","blacksquare":"▪","blacktriangle":"▴","blacktriangledown":"▾","blacktriangleleft":"◂","blacktriangleright":"▸","blank":"␣","blk12":"▒","blk14":"░","blk34":"▓","block":"█","bne":"=⃥","bnequiv":"≡⃥","bNot":"⫭","bnot":"⌐","Bopf":"𝔹","bopf":"𝕓","bot":"⊥","bottom":"⊥","bowtie":"⋈","boxbox":"⧉","boxdl":"┐","boxdL":"╕","boxDl":"╖","boxDL":"╗","boxdr":"┌","boxdR":"╒","boxDr":"╓","boxDR":"╔","boxh":"─","boxH":"═","boxhd":"┬","boxHd":"╤","boxhD":"╥","boxHD":"╦","boxhu":"┴","boxHu":"╧","boxhU":"╨","boxHU":"╩","boxminus":"⊟","boxplus":"⊞","boxtimes":"⊠","boxul":"┘","boxuL":"╛","boxUl":"╜","boxUL":"╝","boxur":"└","boxuR":"╘","boxUr":"╙","boxUR":"╚","boxv":"│","boxV":"║","boxvh":"┼","boxvH":"╪","boxVh":"╫","boxVH":"╬","boxvl":"┤","boxvL":"╡","boxVl":"╢","boxVL":"╣","boxvr":"├","boxvR":"╞","boxVr":"╟","boxVR":"╠","bprime":"‵","breve":"˘","Breve":"˘","brvbar":"¦","bscr":"𝒷","Bscr":"ℬ","bsemi":"⁏","bsim":"∽","bsime":"⋍","bsolb":"⧅","bsol":"\\\\","bsolhsub":"⟈","bull":"•","bullet":"•","bump":"≎","bumpE":"⪮","bumpe":"≏","Bumpeq":"≎","bumpeq":"≏","Cacute":"Ć","cacute":"ć","capand":"⩄","capbrcup":"⩉","capcap":"⩋","cap":"∩","Cap":"⋒","capcup":"⩇","capdot":"⩀","CapitalDifferentialD":"ⅅ","caps":"∩︀","caret":"⁁","caron":"ˇ","Cayleys":"ℭ","ccaps":"⩍","Ccaron":"Č","ccaron":"č","Ccedil":"Ç","ccedil":"ç","Ccirc":"Ĉ","ccirc":"ĉ","Cconint":"∰","ccups":"⩌","ccupssm":"⩐","Cdot":"Ċ","cdot":"ċ","cedil":"¸","Cedilla":"¸","cemptyv":"⦲","cent":"¢","centerdot":"·","CenterDot":"·","cfr":"𝔠","Cfr":"ℭ","CHcy":"Ч","chcy":"ч","check":"✓","checkmark":"✓","Chi":"Χ","chi":"χ","circ":"ˆ","circeq":"≗","circlearrowleft":"↺","circlearrowright":"↻","circledast":"⊛","circledcirc":"⊚","circleddash":"⊝","CircleDot":"⊙","circledR":"®","circledS":"Ⓢ","CircleMinus":"⊖","CirclePlus":"⊕","CircleTimes":"⊗","cir":"○","cirE":"⧃","cire":"≗","cirfnint":"⨐","cirmid":"⫯","cirscir":"⧂","ClockwiseContourIntegral":"∲","CloseCurlyDoubleQuote":"”","CloseCurlyQuote":"’","clubs":"♣","clubsuit":"♣","colon":":","Colon":"∷","Colone":"⩴","colone":"≔","coloneq":"≔","comma":",","commat":"@","comp":"∁","compfn":"∘","complement":"∁","complexes":"ℂ","cong":"≅","congdot":"⩭","Congruent":"≡","conint":"∮","Conint":"∯","ContourIntegral":"∮","copf":"𝕔","Copf":"ℂ","coprod":"∐","Coproduct":"∐","copy":"©","COPY":"©","copysr":"℗","CounterClockwiseContourIntegral":"∳","crarr":"↵","cross":"✗","Cross":"⨯","Cscr":"𝒞","cscr":"𝒸","csub":"⫏","csube":"⫑","csup":"⫐","csupe":"⫒","ctdot":"⋯","cudarrl":"⤸","cudarrr":"⤵","cuepr":"⋞","cuesc":"⋟","cularr":"↶","cularrp":"⤽","cupbrcap":"⩈","cupcap":"⩆","CupCap":"≍","cup":"∪","Cup":"⋓","cupcup":"⩊","cupdot":"⊍","cupor":"⩅","cups":"∪︀","curarr":"↷","curarrm":"⤼","curlyeqprec":"⋞","curlyeqsucc":"⋟","curlyvee":"⋎","curlywedge":"⋏","curren":"¤","curvearrowleft":"↶","curvearrowright":"↷","cuvee":"⋎","cuwed":"⋏","cwconint":"∲","cwint":"∱","cylcty":"⌭","dagger":"†","Dagger":"‡","daleth":"ℸ","darr":"↓","Darr":"↡","dArr":"⇓","dash":"‐","Dashv":"⫤","dashv":"⊣","dbkarow":"⤏","dblac":"˝","Dcaron":"Ď","dcaron":"ď","Dcy":"Д","dcy":"д","ddagger":"‡","ddarr":"⇊","DD":"ⅅ","dd":"ⅆ","DDotrahd":"⤑","ddotseq":"⩷","deg":"°","Del":"∇","Delta":"Δ","delta":"δ","demptyv":"⦱","dfisht":"⥿","Dfr":"𝔇","dfr":"𝔡","dHar":"⥥","dharl":"⇃","dharr":"⇂","DiacriticalAcute":"´","DiacriticalDot":"˙","DiacriticalDoubleAcute":"˝","DiacriticalGrave":"`","DiacriticalTilde":"˜","diam":"⋄","diamond":"⋄","Diamond":"⋄","diamondsuit":"♦","diams":"♦","die":"¨","DifferentialD":"ⅆ","digamma":"ϝ","disin":"⋲","div":"÷","divide":"÷","divideontimes":"⋇","divonx":"⋇","DJcy":"Ђ","djcy":"ђ","dlcorn":"⌞","dlcrop":"⌍","dollar":"$","Dopf":"𝔻","dopf":"𝕕","Dot":"¨","dot":"˙","DotDot":"⃜","doteq":"≐","doteqdot":"≑","DotEqual":"≐","dotminus":"∸","dotplus":"∔","dotsquare":"⊡","doublebarwedge":"⌆","DoubleContourIntegral":"∯","DoubleDot":"¨","DoubleDownArrow":"⇓","DoubleLeftArrow":"⇐","DoubleLeftRightArrow":"⇔","DoubleLeftTee":"⫤","DoubleLongLeftArrow":"⟸","DoubleLongLeftRightArrow":"⟺","DoubleLongRightArrow":"⟹","DoubleRightArrow":"⇒","DoubleRightTee":"⊨","DoubleUpArrow":"⇑","DoubleUpDownArrow":"⇕","DoubleVerticalBar":"∥","DownArrowBar":"⤓","downarrow":"↓","DownArrow":"↓","Downarrow":"⇓","DownArrowUpArrow":"⇵","DownBreve":"̑","downdownarrows":"⇊","downharpoonleft":"⇃","downharpoonright":"⇂","DownLeftRightVector":"⥐","DownLeftTeeVector":"⥞","DownLeftVectorBar":"⥖","DownLeftVector":"↽","DownRightTeeVector":"⥟","DownRightVectorBar":"⥗","DownRightVector":"⇁","DownTeeArrow":"↧","DownTee":"⊤","drbkarow":"⤐","drcorn":"⌟","drcrop":"⌌","Dscr":"𝒟","dscr":"𝒹","DScy":"Ѕ","dscy":"ѕ","dsol":"⧶","Dstrok":"Đ","dstrok":"đ","dtdot":"⋱","dtri":"▿","dtrif":"▾","duarr":"⇵","duhar":"⥯","dwangle":"⦦","DZcy":"Џ","dzcy":"џ","dzigrarr":"⟿","Eacute":"É","eacute":"é","easter":"⩮","Ecaron":"Ě","ecaron":"ě","Ecirc":"Ê","ecirc":"ê","ecir":"≖","ecolon":"≕","Ecy":"Э","ecy":"э","eDDot":"⩷","Edot":"Ė","edot":"ė","eDot":"≑","ee":"ⅇ","efDot":"≒","Efr":"𝔈","efr":"𝔢","eg":"⪚","Egrave":"È","egrave":"è","egs":"⪖","egsdot":"⪘","el":"⪙","Element":"∈","elinters":"⏧","ell":"ℓ","els":"⪕","elsdot":"⪗","Emacr":"Ē","emacr":"ē","empty":"∅","emptyset":"∅","EmptySmallSquare":"◻","emptyv":"∅","EmptyVerySmallSquare":"▫","emsp13":" ","emsp14":" ","emsp":" ","ENG":"Ŋ","eng":"ŋ","ensp":" ","Eogon":"Ę","eogon":"ę","Eopf":"𝔼","eopf":"𝕖","epar":"⋕","eparsl":"⧣","eplus":"⩱","epsi":"ε","Epsilon":"Ε","epsilon":"ε","epsiv":"ϵ","eqcirc":"≖","eqcolon":"≕","eqsim":"≂","eqslantgtr":"⪖","eqslantless":"⪕","Equal":"⩵","equals":"=","EqualTilde":"≂","equest":"≟","Equilibrium":"⇌","equiv":"≡","equivDD":"⩸","eqvparsl":"⧥","erarr":"⥱","erDot":"≓","escr":"ℯ","Escr":"ℰ","esdot":"≐","Esim":"⩳","esim":"≂","Eta":"Η","eta":"η","ETH":"Ð","eth":"ð","Euml":"Ë","euml":"ë","euro":"€","excl":"!","exist":"∃","Exists":"∃","expectation":"ℰ","exponentiale":"ⅇ","ExponentialE":"ⅇ","fallingdotseq":"≒","Fcy":"Ф","fcy":"ф","female":"♀","ffilig":"ffi","fflig":"ff","ffllig":"ffl","Ffr":"𝔉","ffr":"𝔣","filig":"fi","FilledSmallSquare":"◼","FilledVerySmallSquare":"▪","fjlig":"fj","flat":"♭","fllig":"fl","fltns":"▱","fnof":"ƒ","Fopf":"𝔽","fopf":"𝕗","forall":"∀","ForAll":"∀","fork":"⋔","forkv":"⫙","Fouriertrf":"ℱ","fpartint":"⨍","frac12":"½","frac13":"⅓","frac14":"¼","frac15":"⅕","frac16":"⅙","frac18":"⅛","frac23":"⅔","frac25":"⅖","frac34":"¾","frac35":"⅗","frac38":"⅜","frac45":"⅘","frac56":"⅚","frac58":"⅝","frac78":"⅞","frasl":"⁄","frown":"⌢","fscr":"𝒻","Fscr":"ℱ","gacute":"ǵ","Gamma":"Γ","gamma":"γ","Gammad":"Ϝ","gammad":"ϝ","gap":"⪆","Gbreve":"Ğ","gbreve":"ğ","Gcedil":"Ģ","Gcirc":"Ĝ","gcirc":"ĝ","Gcy":"Г","gcy":"г","Gdot":"Ġ","gdot":"ġ","ge":"≥","gE":"≧","gEl":"⪌","gel":"⋛","geq":"≥","geqq":"≧","geqslant":"⩾","gescc":"⪩","ges":"⩾","gesdot":"⪀","gesdoto":"⪂","gesdotol":"⪄","gesl":"⋛︀","gesles":"⪔","Gfr":"𝔊","gfr":"𝔤","gg":"≫","Gg":"⋙","ggg":"⋙","gimel":"ℷ","GJcy":"Ѓ","gjcy":"ѓ","gla":"⪥","gl":"≷","glE":"⪒","glj":"⪤","gnap":"⪊","gnapprox":"⪊","gne":"⪈","gnE":"≩","gneq":"⪈","gneqq":"≩","gnsim":"⋧","Gopf":"𝔾","gopf":"𝕘","grave":"`","GreaterEqual":"≥","GreaterEqualLess":"⋛","GreaterFullEqual":"≧","GreaterGreater":"⪢","GreaterLess":"≷","GreaterSlantEqual":"⩾","GreaterTilde":"≳","Gscr":"𝒢","gscr":"ℊ","gsim":"≳","gsime":"⪎","gsiml":"⪐","gtcc":"⪧","gtcir":"⩺","gt":">","GT":">","Gt":"≫","gtdot":"⋗","gtlPar":"⦕","gtquest":"⩼","gtrapprox":"⪆","gtrarr":"⥸","gtrdot":"⋗","gtreqless":"⋛","gtreqqless":"⪌","gtrless":"≷","gtrsim":"≳","gvertneqq":"≩︀","gvnE":"≩︀","Hacek":"ˇ","hairsp":" ","half":"½","hamilt":"ℋ","HARDcy":"Ъ","hardcy":"ъ","harrcir":"⥈","harr":"↔","hArr":"⇔","harrw":"↭","Hat":"^","hbar":"ℏ","Hcirc":"Ĥ","hcirc":"ĥ","hearts":"♥","heartsuit":"♥","hellip":"…","hercon":"⊹","hfr":"𝔥","Hfr":"ℌ","HilbertSpace":"ℋ","hksearow":"⤥","hkswarow":"⤦","hoarr":"⇿","homtht":"∻","hookleftarrow":"↩","hookrightarrow":"↪","hopf":"𝕙","Hopf":"ℍ","horbar":"―","HorizontalLine":"─","hscr":"𝒽","Hscr":"ℋ","hslash":"ℏ","Hstrok":"Ħ","hstrok":"ħ","HumpDownHump":"≎","HumpEqual":"≏","hybull":"⁃","hyphen":"‐","Iacute":"Í","iacute":"í","ic":"⁣","Icirc":"Î","icirc":"î","Icy":"И","icy":"и","Idot":"İ","IEcy":"Е","iecy":"е","iexcl":"¡","iff":"⇔","ifr":"𝔦","Ifr":"ℑ","Igrave":"Ì","igrave":"ì","ii":"ⅈ","iiiint":"⨌","iiint":"∭","iinfin":"⧜","iiota":"℩","IJlig":"IJ","ijlig":"ij","Imacr":"Ī","imacr":"ī","image":"ℑ","ImaginaryI":"ⅈ","imagline":"ℐ","imagpart":"ℑ","imath":"ı","Im":"ℑ","imof":"⊷","imped":"Ƶ","Implies":"⇒","incare":"℅","in":"∈","infin":"∞","infintie":"⧝","inodot":"ı","intcal":"⊺","int":"∫","Int":"∬","integers":"ℤ","Integral":"∫","intercal":"⊺","Intersection":"⋂","intlarhk":"⨗","intprod":"⨼","InvisibleComma":"⁣","InvisibleTimes":"⁢","IOcy":"Ё","iocy":"ё","Iogon":"Į","iogon":"į","Iopf":"𝕀","iopf":"𝕚","Iota":"Ι","iota":"ι","iprod":"⨼","iquest":"¿","iscr":"𝒾","Iscr":"ℐ","isin":"∈","isindot":"⋵","isinE":"⋹","isins":"⋴","isinsv":"⋳","isinv":"∈","it":"⁢","Itilde":"Ĩ","itilde":"ĩ","Iukcy":"І","iukcy":"і","Iuml":"Ï","iuml":"ï","Jcirc":"Ĵ","jcirc":"ĵ","Jcy":"Й","jcy":"й","Jfr":"𝔍","jfr":"𝔧","jmath":"ȷ","Jopf":"𝕁","jopf":"𝕛","Jscr":"𝒥","jscr":"𝒿","Jsercy":"Ј","jsercy":"ј","Jukcy":"Є","jukcy":"є","Kappa":"Κ","kappa":"κ","kappav":"ϰ","Kcedil":"Ķ","kcedil":"ķ","Kcy":"К","kcy":"к","Kfr":"𝔎","kfr":"𝔨","kgreen":"ĸ","KHcy":"Х","khcy":"х","KJcy":"Ќ","kjcy":"ќ","Kopf":"𝕂","kopf":"𝕜","Kscr":"𝒦","kscr":"𝓀","lAarr":"⇚","Lacute":"Ĺ","lacute":"ĺ","laemptyv":"⦴","lagran":"ℒ","Lambda":"Λ","lambda":"λ","lang":"⟨","Lang":"⟪","langd":"⦑","langle":"⟨","lap":"⪅","Laplacetrf":"ℒ","laquo":"«","larrb":"⇤","larrbfs":"⤟","larr":"←","Larr":"↞","lArr":"⇐","larrfs":"⤝","larrhk":"↩","larrlp":"↫","larrpl":"⤹","larrsim":"⥳","larrtl":"↢","latail":"⤙","lAtail":"⤛","lat":"⪫","late":"⪭","lates":"⪭︀","lbarr":"⤌","lBarr":"⤎","lbbrk":"❲","lbrace":"{","lbrack":"[","lbrke":"⦋","lbrksld":"⦏","lbrkslu":"⦍","Lcaron":"Ľ","lcaron":"ľ","Lcedil":"Ļ","lcedil":"ļ","lceil":"⌈","lcub":"{","Lcy":"Л","lcy":"л","ldca":"⤶","ldquo":"“","ldquor":"„","ldrdhar":"⥧","ldrushar":"⥋","ldsh":"↲","le":"≤","lE":"≦","LeftAngleBracket":"⟨","LeftArrowBar":"⇤","leftarrow":"←","LeftArrow":"←","Leftarrow":"⇐","LeftArrowRightArrow":"⇆","leftarrowtail":"↢","LeftCeiling":"⌈","LeftDoubleBracket":"⟦","LeftDownTeeVector":"⥡","LeftDownVectorBar":"⥙","LeftDownVector":"⇃","LeftFloor":"⌊","leftharpoondown":"↽","leftharpoonup":"↼","leftleftarrows":"⇇","leftrightarrow":"↔","LeftRightArrow":"↔","Leftrightarrow":"⇔","leftrightarrows":"⇆","leftrightharpoons":"⇋","leftrightsquigarrow":"↭","LeftRightVector":"⥎","LeftTeeArrow":"↤","LeftTee":"⊣","LeftTeeVector":"⥚","leftthreetimes":"⋋","LeftTriangleBar":"⧏","LeftTriangle":"⊲","LeftTriangleEqual":"⊴","LeftUpDownVector":"⥑","LeftUpTeeVector":"⥠","LeftUpVectorBar":"⥘","LeftUpVector":"↿","LeftVectorBar":"⥒","LeftVector":"↼","lEg":"⪋","leg":"⋚","leq":"≤","leqq":"≦","leqslant":"⩽","lescc":"⪨","les":"⩽","lesdot":"⩿","lesdoto":"⪁","lesdotor":"⪃","lesg":"⋚︀","lesges":"⪓","lessapprox":"⪅","lessdot":"⋖","lesseqgtr":"⋚","lesseqqgtr":"⪋","LessEqualGreater":"⋚","LessFullEqual":"≦","LessGreater":"≶","lessgtr":"≶","LessLess":"⪡","lesssim":"≲","LessSlantEqual":"⩽","LessTilde":"≲","lfisht":"⥼","lfloor":"⌊","Lfr":"𝔏","lfr":"𝔩","lg":"≶","lgE":"⪑","lHar":"⥢","lhard":"↽","lharu":"↼","lharul":"⥪","lhblk":"▄","LJcy":"Љ","ljcy":"љ","llarr":"⇇","ll":"≪","Ll":"⋘","llcorner":"⌞","Lleftarrow":"⇚","llhard":"⥫","lltri":"◺","Lmidot":"Ŀ","lmidot":"ŀ","lmoustache":"⎰","lmoust":"⎰","lnap":"⪉","lnapprox":"⪉","lne":"⪇","lnE":"≨","lneq":"⪇","lneqq":"≨","lnsim":"⋦","loang":"⟬","loarr":"⇽","lobrk":"⟦","longleftarrow":"⟵","LongLeftArrow":"⟵","Longleftarrow":"⟸","longleftrightarrow":"⟷","LongLeftRightArrow":"⟷","Longleftrightarrow":"⟺","longmapsto":"⟼","longrightarrow":"⟶","LongRightArrow":"⟶","Longrightarrow":"⟹","looparrowleft":"↫","looparrowright":"↬","lopar":"⦅","Lopf":"𝕃","lopf":"𝕝","loplus":"⨭","lotimes":"⨴","lowast":"∗","lowbar":"_","LowerLeftArrow":"↙","LowerRightArrow":"↘","loz":"◊","lozenge":"◊","lozf":"⧫","lpar":"(","lparlt":"⦓","lrarr":"⇆","lrcorner":"⌟","lrhar":"⇋","lrhard":"⥭","lrm":"‎","lrtri":"⊿","lsaquo":"‹","lscr":"𝓁","Lscr":"ℒ","lsh":"↰","Lsh":"↰","lsim":"≲","lsime":"⪍","lsimg":"⪏","lsqb":"[","lsquo":"‘","lsquor":"‚","Lstrok":"Ł","lstrok":"ł","ltcc":"⪦","ltcir":"⩹","lt":"<","LT":"<","Lt":"≪","ltdot":"⋖","lthree":"⋋","ltimes":"⋉","ltlarr":"⥶","ltquest":"⩻","ltri":"◃","ltrie":"⊴","ltrif":"◂","ltrPar":"⦖","lurdshar":"⥊","luruhar":"⥦","lvertneqq":"≨︀","lvnE":"≨︀","macr":"¯","male":"♂","malt":"✠","maltese":"✠","Map":"⤅","map":"↦","mapsto":"↦","mapstodown":"↧","mapstoleft":"↤","mapstoup":"↥","marker":"▮","mcomma":"⨩","Mcy":"М","mcy":"м","mdash":"—","mDDot":"∺","measuredangle":"∡","MediumSpace":" ","Mellintrf":"ℳ","Mfr":"𝔐","mfr":"𝔪","mho":"℧","micro":"µ","midast":"*","midcir":"⫰","mid":"∣","middot":"·","minusb":"⊟","minus":"−","minusd":"∸","minusdu":"⨪","MinusPlus":"∓","mlcp":"⫛","mldr":"…","mnplus":"∓","models":"⊧","Mopf":"𝕄","mopf":"𝕞","mp":"∓","mscr":"𝓂","Mscr":"ℳ","mstpos":"∾","Mu":"Μ","mu":"μ","multimap":"⊸","mumap":"⊸","nabla":"∇","Nacute":"Ń","nacute":"ń","nang":"∠⃒","nap":"≉","napE":"⩰̸","napid":"≋̸","napos":"ʼn","napprox":"≉","natural":"♮","naturals":"ℕ","natur":"♮","nbsp":" ","nbump":"≎̸","nbumpe":"≏̸","ncap":"⩃","Ncaron":"Ň","ncaron":"ň","Ncedil":"Ņ","ncedil":"ņ","ncong":"≇","ncongdot":"⩭̸","ncup":"⩂","Ncy":"Н","ncy":"н","ndash":"–","nearhk":"⤤","nearr":"↗","neArr":"⇗","nearrow":"↗","ne":"≠","nedot":"≐̸","NegativeMediumSpace":"​","NegativeThickSpace":"​","NegativeThinSpace":"​","NegativeVeryThinSpace":"​","nequiv":"≢","nesear":"⤨","nesim":"≂̸","NestedGreaterGreater":"≫","NestedLessLess":"≪","NewLine":"\\n","nexist":"∄","nexists":"∄","Nfr":"𝔑","nfr":"𝔫","ngE":"≧̸","nge":"≱","ngeq":"≱","ngeqq":"≧̸","ngeqslant":"⩾̸","nges":"⩾̸","nGg":"⋙̸","ngsim":"≵","nGt":"≫⃒","ngt":"≯","ngtr":"≯","nGtv":"≫̸","nharr":"↮","nhArr":"⇎","nhpar":"⫲","ni":"∋","nis":"⋼","nisd":"⋺","niv":"∋","NJcy":"Њ","njcy":"њ","nlarr":"↚","nlArr":"⇍","nldr":"‥","nlE":"≦̸","nle":"≰","nleftarrow":"↚","nLeftarrow":"⇍","nleftrightarrow":"↮","nLeftrightarrow":"⇎","nleq":"≰","nleqq":"≦̸","nleqslant":"⩽̸","nles":"⩽̸","nless":"≮","nLl":"⋘̸","nlsim":"≴","nLt":"≪⃒","nlt":"≮","nltri":"⋪","nltrie":"⋬","nLtv":"≪̸","nmid":"∤","NoBreak":"⁠","NonBreakingSpace":" ","nopf":"𝕟","Nopf":"ℕ","Not":"⫬","not":"¬","NotCongruent":"≢","NotCupCap":"≭","NotDoubleVerticalBar":"∦","NotElement":"∉","NotEqual":"≠","NotEqualTilde":"≂̸","NotExists":"∄","NotGreater":"≯","NotGreaterEqual":"≱","NotGreaterFullEqual":"≧̸","NotGreaterGreater":"≫̸","NotGreaterLess":"≹","NotGreaterSlantEqual":"⩾̸","NotGreaterTilde":"≵","NotHumpDownHump":"≎̸","NotHumpEqual":"≏̸","notin":"∉","notindot":"⋵̸","notinE":"⋹̸","notinva":"∉","notinvb":"⋷","notinvc":"⋶","NotLeftTriangleBar":"⧏̸","NotLeftTriangle":"⋪","NotLeftTriangleEqual":"⋬","NotLess":"≮","NotLessEqual":"≰","NotLessGreater":"≸","NotLessLess":"≪̸","NotLessSlantEqual":"⩽̸","NotLessTilde":"≴","NotNestedGreaterGreater":"⪢̸","NotNestedLessLess":"⪡̸","notni":"∌","notniva":"∌","notnivb":"⋾","notnivc":"⋽","NotPrecedes":"⊀","NotPrecedesEqual":"⪯̸","NotPrecedesSlantEqual":"⋠","NotReverseElement":"∌","NotRightTriangleBar":"⧐̸","NotRightTriangle":"⋫","NotRightTriangleEqual":"⋭","NotSquareSubset":"⊏̸","NotSquareSubsetEqual":"⋢","NotSquareSuperset":"⊐̸","NotSquareSupersetEqual":"⋣","NotSubset":"⊂⃒","NotSubsetEqual":"⊈","NotSucceeds":"⊁","NotSucceedsEqual":"⪰̸","NotSucceedsSlantEqual":"⋡","NotSucceedsTilde":"≿̸","NotSuperset":"⊃⃒","NotSupersetEqual":"⊉","NotTilde":"≁","NotTildeEqual":"≄","NotTildeFullEqual":"≇","NotTildeTilde":"≉","NotVerticalBar":"∤","nparallel":"∦","npar":"∦","nparsl":"⫽⃥","npart":"∂̸","npolint":"⨔","npr":"⊀","nprcue":"⋠","nprec":"⊀","npreceq":"⪯̸","npre":"⪯̸","nrarrc":"⤳̸","nrarr":"↛","nrArr":"⇏","nrarrw":"↝̸","nrightarrow":"↛","nRightarrow":"⇏","nrtri":"⋫","nrtrie":"⋭","nsc":"⊁","nsccue":"⋡","nsce":"⪰̸","Nscr":"𝒩","nscr":"𝓃","nshortmid":"∤","nshortparallel":"∦","nsim":"≁","nsime":"≄","nsimeq":"≄","nsmid":"∤","nspar":"∦","nsqsube":"⋢","nsqsupe":"⋣","nsub":"⊄","nsubE":"⫅̸","nsube":"⊈","nsubset":"⊂⃒","nsubseteq":"⊈","nsubseteqq":"⫅̸","nsucc":"⊁","nsucceq":"⪰̸","nsup":"⊅","nsupE":"⫆̸","nsupe":"⊉","nsupset":"⊃⃒","nsupseteq":"⊉","nsupseteqq":"⫆̸","ntgl":"≹","Ntilde":"Ñ","ntilde":"ñ","ntlg":"≸","ntriangleleft":"⋪","ntrianglelefteq":"⋬","ntriangleright":"⋫","ntrianglerighteq":"⋭","Nu":"Ν","nu":"ν","num":"#","numero":"№","numsp":" ","nvap":"≍⃒","nvdash":"⊬","nvDash":"⊭","nVdash":"⊮","nVDash":"⊯","nvge":"≥⃒","nvgt":">⃒","nvHarr":"⤄","nvinfin":"⧞","nvlArr":"⤂","nvle":"≤⃒","nvlt":"<⃒","nvltrie":"⊴⃒","nvrArr":"⤃","nvrtrie":"⊵⃒","nvsim":"∼⃒","nwarhk":"⤣","nwarr":"↖","nwArr":"⇖","nwarrow":"↖","nwnear":"⤧","Oacute":"Ó","oacute":"ó","oast":"⊛","Ocirc":"Ô","ocirc":"ô","ocir":"⊚","Ocy":"О","ocy":"о","odash":"⊝","Odblac":"Ő","odblac":"ő","odiv":"⨸","odot":"⊙","odsold":"⦼","OElig":"Œ","oelig":"œ","ofcir":"⦿","Ofr":"𝔒","ofr":"𝔬","ogon":"˛","Ograve":"Ò","ograve":"ò","ogt":"⧁","ohbar":"⦵","ohm":"Ω","oint":"∮","olarr":"↺","olcir":"⦾","olcross":"⦻","oline":"‾","olt":"⧀","Omacr":"Ō","omacr":"ō","Omega":"Ω","omega":"ω","Omicron":"Ο","omicron":"ο","omid":"⦶","ominus":"⊖","Oopf":"𝕆","oopf":"𝕠","opar":"⦷","OpenCurlyDoubleQuote":"“","OpenCurlyQuote":"‘","operp":"⦹","oplus":"⊕","orarr":"↻","Or":"⩔","or":"∨","ord":"⩝","order":"ℴ","orderof":"ℴ","ordf":"ª","ordm":"º","origof":"⊶","oror":"⩖","orslope":"⩗","orv":"⩛","oS":"Ⓢ","Oscr":"𝒪","oscr":"ℴ","Oslash":"Ø","oslash":"ø","osol":"⊘","Otilde":"Õ","otilde":"õ","otimesas":"⨶","Otimes":"⨷","otimes":"⊗","Ouml":"Ö","ouml":"ö","ovbar":"⌽","OverBar":"‾","OverBrace":"⏞","OverBracket":"⎴","OverParenthesis":"⏜","para":"¶","parallel":"∥","par":"∥","parsim":"⫳","parsl":"⫽","part":"∂","PartialD":"∂","Pcy":"П","pcy":"п","percnt":"%","period":".","permil":"‰","perp":"⊥","pertenk":"‱","Pfr":"𝔓","pfr":"𝔭","Phi":"Φ","phi":"φ","phiv":"ϕ","phmmat":"ℳ","phone":"☎","Pi":"Π","pi":"π","pitchfork":"⋔","piv":"ϖ","planck":"ℏ","planckh":"ℎ","plankv":"ℏ","plusacir":"⨣","plusb":"⊞","pluscir":"⨢","plus":"+","plusdo":"∔","plusdu":"⨥","pluse":"⩲","PlusMinus":"±","plusmn":"±","plussim":"⨦","plustwo":"⨧","pm":"±","Poincareplane":"ℌ","pointint":"⨕","popf":"𝕡","Popf":"ℙ","pound":"£","prap":"⪷","Pr":"⪻","pr":"≺","prcue":"≼","precapprox":"⪷","prec":"≺","preccurlyeq":"≼","Precedes":"≺","PrecedesEqual":"⪯","PrecedesSlantEqual":"≼","PrecedesTilde":"≾","preceq":"⪯","precnapprox":"⪹","precneqq":"⪵","precnsim":"⋨","pre":"⪯","prE":"⪳","precsim":"≾","prime":"′","Prime":"″","primes":"ℙ","prnap":"⪹","prnE":"⪵","prnsim":"⋨","prod":"∏","Product":"∏","profalar":"⌮","profline":"⌒","profsurf":"⌓","prop":"∝","Proportional":"∝","Proportion":"∷","propto":"∝","prsim":"≾","prurel":"⊰","Pscr":"𝒫","pscr":"𝓅","Psi":"Ψ","psi":"ψ","puncsp":" ","Qfr":"𝔔","qfr":"𝔮","qint":"⨌","qopf":"𝕢","Qopf":"ℚ","qprime":"⁗","Qscr":"𝒬","qscr":"𝓆","quaternions":"ℍ","quatint":"⨖","quest":"?","questeq":"≟","quot":"\\"","QUOT":"\\"","rAarr":"⇛","race":"∽̱","Racute":"Ŕ","racute":"ŕ","radic":"√","raemptyv":"⦳","rang":"⟩","Rang":"⟫","rangd":"⦒","range":"⦥","rangle":"⟩","raquo":"»","rarrap":"⥵","rarrb":"⇥","rarrbfs":"⤠","rarrc":"⤳","rarr":"→","Rarr":"↠","rArr":"⇒","rarrfs":"⤞","rarrhk":"↪","rarrlp":"↬","rarrpl":"⥅","rarrsim":"⥴","Rarrtl":"⤖","rarrtl":"↣","rarrw":"↝","ratail":"⤚","rAtail":"⤜","ratio":"∶","rationals":"ℚ","rbarr":"⤍","rBarr":"⤏","RBarr":"⤐","rbbrk":"❳","rbrace":"}","rbrack":"]","rbrke":"⦌","rbrksld":"⦎","rbrkslu":"⦐","Rcaron":"Ř","rcaron":"ř","Rcedil":"Ŗ","rcedil":"ŗ","rceil":"⌉","rcub":"}","Rcy":"Р","rcy":"р","rdca":"⤷","rdldhar":"⥩","rdquo":"”","rdquor":"”","rdsh":"↳","real":"ℜ","realine":"ℛ","realpart":"ℜ","reals":"ℝ","Re":"ℜ","rect":"▭","reg":"®","REG":"®","ReverseElement":"∋","ReverseEquilibrium":"⇋","ReverseUpEquilibrium":"⥯","rfisht":"⥽","rfloor":"⌋","rfr":"𝔯","Rfr":"ℜ","rHar":"⥤","rhard":"⇁","rharu":"⇀","rharul":"⥬","Rho":"Ρ","rho":"ρ","rhov":"ϱ","RightAngleBracket":"⟩","RightArrowBar":"⇥","rightarrow":"→","RightArrow":"→","Rightarrow":"⇒","RightArrowLeftArrow":"⇄","rightarrowtail":"↣","RightCeiling":"⌉","RightDoubleBracket":"⟧","RightDownTeeVector":"⥝","RightDownVectorBar":"⥕","RightDownVector":"⇂","RightFloor":"⌋","rightharpoondown":"⇁","rightharpoonup":"⇀","rightleftarrows":"⇄","rightleftharpoons":"⇌","rightrightarrows":"⇉","rightsquigarrow":"↝","RightTeeArrow":"↦","RightTee":"⊢","RightTeeVector":"⥛","rightthreetimes":"⋌","RightTriangleBar":"⧐","RightTriangle":"⊳","RightTriangleEqual":"⊵","RightUpDownVector":"⥏","RightUpTeeVector":"⥜","RightUpVectorBar":"⥔","RightUpVector":"↾","RightVectorBar":"⥓","RightVector":"⇀","ring":"˚","risingdotseq":"≓","rlarr":"⇄","rlhar":"⇌","rlm":"‏","rmoustache":"⎱","rmoust":"⎱","rnmid":"⫮","roang":"⟭","roarr":"⇾","robrk":"⟧","ropar":"⦆","ropf":"𝕣","Ropf":"ℝ","roplus":"⨮","rotimes":"⨵","RoundImplies":"⥰","rpar":")","rpargt":"⦔","rppolint":"⨒","rrarr":"⇉","Rrightarrow":"⇛","rsaquo":"›","rscr":"𝓇","Rscr":"ℛ","rsh":"↱","Rsh":"↱","rsqb":"]","rsquo":"’","rsquor":"’","rthree":"⋌","rtimes":"⋊","rtri":"▹","rtrie":"⊵","rtrif":"▸","rtriltri":"⧎","RuleDelayed":"⧴","ruluhar":"⥨","rx":"℞","Sacute":"Ś","sacute":"ś","sbquo":"‚","scap":"⪸","Scaron":"Š","scaron":"š","Sc":"⪼","sc":"≻","sccue":"≽","sce":"⪰","scE":"⪴","Scedil":"Ş","scedil":"ş","Scirc":"Ŝ","scirc":"ŝ","scnap":"⪺","scnE":"⪶","scnsim":"⋩","scpolint":"⨓","scsim":"≿","Scy":"С","scy":"с","sdotb":"⊡","sdot":"⋅","sdote":"⩦","searhk":"⤥","searr":"↘","seArr":"⇘","searrow":"↘","sect":"§","semi":";","seswar":"⤩","setminus":"∖","setmn":"∖","sext":"✶","Sfr":"𝔖","sfr":"𝔰","sfrown":"⌢","sharp":"♯","SHCHcy":"Щ","shchcy":"щ","SHcy":"Ш","shcy":"ш","ShortDownArrow":"↓","ShortLeftArrow":"←","shortmid":"∣","shortparallel":"∥","ShortRightArrow":"→","ShortUpArrow":"↑","shy":"­","Sigma":"Σ","sigma":"σ","sigmaf":"ς","sigmav":"ς","sim":"∼","simdot":"⩪","sime":"≃","simeq":"≃","simg":"⪞","simgE":"⪠","siml":"⪝","simlE":"⪟","simne":"≆","simplus":"⨤","simrarr":"⥲","slarr":"←","SmallCircle":"∘","smallsetminus":"∖","smashp":"⨳","smeparsl":"⧤","smid":"∣","smile":"⌣","smt":"⪪","smte":"⪬","smtes":"⪬︀","SOFTcy":"Ь","softcy":"ь","solbar":"⌿","solb":"⧄","sol":"/","Sopf":"𝕊","sopf":"𝕤","spades":"♠","spadesuit":"♠","spar":"∥","sqcap":"⊓","sqcaps":"⊓︀","sqcup":"⊔","sqcups":"⊔︀","Sqrt":"√","sqsub":"⊏","sqsube":"⊑","sqsubset":"⊏","sqsubseteq":"⊑","sqsup":"⊐","sqsupe":"⊒","sqsupset":"⊐","sqsupseteq":"⊒","square":"□","Square":"□","SquareIntersection":"⊓","SquareSubset":"⊏","SquareSubsetEqual":"⊑","SquareSuperset":"⊐","SquareSupersetEqual":"⊒","SquareUnion":"⊔","squarf":"▪","squ":"□","squf":"▪","srarr":"→","Sscr":"𝒮","sscr":"𝓈","ssetmn":"∖","ssmile":"⌣","sstarf":"⋆","Star":"⋆","star":"☆","starf":"★","straightepsilon":"ϵ","straightphi":"ϕ","strns":"¯","sub":"⊂","Sub":"⋐","subdot":"⪽","subE":"⫅","sube":"⊆","subedot":"⫃","submult":"⫁","subnE":"⫋","subne":"⊊","subplus":"⪿","subrarr":"⥹","subset":"⊂","Subset":"⋐","subseteq":"⊆","subseteqq":"⫅","SubsetEqual":"⊆","subsetneq":"⊊","subsetneqq":"⫋","subsim":"⫇","subsub":"⫕","subsup":"⫓","succapprox":"⪸","succ":"≻","succcurlyeq":"≽","Succeeds":"≻","SucceedsEqual":"⪰","SucceedsSlantEqual":"≽","SucceedsTilde":"≿","succeq":"⪰","succnapprox":"⪺","succneqq":"⪶","succnsim":"⋩","succsim":"≿","SuchThat":"∋","sum":"∑","Sum":"∑","sung":"♪","sup1":"¹","sup2":"²","sup3":"³","sup":"⊃","Sup":"⋑","supdot":"⪾","supdsub":"⫘","supE":"⫆","supe":"⊇","supedot":"⫄","Superset":"⊃","SupersetEqual":"⊇","suphsol":"⟉","suphsub":"⫗","suplarr":"⥻","supmult":"⫂","supnE":"⫌","supne":"⊋","supplus":"⫀","supset":"⊃","Supset":"⋑","supseteq":"⊇","supseteqq":"⫆","supsetneq":"⊋","supsetneqq":"⫌","supsim":"⫈","supsub":"⫔","supsup":"⫖","swarhk":"⤦","swarr":"↙","swArr":"⇙","swarrow":"↙","swnwar":"⤪","szlig":"ß","Tab":"\\t","target":"⌖","Tau":"Τ","tau":"τ","tbrk":"⎴","Tcaron":"Ť","tcaron":"ť","Tcedil":"Ţ","tcedil":"ţ","Tcy":"Т","tcy":"т","tdot":"⃛","telrec":"⌕","Tfr":"𝔗","tfr":"𝔱","there4":"∴","therefore":"∴","Therefore":"∴","Theta":"Θ","theta":"θ","thetasym":"ϑ","thetav":"ϑ","thickapprox":"≈","thicksim":"∼","ThickSpace":"  ","ThinSpace":" ","thinsp":" ","thkap":"≈","thksim":"∼","THORN":"Þ","thorn":"þ","tilde":"˜","Tilde":"∼","TildeEqual":"≃","TildeFullEqual":"≅","TildeTilde":"≈","timesbar":"⨱","timesb":"⊠","times":"×","timesd":"⨰","tint":"∭","toea":"⤨","topbot":"⌶","topcir":"⫱","top":"⊤","Topf":"𝕋","topf":"𝕥","topfork":"⫚","tosa":"⤩","tprime":"‴","trade":"™","TRADE":"™","triangle":"▵","triangledown":"▿","triangleleft":"◃","trianglelefteq":"⊴","triangleq":"≜","triangleright":"▹","trianglerighteq":"⊵","tridot":"◬","trie":"≜","triminus":"⨺","TripleDot":"⃛","triplus":"⨹","trisb":"⧍","tritime":"⨻","trpezium":"⏢","Tscr":"𝒯","tscr":"𝓉","TScy":"Ц","tscy":"ц","TSHcy":"Ћ","tshcy":"ћ","Tstrok":"Ŧ","tstrok":"ŧ","twixt":"≬","twoheadleftarrow":"↞","twoheadrightarrow":"↠","Uacute":"Ú","uacute":"ú","uarr":"↑","Uarr":"↟","uArr":"⇑","Uarrocir":"⥉","Ubrcy":"Ў","ubrcy":"ў","Ubreve":"Ŭ","ubreve":"ŭ","Ucirc":"Û","ucirc":"û","Ucy":"У","ucy":"у","udarr":"⇅","Udblac":"Ű","udblac":"ű","udhar":"⥮","ufisht":"⥾","Ufr":"𝔘","ufr":"𝔲","Ugrave":"Ù","ugrave":"ù","uHar":"⥣","uharl":"↿","uharr":"↾","uhblk":"▀","ulcorn":"⌜","ulcorner":"⌜","ulcrop":"⌏","ultri":"◸","Umacr":"Ū","umacr":"ū","uml":"¨","UnderBar":"_","UnderBrace":"⏟","UnderBracket":"⎵","UnderParenthesis":"⏝","Union":"⋃","UnionPlus":"⊎","Uogon":"Ų","uogon":"ų","Uopf":"𝕌","uopf":"𝕦","UpArrowBar":"⤒","uparrow":"↑","UpArrow":"↑","Uparrow":"⇑","UpArrowDownArrow":"⇅","updownarrow":"↕","UpDownArrow":"↕","Updownarrow":"⇕","UpEquilibrium":"⥮","upharpoonleft":"↿","upharpoonright":"↾","uplus":"⊎","UpperLeftArrow":"↖","UpperRightArrow":"↗","upsi":"υ","Upsi":"ϒ","upsih":"ϒ","Upsilon":"Υ","upsilon":"υ","UpTeeArrow":"↥","UpTee":"⊥","upuparrows":"⇈","urcorn":"⌝","urcorner":"⌝","urcrop":"⌎","Uring":"Ů","uring":"ů","urtri":"◹","Uscr":"𝒰","uscr":"𝓊","utdot":"⋰","Utilde":"Ũ","utilde":"ũ","utri":"▵","utrif":"▴","uuarr":"⇈","Uuml":"Ü","uuml":"ü","uwangle":"⦧","vangrt":"⦜","varepsilon":"ϵ","varkappa":"ϰ","varnothing":"∅","varphi":"ϕ","varpi":"ϖ","varpropto":"∝","varr":"↕","vArr":"⇕","varrho":"ϱ","varsigma":"ς","varsubsetneq":"⊊︀","varsubsetneqq":"⫋︀","varsupsetneq":"⊋︀","varsupsetneqq":"⫌︀","vartheta":"ϑ","vartriangleleft":"⊲","vartriangleright":"⊳","vBar":"⫨","Vbar":"⫫","vBarv":"⫩","Vcy":"В","vcy":"в","vdash":"⊢","vDash":"⊨","Vdash":"⊩","VDash":"⊫","Vdashl":"⫦","veebar":"⊻","vee":"∨","Vee":"⋁","veeeq":"≚","vellip":"⋮","verbar":"|","Verbar":"‖","vert":"|","Vert":"‖","VerticalBar":"∣","VerticalLine":"|","VerticalSeparator":"❘","VerticalTilde":"≀","VeryThinSpace":" ","Vfr":"𝔙","vfr":"𝔳","vltri":"⊲","vnsub":"⊂⃒","vnsup":"⊃⃒","Vopf":"𝕍","vopf":"𝕧","vprop":"∝","vrtri":"⊳","Vscr":"𝒱","vscr":"𝓋","vsubnE":"⫋︀","vsubne":"⊊︀","vsupnE":"⫌︀","vsupne":"⊋︀","Vvdash":"⊪","vzigzag":"⦚","Wcirc":"Ŵ","wcirc":"ŵ","wedbar":"⩟","wedge":"∧","Wedge":"⋀","wedgeq":"≙","weierp":"℘","Wfr":"𝔚","wfr":"𝔴","Wopf":"𝕎","wopf":"𝕨","wp":"℘","wr":"≀","wreath":"≀","Wscr":"𝒲","wscr":"𝓌","xcap":"⋂","xcirc":"◯","xcup":"⋃","xdtri":"▽","Xfr":"𝔛","xfr":"𝔵","xharr":"⟷","xhArr":"⟺","Xi":"Ξ","xi":"ξ","xlarr":"⟵","xlArr":"⟸","xmap":"⟼","xnis":"⋻","xodot":"⨀","Xopf":"𝕏","xopf":"𝕩","xoplus":"⨁","xotime":"⨂","xrarr":"⟶","xrArr":"⟹","Xscr":"𝒳","xscr":"𝓍","xsqcup":"⨆","xuplus":"⨄","xutri":"△","xvee":"⋁","xwedge":"⋀","Yacute":"Ý","yacute":"ý","YAcy":"Я","yacy":"я","Ycirc":"Ŷ","ycirc":"ŷ","Ycy":"Ы","ycy":"ы","yen":"¥","Yfr":"𝔜","yfr":"𝔶","YIcy":"Ї","yicy":"ї","Yopf":"𝕐","yopf":"𝕪","Yscr":"𝒴","yscr":"𝓎","YUcy":"Ю","yucy":"ю","yuml":"ÿ","Yuml":"Ÿ","Zacute":"Ź","zacute":"ź","Zcaron":"Ž","zcaron":"ž","Zcy":"З","zcy":"з","Zdot":"Ż","zdot":"ż","zeetrf":"ℨ","ZeroWidthSpace":"​","Zeta":"Ζ","zeta":"ζ","zfr":"𝔷","Zfr":"ℨ","ZHcy":"Ж","zhcy":"ж","zigrarr":"⇝","zopf":"𝕫","Zopf":"ℤ","Zscr":"𝒵","zscr":"𝓏","zwj":"‍","zwnj":"‌"}');
+module.exports = {"rE":"3.1.10"};
 
 /***/ })
 
@@ -33121,7 +37574,7 @@ module.exports = JSON.parse('{"Aacute":"Á","aacute":"á","Abreve":"Ă","abreve"
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
 (() => {
 "use strict";
 // Require normalize.css.
@@ -33129,12 +37582,12 @@ var __webpack_exports__ = {};
 // Require local CSS.
 
 // Require jQuery.
-const $ = __webpack_require__(9755);
+const $ = __webpack_require__(4692);
 // Setup global jQuery.
 window.$ = $;
 window.jQuery = $;
 // Require Story.
-const Story = __webpack_require__(3213);
+const Story = __webpack_require__(2577);
 // Create new Story instance.
 window.Story = new Story();
 // Create global store shortcut.
diff --git a/build/format.css b/build/format.css
index 88a73dcd..a0ce6ee5 100644
--- a/build/format.css
+++ b/build/format.css
@@ -1 +1 @@
-/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{-webkit-text-size-adjust:100%;line-height:1.15}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}body{color:#222;font:1.5em Helvetica Neue,Helvetica,Arial,sans-serif;margin-right:1em}tw-icon{cursor:pointer;font-size:2em}tw-story{box-sizing:border-box;display:flex;flex-direction:row;font-size:1.5em;line-height:1.5em;margin-top:1em;min-height:100%;width:100%}tw-passage{display:block;width:90%}a,tw-link{color:#222;cursor:pointer;text-decoration-color:#ccc}a,a:hover,tw-icon:hover,tw-link,tw-link:hover{text-decoration:underline}tw-sidebar{margin-left:1em;width:10%}a:hover{color:#cc8929}a:active,a:hover{text-decoration-color:#cc8929}a:active{color:#ffb040}tw-storydata{display:none}tw-screenlock{align-items:center;background-color:#fff;display:flex;height:100%;justify-content:center;left:0;position:fixed;top:0;width:100%;z-index:100000}.loading{-webkit-animation:spin 2s linear infinite;animation:spin 2s linear infinite;border:16px solid #f3f3f3;border-radius:50%;border-top-color:#3498db;height:250px;width:250px}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(1turn)}}@keyframes spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}
\ No newline at end of file
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}body{color:#222;font:1.5em Helvetica Neue,Helvetica,Arial,sans-serif;margin-right:1em}tw-icon{cursor:pointer;font-size:2em}tw-story{box-sizing:border-box;display:flex;flex-direction:row;font-size:1.5em;line-height:1.5em;margin-top:1em;min-height:100%;width:100%}tw-passage{display:block;width:90%}a,tw-link{color:#222;cursor:pointer;text-decoration-color:#ccc}a,a:hover,tw-icon:hover,tw-link,tw-link:hover{text-decoration:underline}tw-sidebar{margin-left:1em;width:10%}a:hover{color:#cc8929}a:active,a:hover{text-decoration-color:#cc8929}a:active{color:#ffb040}tw-storydata{display:none}tw-screenlock{align-items:center;background-color:#fff;display:flex;height:100%;justify-content:center;left:0;position:fixed;top:0;width:100%;z-index:100000}.loading{-webkit-animation:spin 2s linear infinite;animation:spin 2s linear infinite;border:16px solid #f3f3f3;border-radius:50%;border-top-color:#3498db;height:250px;width:250px}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(1turn)}}@keyframes spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}
\ No newline at end of file
diff --git a/dist/format.js b/dist/format.js
index 1a57ace7..c6a283b9 100644
--- a/dist/format.js
+++ b/dist/format.js
@@ -1 +1 @@
-window.storyFormat({"name":"Snowman","version":"3.0.0","description":"An advanced story format for authors more experienced with HTML, CSS, and JavaScript. See its <a href='https://videlais.github.io/snowman/#/' target='_blank' rel='noopener noreferrer'>documentation</a>.","proofing":false,"license":"MIT","setup":"","source":"<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n\t\t<meta charset=\"utf-8\">\n\t\t<title>{{STORY_NAME}}</title>\n\t\t<style>/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{-webkit-text-size-adjust:100%;line-height:1.15}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}body{color:#222;font:1.5em Helvetica Neue,Helvetica,Arial,sans-serif;margin-right:1em}tw-icon{cursor:pointer;font-size:2em}tw-story{box-sizing:border-box;display:flex;flex-direction:row;font-size:1.5em;line-height:1.5em;margin-top:1em;min-height:100%;width:100%}tw-passage{display:block;width:90%}a,tw-link{color:#222;cursor:pointer;text-decoration-color:#ccc}a,a:hover,tw-icon:hover,tw-link,tw-link:hover{text-decoration:underline}tw-sidebar{margin-left:1em;width:10%}a:hover{color:#cc8929}a:active,a:hover{text-decoration-color:#cc8929}a:active{color:#ffb040}tw-storydata{display:none}tw-screenlock{align-items:center;background-color:#fff;display:flex;height:100%;justify-content:center;left:0;position:fixed;top:0;width:100%;z-index:100000}.loading{-webkit-animation:spin 2s linear infinite;animation:spin 2s linear infinite;border:16px solid #f3f3f3;border-radius:50%;border-top-color:#3498db;height:250px;width:250px}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(1turn)}}@keyframes spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}</style>\n\t</head>\n\t<body>\n\t\t{{STORY_DATA}}\n\t\t<tw-story>\n\t\t\t<tw-sidebar>\n\t\t\t\t<tw-icon tabindex=\"0\" alt=\"Undo\" title=\"Undo\">↶</tw-icon>\n\t\t\t\t<tw-icon tabindex=\"1\" alt=\"Redo\" title=\"Redo\">↷</tw-icon>\n\t\t\t</tw-sidebar>\n\t\t\t<tw-passage class=\"passage\" aria-live=\"polite\"></tw-passage>\n\t\t</tw-story>\n\t\t<script>/******/ (() => { // webpackBootstrap\n/******/ \tvar __webpack_modules__ = ({\n\n/***/ 7083:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n/*\n * EJS Embedded JavaScript templates\n * Copyright 2112 Matthew Eernisse (mde@fleegix.org)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n*/\n\n\n\n/**\n * @file Embedded JavaScript templating engine. {@link http://ejs.co}\n * @author Matthew Eernisse <mde@fleegix.org>\n * @author Tiancheng \"Timothy\" Gu <timothygu99@gmail.com>\n * @project EJS\n * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}\n */\n\n/**\n * EJS internal functions.\n *\n * Technically this \"module\" lies in the same file as {@link module:ejs}, for\n * the sake of organization all the private functions re grouped into this\n * module.\n *\n * @module ejs-internal\n * @private\n */\n\n/**\n * Embedded JavaScript templating engine.\n *\n * @module ejs\n * @public\n */\n\n\nvar fs = __webpack_require__(7790);\nvar path = __webpack_require__(5272);\nvar utils = __webpack_require__(1176);\n\nvar scopeOptionWarned = false;\n/** @type {string} */\nvar _VERSION_STRING = (__webpack_require__(3558)/* .version */ .i8);\nvar _DEFAULT_OPEN_DELIMITER = '<';\nvar _DEFAULT_CLOSE_DELIMITER = '>';\nvar _DEFAULT_DELIMITER = '%';\nvar _DEFAULT_LOCALS_NAME = 'locals';\nvar _NAME = 'ejs';\nvar _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';\nvar _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',\n  'client', '_with', 'rmWhitespace', 'strict', 'filename', 'async'];\n// We don't allow 'cache' option to be passed in the data obj for\n// the normal `render` call, but this is where Express 2 & 3 put it\n// so we make an exception for `renderFile`\nvar _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');\nvar _BOM = /^\\uFEFF/;\nvar _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;\n\n/**\n * EJS template function cache. This can be a LRU object from lru-cache NPM\n * module. By default, it is {@link module:utils.cache}, a simple in-process\n * cache that grows continuously.\n *\n * @type {Cache}\n */\n\nexports.cache = utils.cache;\n\n/**\n * Custom file loader. Useful for template preprocessing or restricting access\n * to a certain part of the filesystem.\n *\n * @type {fileLoader}\n */\n\nexports.fileLoader = fs.readFileSync;\n\n/**\n * Name of the object containing the locals.\n *\n * This variable is overridden by {@link Options}`.localsName` if it is not\n * `undefined`.\n *\n * @type {String}\n * @public\n */\n\nexports.localsName = _DEFAULT_LOCALS_NAME;\n\n/**\n * Promise implementation -- defaults to the native implementation if available\n * This is mostly just for testability\n *\n * @type {PromiseConstructorLike}\n * @public\n */\n\nexports.promiseImpl = (new Function('return this;'))().Promise;\n\n/**\n * Get the path to the included file from the parent file path and the\n * specified path.\n *\n * @param {String}  name     specified path\n * @param {String}  filename parent file path\n * @param {Boolean} [isDir=false] whether the parent file path is a directory\n * @return {String}\n */\nexports.resolveInclude = function(name, filename, isDir) {\n  var dirname = path.dirname;\n  var extname = path.extname;\n  var resolve = path.resolve;\n  var includePath = resolve(isDir ? filename : dirname(filename), name);\n  var ext = extname(name);\n  if (!ext) {\n    includePath += '.ejs';\n  }\n  return includePath;\n};\n\n/**\n * Try to resolve file path on multiple directories\n *\n * @param  {String}        name  specified path\n * @param  {Array<String>} paths list of possible parent directory paths\n * @return {String}\n */\nfunction resolvePaths(name, paths) {\n  var filePath;\n  if (paths.some(function (v) {\n    filePath = exports.resolveInclude(name, v, true);\n    return fs.existsSync(filePath);\n  })) {\n    return filePath;\n  }\n}\n\n/**\n * Get the path to the included file by Options\n *\n * @param  {String}  path    specified path\n * @param  {Options} options compilation options\n * @return {String}\n */\nfunction getIncludePath(path, options) {\n  var includePath;\n  var filePath;\n  var views = options.views;\n  var match = /^[A-Za-z]+:\\\\|^\\//.exec(path);\n\n  // Abs path\n  if (match && match.length) {\n    path = path.replace(/^\\/*/, '');\n    if (Array.isArray(options.root)) {\n      includePath = resolvePaths(path, options.root);\n    } else {\n      includePath = exports.resolveInclude(path, options.root || '/', true);\n    }\n  }\n  // Relative paths\n  else {\n    // Look relative to a passed filename first\n    if (options.filename) {\n      filePath = exports.resolveInclude(path, options.filename);\n      if (fs.existsSync(filePath)) {\n        includePath = filePath;\n      }\n    }\n    // Then look in any views directories\n    if (!includePath && Array.isArray(views)) {\n      includePath = resolvePaths(path, views);\n    }\n    if (!includePath && typeof options.includer !== 'function') {\n      throw new Error('Could not find the include file \"' +\n          options.escapeFunction(path) + '\"');\n    }\n  }\n  return includePath;\n}\n\n/**\n * Get the template from a string or a file, either compiled on-the-fly or\n * read from cache (if enabled), and cache the template if needed.\n *\n * If `template` is not set, the file specified in `options.filename` will be\n * read.\n *\n * If `options.cache` is true, this function reads the file from\n * `options.filename` so it must be set prior to calling this function.\n *\n * @memberof module:ejs-internal\n * @param {Options} options   compilation options\n * @param {String} [template] template source\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `options.client`, either type might be returned.\n * @static\n */\n\nfunction handleCache(options, template) {\n  var func;\n  var filename = options.filename;\n  var hasTemplate = arguments.length > 1;\n\n  if (options.cache) {\n    if (!filename) {\n      throw new Error('cache option requires a filename');\n    }\n    func = exports.cache.get(filename);\n    if (func) {\n      return func;\n    }\n    if (!hasTemplate) {\n      template = fileLoader(filename).toString().replace(_BOM, '');\n    }\n  }\n  else if (!hasTemplate) {\n    // istanbul ignore if: should not happen at all\n    if (!filename) {\n      throw new Error('Internal EJS error: no file name or template '\n                    + 'provided');\n    }\n    template = fileLoader(filename).toString().replace(_BOM, '');\n  }\n  func = exports.compile(template, options);\n  if (options.cache) {\n    exports.cache.set(filename, func);\n  }\n  return func;\n}\n\n/**\n * Try calling handleCache with the given options and data and call the\n * callback with the result. If an error occurs, call the callback with\n * the error. Used by renderFile().\n *\n * @memberof module:ejs-internal\n * @param {Options} options    compilation options\n * @param {Object} data        template data\n * @param {RenderFileCallback} cb callback\n * @static\n */\n\nfunction tryHandleCache(options, data, cb) {\n  var result;\n  if (!cb) {\n    if (typeof exports.promiseImpl == 'function') {\n      return new exports.promiseImpl(function (resolve, reject) {\n        try {\n          result = handleCache(options)(data);\n          resolve(result);\n        }\n        catch (err) {\n          reject(err);\n        }\n      });\n    }\n    else {\n      throw new Error('Please provide a callback function');\n    }\n  }\n  else {\n    try {\n      result = handleCache(options)(data);\n    }\n    catch (err) {\n      return cb(err);\n    }\n\n    cb(null, result);\n  }\n}\n\n/**\n * fileLoader is independent\n *\n * @param {String} filePath ejs file path.\n * @return {String} The contents of the specified file.\n * @static\n */\n\nfunction fileLoader(filePath){\n  return exports.fileLoader(filePath);\n}\n\n/**\n * Get the template function.\n *\n * If `options.cache` is `true`, then the template is cached.\n *\n * @memberof module:ejs-internal\n * @param {String}  path    path for the specified file\n * @param {Options} options compilation options\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `options.client`, either type might be returned\n * @static\n */\n\nfunction includeFile(path, options) {\n  var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);\n  opts.filename = getIncludePath(path, opts);\n  if (typeof options.includer === 'function') {\n    var includerResult = options.includer(path, opts.filename);\n    if (includerResult) {\n      if (includerResult.filename) {\n        opts.filename = includerResult.filename;\n      }\n      if (includerResult.template) {\n        return handleCache(opts, includerResult.template);\n      }\n    }\n  }\n  return handleCache(opts);\n}\n\n/**\n * Re-throw the given `err` in context to the `str` of ejs, `filename`, and\n * `lineno`.\n *\n * @implements {RethrowCallback}\n * @memberof module:ejs-internal\n * @param {Error}  err      Error object\n * @param {String} str      EJS source\n * @param {String} flnm     file name of the EJS file\n * @param {Number} lineno   line number of the error\n * @param {EscapeCallback} esc\n * @static\n */\n\nfunction rethrow(err, str, flnm, lineno, esc) {\n  var lines = str.split('\\n');\n  var start = Math.max(lineno - 3, 0);\n  var end = Math.min(lines.length, lineno + 3);\n  var filename = esc(flnm);\n  // Error context\n  var context = lines.slice(start, end).map(function (line, i){\n    var curr = i + start + 1;\n    return (curr == lineno ? ' >> ' : '    ')\n      + curr\n      + '| '\n      + line;\n  }).join('\\n');\n\n  // Alter exception message\n  err.path = filename;\n  err.message = (filename || 'ejs') + ':'\n    + lineno + '\\n'\n    + context + '\\n\\n'\n    + err.message;\n\n  throw err;\n}\n\nfunction stripSemi(str){\n  return str.replace(/;(\\s*$)/, '$1');\n}\n\n/**\n * Compile the given `str` of ejs into a template function.\n *\n * @param {String}  template EJS template\n *\n * @param {Options} [opts] compilation options\n *\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `opts.client`, either type might be returned.\n * Note that the return type of the function also depends on the value of `opts.async`.\n * @public\n */\n\nexports.compile = function compile(template, opts) {\n  var templ;\n\n  // v1 compat\n  // 'scope' is 'context'\n  // FIXME: Remove this in a future version\n  if (opts && opts.scope) {\n    if (!scopeOptionWarned){\n      console.warn('`scope` option is deprecated and will be removed in EJS 3');\n      scopeOptionWarned = true;\n    }\n    if (!opts.context) {\n      opts.context = opts.scope;\n    }\n    delete opts.scope;\n  }\n  templ = new Template(template, opts);\n  return templ.compile();\n};\n\n/**\n * Render the given `template` of ejs.\n *\n * If you would like to include options but not data, you need to explicitly\n * call this function with `data` being an empty object or `null`.\n *\n * @param {String}   template EJS template\n * @param {Object}  [data={}] template data\n * @param {Options} [opts={}] compilation and rendering options\n * @return {(String|Promise<String>)}\n * Return value type depends on `opts.async`.\n * @public\n */\n\nexports.render = function (template, d, o) {\n  var data = d || utils.createNullProtoObjWherePossible();\n  var opts = o || utils.createNullProtoObjWherePossible();\n\n  // No options object -- if there are optiony names\n  // in the data, copy them to options\n  if (arguments.length == 2) {\n    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);\n  }\n\n  return handleCache(opts, template)(data);\n};\n\n/**\n * Render an EJS file at the given `path` and callback `cb(err, str)`.\n *\n * If you would like to include options but not data, you need to explicitly\n * call this function with `data` being an empty object or `null`.\n *\n * @param {String}             path     path to the EJS file\n * @param {Object}            [data={}] template data\n * @param {Options}           [opts={}] compilation and rendering options\n * @param {RenderFileCallback} cb callback\n * @public\n */\n\nexports.renderFile = function () {\n  var args = Array.prototype.slice.call(arguments);\n  var filename = args.shift();\n  var cb;\n  var opts = {filename: filename};\n  var data;\n  var viewOpts;\n\n  // Do we have a callback?\n  if (typeof arguments[arguments.length - 1] == 'function') {\n    cb = args.pop();\n  }\n  // Do we have data/opts?\n  if (args.length) {\n    // Should always have data obj\n    data = args.shift();\n    // Normal passed opts (data obj + opts obj)\n    if (args.length) {\n      // Use shallowCopy so we don't pollute passed in opts obj with new vals\n      utils.shallowCopy(opts, args.pop());\n    }\n    // Special casing for Express (settings + opts-in-data)\n    else {\n      // Express 3 and 4\n      if (data.settings) {\n        // Pull a few things from known locations\n        if (data.settings.views) {\n          opts.views = data.settings.views;\n        }\n        if (data.settings['view cache']) {\n          opts.cache = true;\n        }\n        // Undocumented after Express 2, but still usable, esp. for\n        // items that are unsafe to be passed along with data, like `root`\n        viewOpts = data.settings['view options'];\n        if (viewOpts) {\n          utils.shallowCopy(opts, viewOpts);\n        }\n      }\n      // Express 2 and lower, values set in app.locals, or people who just\n      // want to pass options in their data. NOTE: These values will override\n      // anything previously set in settings  or settings['view options']\n      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);\n    }\n    opts.filename = filename;\n  }\n  else {\n    data = utils.createNullProtoObjWherePossible();\n  }\n\n  return tryHandleCache(opts, data, cb);\n};\n\n/**\n * Clear intermediate JavaScript cache. Calls {@link Cache#reset}.\n * @public\n */\n\n/**\n * EJS template class\n * @public\n */\nexports.Template = Template;\n\nexports.clearCache = function () {\n  exports.cache.reset();\n};\n\nfunction Template(text, opts) {\n  opts = opts || utils.createNullProtoObjWherePossible();\n  var options = utils.createNullProtoObjWherePossible();\n  this.templateText = text;\n  /** @type {string | null} */\n  this.mode = null;\n  this.truncate = false;\n  this.currentLine = 1;\n  this.source = '';\n  options.client = opts.client || false;\n  options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;\n  options.compileDebug = opts.compileDebug !== false;\n  options.debug = !!opts.debug;\n  options.filename = opts.filename;\n  options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;\n  options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;\n  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;\n  options.strict = opts.strict || false;\n  options.context = opts.context;\n  options.cache = opts.cache || false;\n  options.rmWhitespace = opts.rmWhitespace;\n  options.root = opts.root;\n  options.includer = opts.includer;\n  options.outputFunctionName = opts.outputFunctionName;\n  options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;\n  options.views = opts.views;\n  options.async = opts.async;\n  options.destructuredLocals = opts.destructuredLocals;\n  options.legacyInclude = typeof opts.legacyInclude != 'undefined' ? !!opts.legacyInclude : true;\n\n  if (options.strict) {\n    options._with = false;\n  }\n  else {\n    options._with = typeof opts._with != 'undefined' ? opts._with : true;\n  }\n\n  this.opts = options;\n\n  this.regex = this.createRegex();\n}\n\nTemplate.modes = {\n  EVAL: 'eval',\n  ESCAPED: 'escaped',\n  RAW: 'raw',\n  COMMENT: 'comment',\n  LITERAL: 'literal'\n};\n\nTemplate.prototype = {\n  createRegex: function () {\n    var str = _REGEX_STRING;\n    var delim = utils.escapeRegExpChars(this.opts.delimiter);\n    var open = utils.escapeRegExpChars(this.opts.openDelimiter);\n    var close = utils.escapeRegExpChars(this.opts.closeDelimiter);\n    str = str.replace(/%/g, delim)\n      .replace(/</g, open)\n      .replace(/>/g, close);\n    return new RegExp(str);\n  },\n\n  compile: function () {\n    /** @type {string} */\n    var src;\n    /** @type {ClientFunction} */\n    var fn;\n    var opts = this.opts;\n    var prepended = '';\n    var appended = '';\n    /** @type {EscapeCallback} */\n    var escapeFn = opts.escapeFunction;\n    /** @type {FunctionConstructor} */\n    var ctor;\n    /** @type {string} */\n    var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : 'undefined';\n\n    if (!this.source) {\n      this.generateSource();\n      prepended +=\n        '  var __output = \"\";\\n' +\n        '  function __append(s) { if (s !== undefined && s !== null) __output += s }\\n';\n      if (opts.outputFunctionName) {\n        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {\n          throw new Error('outputFunctionName is not a valid JS identifier.');\n        }\n        prepended += '  var ' + opts.outputFunctionName + ' = __append;' + '\\n';\n      }\n      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {\n        throw new Error('localsName is not a valid JS identifier.');\n      }\n      if (opts.destructuredLocals && opts.destructuredLocals.length) {\n        var destructuring = '  var __locals = (' + opts.localsName + ' || {}),\\n';\n        for (var i = 0; i < opts.destructuredLocals.length; i++) {\n          var name = opts.destructuredLocals[i];\n          if (!_JS_IDENTIFIER.test(name)) {\n            throw new Error('destructuredLocals[' + i + '] is not a valid JS identifier.');\n          }\n          if (i > 0) {\n            destructuring += ',\\n  ';\n          }\n          destructuring += name + ' = __locals.' + name;\n        }\n        prepended += destructuring + ';\\n';\n      }\n      if (opts._with !== false) {\n        prepended +=  '  with (' + opts.localsName + ' || {}) {' + '\\n';\n        appended += '  }' + '\\n';\n      }\n      appended += '  return __output;' + '\\n';\n      this.source = prepended + this.source + appended;\n    }\n\n    if (opts.compileDebug) {\n      src = 'var __line = 1' + '\\n'\n        + '  , __lines = ' + JSON.stringify(this.templateText) + '\\n'\n        + '  , __filename = ' + sanitizedFilename + ';' + '\\n'\n        + 'try {' + '\\n'\n        + this.source\n        + '} catch (e) {' + '\\n'\n        + '  rethrow(e, __lines, __filename, __line, escapeFn);' + '\\n'\n        + '}' + '\\n';\n    }\n    else {\n      src = this.source;\n    }\n\n    if (opts.client) {\n      src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\\n' + src;\n      if (opts.compileDebug) {\n        src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\\n' + src;\n      }\n    }\n\n    if (opts.strict) {\n      src = '\"use strict\";\\n' + src;\n    }\n    if (opts.debug) {\n      console.log(src);\n    }\n    if (opts.compileDebug && opts.filename) {\n      src = src + '\\n'\n        + '//# sourceURL=' + sanitizedFilename + '\\n';\n    }\n\n    try {\n      if (opts.async) {\n        // Have to use generated function for this, since in envs without support,\n        // it breaks in parsing\n        try {\n          ctor = (new Function('return (async function(){}).constructor;'))();\n        }\n        catch(e) {\n          if (e instanceof SyntaxError) {\n            throw new Error('This environment does not support async/await');\n          }\n          else {\n            throw e;\n          }\n        }\n      }\n      else {\n        ctor = Function;\n      }\n      fn = new ctor(opts.localsName + ', escapeFn, include, rethrow', src);\n    }\n    catch(e) {\n      // istanbul ignore else\n      if (e instanceof SyntaxError) {\n        if (opts.filename) {\n          e.message += ' in ' + opts.filename;\n        }\n        e.message += ' while compiling ejs\\n\\n';\n        e.message += 'If the above error is not helpful, you may want to try EJS-Lint:\\n';\n        e.message += 'https://github.com/RyanZim/EJS-Lint';\n        if (!opts.async) {\n          e.message += '\\n';\n          e.message += 'Or, if you meant to create an async function, pass `async: true` as an option.';\n        }\n      }\n      throw e;\n    }\n\n    // Return a callable function which will execute the function\n    // created by the source-code, with the passed data as locals\n    // Adds a local `include` function which allows full recursive include\n    var returnedFn = opts.client ? fn : function anonymous(data) {\n      var include = function (path, includeData) {\n        var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);\n        if (includeData) {\n          d = utils.shallowCopy(d, includeData);\n        }\n        return includeFile(path, opts)(d);\n      };\n      return fn.apply(opts.context,\n        [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);\n    };\n    if (opts.filename && typeof Object.defineProperty === 'function') {\n      var filename = opts.filename;\n      var basename = path.basename(filename, path.extname(filename));\n      try {\n        Object.defineProperty(returnedFn, 'name', {\n          value: basename,\n          writable: false,\n          enumerable: false,\n          configurable: true\n        });\n      } catch (e) {/* ignore */}\n    }\n    return returnedFn;\n  },\n\n  generateSource: function () {\n    var opts = this.opts;\n\n    if (opts.rmWhitespace) {\n      // Have to use two separate replace here as `^` and `$` operators don't\n      // work well with `\\r` and empty lines don't work well with the `m` flag.\n      this.templateText =\n        this.templateText.replace(/[\\r\\n]+/g, '\\n').replace(/^\\s+|\\s+$/gm, '');\n    }\n\n    // Slurp spaces and tabs before <%_ and after _%>\n    this.templateText =\n      this.templateText.replace(/[ \\t]*<%_/gm, '<%_').replace(/_%>[ \\t]*/gm, '_%>');\n\n    var self = this;\n    var matches = this.parseTemplateText();\n    var d = this.opts.delimiter;\n    var o = this.opts.openDelimiter;\n    var c = this.opts.closeDelimiter;\n\n    if (matches && matches.length) {\n      matches.forEach(function (line, index) {\n        var closing;\n        // If this is an opening tag, check for closing tags\n        // FIXME: May end up with some false positives here\n        // Better to store modes as k/v with openDelimiter + delimiter as key\n        // Then this can simply check against the map\n        if ( line.indexOf(o + d) === 0        // If it is a tag\n          && line.indexOf(o + d + d) !== 0) { // and is not escaped\n          closing = matches[index + 2];\n          if (!(closing == d + c || closing == '-' + d + c || closing == '_' + d + c)) {\n            throw new Error('Could not find matching close tag for \"' + line + '\".');\n          }\n        }\n        self.scanLine(line);\n      });\n    }\n\n  },\n\n  parseTemplateText: function () {\n    var str = this.templateText;\n    var pat = this.regex;\n    var result = pat.exec(str);\n    var arr = [];\n    var firstPos;\n\n    while (result) {\n      firstPos = result.index;\n\n      if (firstPos !== 0) {\n        arr.push(str.substring(0, firstPos));\n        str = str.slice(firstPos);\n      }\n\n      arr.push(result[0]);\n      str = str.slice(result[0].length);\n      result = pat.exec(str);\n    }\n\n    if (str) {\n      arr.push(str);\n    }\n\n    return arr;\n  },\n\n  _addOutput: function (line) {\n    if (this.truncate) {\n      // Only replace single leading linebreak in the line after\n      // -%> tag -- this is the single, trailing linebreak\n      // after the tag that the truncation mode replaces\n      // Handle Win / Unix / old Mac linebreaks -- do the \\r\\n\n      // combo first in the regex-or\n      line = line.replace(/^(?:\\r\\n|\\r|\\n)/, '');\n      this.truncate = false;\n    }\n    if (!line) {\n      return line;\n    }\n\n    // Preserve literal slashes\n    line = line.replace(/\\\\/g, '\\\\\\\\');\n\n    // Convert linebreaks\n    line = line.replace(/\\n/g, '\\\\n');\n    line = line.replace(/\\r/g, '\\\\r');\n\n    // Escape double-quotes\n    // - this will be the delimiter during execution\n    line = line.replace(/\"/g, '\\\\\"');\n    this.source += '    ; __append(\"' + line + '\")' + '\\n';\n  },\n\n  scanLine: function (line) {\n    var self = this;\n    var d = this.opts.delimiter;\n    var o = this.opts.openDelimiter;\n    var c = this.opts.closeDelimiter;\n    var newLineCount = 0;\n\n    newLineCount = (line.split('\\n').length - 1);\n\n    switch (line) {\n    case o + d:\n    case o + d + '_':\n      this.mode = Template.modes.EVAL;\n      break;\n    case o + d + '=':\n      this.mode = Template.modes.ESCAPED;\n      break;\n    case o + d + '-':\n      this.mode = Template.modes.RAW;\n      break;\n    case o + d + '#':\n      this.mode = Template.modes.COMMENT;\n      break;\n    case o + d + d:\n      this.mode = Template.modes.LITERAL;\n      this.source += '    ; __append(\"' + line.replace(o + d + d, o + d) + '\")' + '\\n';\n      break;\n    case d + d + c:\n      this.mode = Template.modes.LITERAL;\n      this.source += '    ; __append(\"' + line.replace(d + d + c, d + c) + '\")' + '\\n';\n      break;\n    case d + c:\n    case '-' + d + c:\n    case '_' + d + c:\n      if (this.mode == Template.modes.LITERAL) {\n        this._addOutput(line);\n      }\n\n      this.mode = null;\n      this.truncate = line.indexOf('-') === 0 || line.indexOf('_') === 0;\n      break;\n    default:\n      // In script mode, depends on type of tag\n      if (this.mode) {\n        // If '//' is found without a line break, add a line break.\n        switch (this.mode) {\n        case Template.modes.EVAL:\n        case Template.modes.ESCAPED:\n        case Template.modes.RAW:\n          if (line.lastIndexOf('//') > line.lastIndexOf('\\n')) {\n            line += '\\n';\n          }\n        }\n        switch (this.mode) {\n        // Just executing code\n        case Template.modes.EVAL:\n          this.source += '    ; ' + line + '\\n';\n          break;\n          // Exec, esc, and output\n        case Template.modes.ESCAPED:\n          this.source += '    ; __append(escapeFn(' + stripSemi(line) + '))' + '\\n';\n          break;\n          // Exec and output\n        case Template.modes.RAW:\n          this.source += '    ; __append(' + stripSemi(line) + ')' + '\\n';\n          break;\n        case Template.modes.COMMENT:\n          // Do nothing\n          break;\n          // Literal <%% mode, append as raw output\n        case Template.modes.LITERAL:\n          this._addOutput(line);\n          break;\n        }\n      }\n      // In string mode, just add the output\n      else {\n        this._addOutput(line);\n      }\n    }\n\n    if (self.opts.compileDebug && newLineCount) {\n      this.currentLine += newLineCount;\n      this.source += '    ; __line = ' + this.currentLine + '\\n';\n    }\n  }\n};\n\n/**\n * Escape characters reserved in XML.\n *\n * This is simply an export of {@link module:utils.escapeXML}.\n *\n * If `markup` is `undefined` or `null`, the empty string is returned.\n *\n * @param {String} markup Input string\n * @return {String} Escaped string\n * @public\n * @func\n * */\nexports.escapeXML = utils.escapeXML;\n\n/**\n * Express.js support.\n *\n * This is an alias for {@link module:ejs.renderFile}, in order to support\n * Express.js out-of-the-box.\n *\n * @func\n */\n\nexports.__express = exports.renderFile;\n\n/**\n * Version of EJS.\n *\n * @readonly\n * @type {String}\n * @public\n */\n\nexports.VERSION = _VERSION_STRING;\n\n/**\n * Name for detection of EJS.\n *\n * @readonly\n * @type {String}\n * @public\n */\n\nexports.name = _NAME;\n\n/* istanbul ignore if */\nif (typeof window != 'undefined') {\n  window.ejs = exports;\n}\n\n\n/***/ }),\n\n/***/ 1176:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n/*\n * EJS Embedded JavaScript templates\n * Copyright 2112 Matthew Eernisse (mde@fleegix.org)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n*/\n\n/**\n * Private utility functions\n * @module utils\n * @private\n */\n\n\n\nvar regExpChars = /[|\\\\{}()[\\]^$+*?.]/g;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); };\n\n/**\n * Escape characters reserved in regular expressions.\n *\n * If `string` is `undefined` or `null`, the empty string is returned.\n *\n * @param {String} string Input string\n * @return {String} Escaped string\n * @static\n * @private\n */\nexports.escapeRegExpChars = function (string) {\n  // istanbul ignore if\n  if (!string) {\n    return '';\n  }\n  return String(string).replace(regExpChars, '\\\\$&');\n};\n\nvar _ENCODE_HTML_RULES = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&#34;',\n  \"'\": '&#39;'\n};\nvar _MATCH_HTML = /[&<>'\"]/g;\n\nfunction encode_char(c) {\n  return _ENCODE_HTML_RULES[c] || c;\n}\n\n/**\n * Stringified version of constants used by {@link module:utils.escapeXML}.\n *\n * It is used in the process of generating {@link ClientFunction}s.\n *\n * @readonly\n * @type {String}\n */\n\nvar escapeFuncStr =\n  'var _ENCODE_HTML_RULES = {\\n'\n+ '      \"&\": \"&amp;\"\\n'\n+ '    , \"<\": \"&lt;\"\\n'\n+ '    , \">\": \"&gt;\"\\n'\n+ '    , \\'\"\\': \"&#34;\"\\n'\n+ '    , \"\\'\": \"&#39;\"\\n'\n+ '    }\\n'\n+ '  , _MATCH_HTML = /[&<>\\'\"]/g;\\n'\n+ 'function encode_char(c) {\\n'\n+ '  return _ENCODE_HTML_RULES[c] || c;\\n'\n+ '};\\n';\n\n/**\n * Escape characters reserved in XML.\n *\n * If `markup` is `undefined` or `null`, the empty string is returned.\n *\n * @implements {EscapeCallback}\n * @param {String} markup Input string\n * @return {String} Escaped string\n * @static\n * @private\n */\n\nexports.escapeXML = function (markup) {\n  return markup == undefined\n    ? ''\n    : String(markup)\n      .replace(_MATCH_HTML, encode_char);\n};\n\nfunction escapeXMLToString() {\n  return Function.prototype.toString.call(this) + ';\\n' + escapeFuncStr;\n}\n\ntry {\n  if (typeof Object.defineProperty === 'function') {\n  // If the Function prototype is frozen, the \"toString\" property is non-writable. This means that any objects which inherit this property\n  // cannot have the property changed using an assignment. If using strict mode, attempting that will cause an error. If not using strict\n  // mode, attempting that will be silently ignored.\n  // However, we can still explicitly shadow the prototype's \"toString\" property by defining a new \"toString\" property on this object.\n    Object.defineProperty(exports.escapeXML, 'toString', { value: escapeXMLToString });\n  } else {\n    // If Object.defineProperty() doesn't exist, attempt to shadow this property using the assignment operator.\n    exports.escapeXML.toString = escapeXMLToString;\n  }\n} catch (err) {\n  console.warn('Unable to set escapeXML.toString (is the Function prototype frozen?)');\n}\n\n/**\n * Naive copy of properties from one object to another.\n * Does not recurse into non-scalar properties\n * Does not check to see if the property has a value before copying\n *\n * @param  {Object} to   Destination object\n * @param  {Object} from Source object\n * @return {Object}      Destination object\n * @static\n * @private\n */\nexports.shallowCopy = function (to, from) {\n  from = from || {};\n  if ((to !== null) && (to !== undefined)) {\n    for (var p in from) {\n      if (!hasOwn(from, p)) {\n        continue;\n      }\n      if (p === '__proto__' || p === 'constructor') {\n        continue;\n      }\n      to[p] = from[p];\n    }\n  }\n  return to;\n};\n\n/**\n * Naive copy of a list of key names, from one object to another.\n * Only copies property if it is actually defined\n * Does not recurse into non-scalar properties\n *\n * @param  {Object} to   Destination object\n * @param  {Object} from Source object\n * @param  {Array} list List of properties to copy\n * @return {Object}      Destination object\n * @static\n * @private\n */\nexports.shallowCopyFromList = function (to, from, list) {\n  list = list || [];\n  from = from || {};\n  if ((to !== null) && (to !== undefined)) {\n    for (var i = 0; i < list.length; i++) {\n      var p = list[i];\n      if (typeof from[p] != 'undefined') {\n        if (!hasOwn(from, p)) {\n          continue;\n        }\n        if (p === '__proto__' || p === 'constructor') {\n          continue;\n        }\n        to[p] = from[p];\n      }\n    }\n  }\n  return to;\n};\n\n/**\n * Simple in-process cache implementation. Does not implement limits of any\n * sort.\n *\n * @implements {Cache}\n * @static\n * @private\n */\nexports.cache = {\n  _data: {},\n  set: function (key, val) {\n    this._data[key] = val;\n  },\n  get: function (key) {\n    return this._data[key];\n  },\n  remove: function (key) {\n    delete this._data[key];\n  },\n  reset: function () {\n    this._data = {};\n  }\n};\n\n/**\n * Transforms hyphen case variable into camel case.\n *\n * @param {String} string Hyphen case string\n * @return {String} Camel case string\n * @static\n * @private\n */\nexports.hyphenToCamel = function (str) {\n  return str.replace(/-[a-z]/g, function (match) { return match[1].toUpperCase(); });\n};\n\n/**\n * Returns a null-prototype object in runtimes that support it\n *\n * @return {Object} Object, prototype will be set to null where possible\n * @static\n * @private\n */\nexports.createNullProtoObjWherePossible = (function () {\n  if (typeof Object.create == 'function') {\n    return function () {\n      return Object.create(null);\n    };\n  }\n  if (!({__proto__: null} instanceof Object)) {\n    return function () {\n      return {__proto__: null};\n    };\n  }\n  // Not possible, just pass through\n  return function () {\n    return {};\n  };\n})();\n\n\n\n\n/***/ }),\n\n/***/ 7187:\n/***/ ((module) => {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n\n\n/***/ }),\n\n/***/ 9755:\n/***/ (function(module, exports) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * jQuery JavaScript Library v3.7.0\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2023-05-11T18:29Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif (  true && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML <object> elements\n\t\t// (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n\t\t// We don't want to classify *any* DOM node as a function.\n\t\t// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n\t\t// Plus for old WebKit, typeof returns \"function\" for HTML collections\n\t\t// (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n\t\treturn typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\n\t\t\ttypeof obj.item !== \"function\";\n\t};\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n/* global Symbol */\n// Defining this global in .eslintrc.json would create a danger of using the global\n// unguarded in another place, it seems safer to define global only for this module\n\n\n\nvar version = \"3.7.0\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\n\nfunction nodeName( elem, name ) {\n\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n}\nvar pop = arr.pop;\n\n\nvar sort = arr.sort;\n\n\nvar splice = arr.splice;\n\n\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n\n\n\n// Note: an element does not contain itself\njQuery.contains = function( a, b ) {\n\tvar bup = b && b.parentNode;\n\n\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE doesn't have `contains` on SVG.\n\t\ta.contains ?\n\t\t\ta.contains( bup ) :\n\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t) );\n};\n\n\n\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\n\n\n\nvar preferredDoc = document,\n\tpushNative = push;\n\n( function() {\n\nvar i,\n\tExpr,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\tpush = pushNative,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\tmatches,\n\n\t// Instance-specific data\n\texpando = jQuery.expando,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|\" +\n\t\t\"loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" +\n\t\twhitespace + \"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\t\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\tATTR: new RegExp( \"^\" + attributes ),\n\t\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\t\tCHILD: new RegExp(\n\t\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\tbool: new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE/Edge.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android <=4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = {\n\t\tapply: function( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t},\n\t\tcall: function( target ) {\n\t\t\tpushNative.apply( target, slice.call( arguments, 1 ) );\n\t\t}\n\t};\n}\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tfind.contains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when\n\t\t\t\t\t// strict-comparing two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: iOS 7 only, IE 9 - 11+\n\t// Older browsers didn't support unprefixed `matches`.\n\tmatches = documentElement.matches ||\n\t\tdocumentElement.webkitMatchesSelector ||\n\t\tdocumentElement.msMatchesSelector;\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (see trac-13936)\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( preferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n\n\t// Support: IE <10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocumentElement.appendChild( el ).id = jQuery.expando;\n\t\treturn !document.getElementsByName ||\n\t\t\t!document.getElementsByName( jQuery.expando ).length;\n\t} );\n\n\t// Support: IE 9 only\n\t// Check to see if it's possible to do matchesSelector\n\t// on a disconnected node.\n\tsupport.disconnectedMatch = assert( function( el ) {\n\t\treturn matches.call( el, \"*\" );\n\t} );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// IE/Edge don't support the :scope pseudo-class.\n\tsupport.scope = assert( function() {\n\t\treturn document.querySelectorAll( \":scope\" );\n\t} );\n\n\t// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only\n\t// Make sure the `:has()` argument is parsed unforgivingly.\n\t// We include `*` in the test to detect buggy implementations that are\n\t// _selectively_ forgiving (specifically when the list includes at least\n\t// one valid selector).\n\t// Note that we treat complete lack of support for `:has()` as if it were\n\t// spec-compliant support, which is fine because use of `:has()` in such\n\t// environments will fail in the qSA path and fall back to jQuery traversal\n\t// anyway.\n\tsupport.cssHas = assert( function() {\n\t\ttry {\n\t\t\tdocument.querySelector( \":has(*,:jqfake)\" );\n\t\t\treturn false;\n\t\t} catch ( e ) {\n\t\t\treturn true;\n\t\t}\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter.ID = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter.ID =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find.TAG = function( tag, context ) {\n\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t// DocumentFragment nodes don't have gEBTN\n\t\t} else {\n\t\t\treturn context.querySelectorAll( tag );\n\t\t}\n\t};\n\n\t// Class\n\tExpr.find.CLASS = function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\trbuggyQSA = [];\n\n\t// Build QSA regex\n\t// Regex strategy adopted from Diego Perini\n\tassert( function( el ) {\n\n\t\tvar input;\n\n\t\tdocumentElement.appendChild( el ).innerHTML =\n\t\t\t\"<a id='\" + expando + \"' href='' disabled='disabled'></a>\" +\n\t\t\t\"<select id='\" + expando + \"-\\r\\\\' disabled='disabled'>\" +\n\t\t\t\"<option selected=''></option></select>\";\n\n\t\t// Support: iOS <=7 - 8 only\n\t\t// Boolean attributes and \"value\" are not treated correctly in some XML documents\n\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t}\n\n\t\t// Support: iOS <=7 - 8 only\n\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\trbuggyQSA.push( \"~=\" );\n\t\t}\n\n\t\t// Support: iOS 8 only\n\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t}\n\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\trbuggyQSA.push( \":checked\" );\n\t\t}\n\n\t\t// Support: Windows 8 Native Apps\n\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tdocumentElement.appendChild( el ).disabled = true;\n\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t}\n\n\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t// Adding a temporary attribute to the document before the selection works\n\t\t// around the issue.\n\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"name\", \"\" );\n\t\tel.appendChild( input );\n\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t}\n\t} );\n\n\tif ( !support.cssHas ) {\n\n\t\t// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t\t// Our regular `try-catch` mechanism fails to detect natively-unsupported\n\t\t// pseudo-classes inside `:has()` (such as `:has(:contains(\"Foo\"))`)\n\t\t// in browsers that parse the `:has()` argument as a forgiving selector list.\n\t\t// https://drafts.csswg.org/selectors/#relational now requires the argument\n\t\t// to be parsed unforgivingly, but browsers have not yet fully adjusted.\n\t\trbuggyQSA.push( \":has\" );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = function( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a === document || a.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b === document || b.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t};\n\n\treturn document;\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\nfind.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn jQuery.contains( context, elem );\n};\n\n\nfind.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (see trac-13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\tif ( val !== undefined ) {\n\t\treturn val;\n\t}\n\n\treturn elem.getAttribute( name );\n};\n\nfind.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\t//\n\t// Support: Android <=4.0+\n\t// Testing for detecting duplicates is unpredictable so instead assume we can't\n\t// depend on duplicate detection in all browsers without a stable sort.\n\thasDuplicate = !support.sortStable;\n\tsortInput = !support.sortStable && slice.call( results, 0 );\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nExpr = jQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\tATTR: function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" )\n\t\t\t\t.replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\tCHILD: function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t\t);\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\tPSEUDO: function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = find.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ expando ] || ( parent[ expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tfind.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf.call( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tfind.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === safeActiveElement() &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !Expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\" &&\n\n\t\t\t\t// Support: IE <10 only\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear\n\t\t\t\t// with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos.nth = Expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tfind.error( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: iOS <=7 - 9 only\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching\n\t\t\t// elements by id. (see trac-14142)\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find.ID(\n\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// One-time assignments\n\n// Support: Android <=4.0 - 4.1+\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Android <=4.0 - 4.1+\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\njQuery.find = find;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.unique = jQuery.uniqueSort;\n\n// These have always been private, but they used to be documented\n// as part of Sizzle so let's maintain them in the 3.x line\n// for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\n\nfind.escape = jQuery.escapeSelector;\nfind.getText = jQuery.text;\nfind.isXML = jQuery.isXMLDoc;\nfind.selectors = jQuery.expr;\nfind.support = jQuery.support;\nfind.uniqueSort = jQuery.uniqueSort;\n\n\t/* eslint-enable */\n\n} )();\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\n\t\t\t\t\t\t\t\t// The deprecated alias of the above. While the name suggests\n\t\t\t\t\t\t\t\t// returning the stack, not an error instance, jQuery just passes\n\t\t\t\t\t\t\t\t// it directly to `console.warn` so both will work; an instance\n\t\t\t\t\t\t\t\t// just better cooperates with source maps.\n\t\t\t\t\t\t\t\t} else if ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message,\n\t\t\terror.stack, asyncError );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\n// Support: IE <=9 - 10 only\n// Older IE sometimes signals \"interactive\" too soon\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase; used by the css and data modules\n// Support: IE <=9 - 11, Edge 12 - 15\n// Microsoft forgot to hump their vendor prefix (trac-9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (trac-11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (trac-14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (trac-13200)\nvar wrapMap = {\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering\n\t\t\t\t// the native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, jQuery.event.trigger(\n\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\tthis\n\t\t\t\t) );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (trac-504, trac-13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\tfunction focusMappedHandler( nativeEvent ) {\n\t\tif ( document.documentMode ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// Attach a single focusin/focusout handler on the document while someone wants\n\t\t\t// focus/blur. This is because the former are synchronous in IE while the latter\n\t\t\t// are async. In other browsers, all those handlers are invoked synchronously.\n\n\t\t\t// `handle` from private data would already wrap the event, but we need\n\t\t\t// to change the `type` here.\n\t\t\tvar handle = dataPriv.get( this, \"handle\" ),\n\t\t\t\tevent = jQuery.event.fix( nativeEvent );\n\t\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\t\tevent.isSimulated = true;\n\n\t\t\t// First, handle focusin/focusout\n\t\t\thandle( nativeEvent );\n\n\t\t\t// ...then, handle focus/blur\n\t\t\t//\n\t\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t\t// invoking the handler at the lower level.\n\t\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t\t// by this point.\n\t\t\t\thandle( event );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// For non-IE browsers, attach a single capturing handler on the document\n\t\t\t// while someone wants focusin/focusout.\n\t\t\tjQuery.event.simulate( delegateType, nativeEvent.target,\n\t\t\t\tjQuery.event.fix( nativeEvent ) );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\tvar attaches;\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( document.documentMode ) {\n\n\t\t\t\t// Support: IE 9 - 11+\n\t\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\t\tattaches = dataPriv.get( this, delegateType );\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t}\n\t\t\t\tdataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tvar attaches;\n\n\t\t\tif ( document.documentMode ) {\n\t\t\t\tattaches = dataPriv.get( this, delegateType ) - 1;\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t\tdataPriv.remove( this, delegateType );\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.set( this, delegateType, attaches );\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n\n\t// Support: Firefox <=44\n\t// Firefox doesn't have focus(in | out) events\n\t// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n\t//\n\t// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n\t// focus(in | out) events fire after focus & blur events,\n\t// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n\t// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\t//\n\t// Support: IE 9 - 11+\n\t// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,\n\t// attach a single handler for both events in IE.\n\tjQuery.event.special[ delegateType ] = {\n\t\tsetup: function() {\n\n\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType );\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.addEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t}\n\t\t\tdataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );\n\t\t},\n\t\tteardown: function() {\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType ) - 1;\n\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.removeEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( dataHolder, delegateType );\n\t\t\t} else {\n\t\t\t\tdataPriv.set( dataHolder, delegateType, attaches );\n\t\t\t}\n\t\t}\n\t};\n} );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\n\trcleanScript = /^\\s*<!\\[CDATA\\[|\\]\\]>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle events\" );\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Unwrap a CDATA section containing script contents. This shouldn't be\n\t\t\t\t\t\t\t// needed as in XML documents they're already not visible when\n\t\t\t\t\t\t\t// inspecting element contents and in HTML documents they have no\n\t\t\t\t\t\t\t// meaning but we're preserving that logic for backwards compatibility.\n\t\t\t\t\t\t\t// This will be removed completely in 4.0. See gh-4904.\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && isAttached( node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html;\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = isAttached( elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew jQuery#find here for performance reasons:\n\t\t\t// https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (trac-8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\t//\n\t\t// Support: Firefox 70+\n\t\t// Only Firefox includes border widths\n\t\t// in computed dimensions. (gh-4529)\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n\t\t\t\ttr.style.cssText = \"border:1px solid\";\n\n\t\t\t\t// Support: Chrome 86+\n\t\t\t\t// Height set through cssText does not get applied.\n\t\t\t\t// Computed height then comes back as 0.\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\t// Support: Android 8 Chrome 86+\n\t\t\t\t// In our bodyBackground.html iframe,\n\t\t\t\t// display for all div elements is set to \"inline\",\n\t\t\t\t// which causes a problem only in Android 8 Chrome 86.\n\t\t\t\t// Ensuring the div is display: block\n\t\t\t\t// gets around this issue.\n\t\t\t\ttrChild.style.display = \"block\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderTopWidth, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tisCustomProp = rcustomProp.test( name ),\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, trac-12537)\n\t//   .css('--customProperty) (gh-3144)\n\tif ( computed ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105+, Chrome <=105+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace. Chrome just collapses\n\t\t\t// both leading & trailing whitespace to a single space.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\tanimationIterationCount: true,\n\t\taspectRatio: true,\n\t\tborderImageSlice: true,\n\t\tcolumnCount: true,\n\t\tflexGrow: true,\n\t\tflexShrink: true,\n\t\tfontWeight: true,\n\t\tgridArea: true,\n\t\tgridColumn: true,\n\t\tgridColumnEnd: true,\n\t\tgridColumnStart: true,\n\t\tgridRow: true,\n\t\tgridRowEnd: true,\n\t\tgridRowStart: true,\n\t\tlineHeight: true,\n\t\topacity: true,\n\t\torder: true,\n\t\torphans: true,\n\t\tscale: true,\n\t\twidows: true,\n\t\tzIndex: true,\n\t\tzoom: true,\n\n\t\t// SVG-related\n\t\tfillOpacity: true,\n\t\tfloodOpacity: true,\n\t\tstopOpacity: true,\n\t\tstrokeMiterlimit: true,\n\t\tstrokeOpacity: true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\n// eslint rule \"no-unused-expressions\" is disabled for this code\n// since it considers such accessions noop\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self,\n\t\t\ttype = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\treturn this.each( function() {\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (trac-2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\n\t\t\t\t\tuncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// trac-1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Support: Safari 8 only\n// In Safari 8 documents created via document.implementation.createHTMLDocument\n// collapse sibling forms: the second one becomes a child of the first one.\n// Because of that, this security measure has to be disabled in Safari 8.\n// https://bugs.webkit.org/show_bug.cgi?id=137337\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( {\n\t\tpadding: \"inner\" + name,\n\t\tcontent: type,\n\t\t\"\": \"outer\" + name\n\t}, function( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( _i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\njQuery.each(\n\t( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( _i, name ) {\n\n\t\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t}\n);\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\n// Require that the \"whitespace run\" starts from a non-whitespace\n// to avoid O(N^2) behavior when the engine would try matching \"\\s+$\" at each space position.\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|([^\\s\\uFEFF\\xA0])[\\s\\uFEFF\\xA0]+$/g;\n\n// Bind a function to a context, optionally partially applying any\n// arguments.\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n// However, it is not slated for removal any time soon\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"$1\" );\n};\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( true ) {\n\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {\n\t\treturn jQuery;\n\t}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (trac-13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n\n\n/***/ }),\n\n/***/ 8337:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Helpers\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\nfunction isString(obj) { return _class(obj) === '[object String]'; }\nfunction isObject(obj) { return _class(obj) === '[object Object]'; }\nfunction isRegExp(obj) { return _class(obj) === '[object RegExp]'; }\nfunction isFunction(obj) { return _class(obj) === '[object Function]'; }\n\n\nfunction escapeRE(str) { return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&'); }\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n};\n\n\nfunction isOptionsObj(obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    return acc || defaultOptions.hasOwnProperty(k);\n  }, false);\n}\n\n\nvar defaultSchemas = {\n  'http:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.http =  new RegExp(\n          '^\\\\/\\\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i'\n        );\n      }\n      if (self.re.http.test(tail)) {\n        return tail.match(self.re.http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'https:':  'http:',\n  'ftp:':    'http:',\n  '//':      {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.no_http) {\n      // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.no_http =  new RegExp(\n          '^' +\n          self.re.src_auth +\n          // Don't allow single-level domains, because of false positives like '//test'\n          // with code comments\n          '(?:localhost|(?:(?:' + self.re.src_domain + ')\\\\.)+' + self.re.src_domain_root + ')' +\n          self.re.src_port +\n          self.re.src_host_terminator +\n          self.re.src_path,\n\n          'i'\n        );\n      }\n\n      if (self.re.no_http.test(tail)) {\n        // should not be `://` & `///`, that protects from errors in protocol name\n        if (pos >= 3 && text[pos - 3] === ':') { return 0; }\n        if (pos >= 3 && text[pos - 3] === '/') { return 0; }\n        return tail.match(self.re.no_http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'mailto:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.mailto) {\n        self.re.mailto =  new RegExp(\n          '^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i'\n        );\n      }\n      if (self.re.mailto.test(tail)) {\n        return tail.match(self.re.mailto)[0].length;\n      }\n      return 0;\n    }\n  }\n};\n\n/*eslint-disable max-len*/\n\n// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\nvar tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';\n\n// DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead\nvar tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');\n\n/*eslint-enable max-len*/\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction resetScanCache(self) {\n  self.__index__ = -1;\n  self.__text_cache__   = '';\n}\n\nfunction createValidator(re) {\n  return function (text, pos) {\n    var tail = text.slice(pos);\n\n    if (re.test(tail)) {\n      return tail.match(re)[0].length;\n    }\n    return 0;\n  };\n}\n\nfunction createNormalizer() {\n  return function (match, self) {\n    self.normalize(match);\n  };\n}\n\n// Schemas compiler. Build regexps.\n//\nfunction compile(self) {\n\n  // Load & clone RE patterns.\n  var re = self.re = __webpack_require__(6066)(self.__opts__);\n\n  // Define dynamic patterns\n  var tlds = self.__tlds__.slice();\n\n  self.onCompile();\n\n  if (!self.__tlds_replaced__) {\n    tlds.push(tlds_2ch_src_re);\n  }\n  tlds.push(re.src_xn);\n\n  re.src_tlds = tlds.join('|');\n\n  function untpl(tpl) { return tpl.replace('%TLDS%', re.src_tlds); }\n\n  re.email_fuzzy      = RegExp(untpl(re.tpl_email_fuzzy), 'i');\n  re.link_fuzzy       = RegExp(untpl(re.tpl_link_fuzzy), 'i');\n  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');\n  re.host_fuzzy_test  = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');\n\n  //\n  // Compile each schema\n  //\n\n  var aliases = [];\n\n  self.__compiled__ = {}; // Reset compiled data\n\n  function schemaError(name, val) {\n    throw new Error('(LinkifyIt) Invalid schema \"' + name + '\": ' + val);\n  }\n\n  Object.keys(self.__schemas__).forEach(function (name) {\n    var val = self.__schemas__[name];\n\n    // skip disabled methods\n    if (val === null) { return; }\n\n    var compiled = { validate: null, link: null };\n\n    self.__compiled__[name] = compiled;\n\n    if (isObject(val)) {\n      if (isRegExp(val.validate)) {\n        compiled.validate = createValidator(val.validate);\n      } else if (isFunction(val.validate)) {\n        compiled.validate = val.validate;\n      } else {\n        schemaError(name, val);\n      }\n\n      if (isFunction(val.normalize)) {\n        compiled.normalize = val.normalize;\n      } else if (!val.normalize) {\n        compiled.normalize = createNormalizer();\n      } else {\n        schemaError(name, val);\n      }\n\n      return;\n    }\n\n    if (isString(val)) {\n      aliases.push(name);\n      return;\n    }\n\n    schemaError(name, val);\n  });\n\n  //\n  // Compile postponed aliases\n  //\n\n  aliases.forEach(function (alias) {\n    if (!self.__compiled__[self.__schemas__[alias]]) {\n      // Silently fail on missed schemas to avoid errons on disable.\n      // schemaError(alias, self.__schemas__[alias]);\n      return;\n    }\n\n    self.__compiled__[alias].validate =\n      self.__compiled__[self.__schemas__[alias]].validate;\n    self.__compiled__[alias].normalize =\n      self.__compiled__[self.__schemas__[alias]].normalize;\n  });\n\n  //\n  // Fake record for guessed links\n  //\n  self.__compiled__[''] = { validate: null, normalize: createNormalizer() };\n\n  //\n  // Build schema condition\n  //\n  var slist = Object.keys(self.__compiled__)\n                      .filter(function (name) {\n                        // Filter disabled & fake schemas\n                        return name.length > 0 && self.__compiled__[name];\n                      })\n                      .map(escapeRE)\n                      .join('|');\n  // (?!_) cause 1.5x slowdown\n  self.re.schema_test     = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search   = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');\n  self.re.schema_at_start = RegExp('^' + self.re.schema_search.source, 'i');\n\n  self.re.pretest = RegExp(\n    '(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@',\n    'i'\n  );\n\n  //\n  // Cleanup\n  //\n\n  resetScanCache(self);\n}\n\n/**\n * class Match\n *\n * Match result. Single element of array, returned by [[LinkifyIt#match]]\n **/\nfunction Match(self, shift) {\n  var start = self.__index__,\n      end   = self.__last_index__,\n      text  = self.__text_cache__.slice(start, end);\n\n  /**\n   * Match#schema -> String\n   *\n   * Prefix (protocol) for matched string.\n   **/\n  this.schema    = self.__schema__.toLowerCase();\n  /**\n   * Match#index -> Number\n   *\n   * First position of matched string.\n   **/\n  this.index     = start + shift;\n  /**\n   * Match#lastIndex -> Number\n   *\n   * Next position after matched string.\n   **/\n  this.lastIndex = end + shift;\n  /**\n   * Match#raw -> String\n   *\n   * Matched string.\n   **/\n  this.raw       = text;\n  /**\n   * Match#text -> String\n   *\n   * Notmalized text of matched string.\n   **/\n  this.text      = text;\n  /**\n   * Match#url -> String\n   *\n   * Normalized url of matched string.\n   **/\n  this.url       = text;\n}\n\nfunction createMatch(self, shift) {\n  var match = new Match(self, shift);\n\n  self.__compiled__[match.schema].normalize(match, self);\n\n  return match;\n}\n\n\n/**\n * class LinkifyIt\n **/\n\n/**\n * new LinkifyIt(schemas, options)\n * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Creates new linkifier instance with optional additional schemas.\n * Can be called without `new` keyword for convenience.\n *\n * By default understands:\n *\n * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n * - \"fuzzy\" links and emails (example.com, foo@bar.com).\n *\n * `schemas` is an object, where each key/value describes protocol/rule:\n *\n * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`\n *   for example). `linkify-it` makes shure that prefix is not preceeded with\n *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.\n * - __value__ - rule to check tail after link prefix\n *   - _String_ - just alias to existing rule\n *   - _Object_\n *     - _validate_ - validator function (should return matched length on success),\n *       or `RegExp`.\n *     - _normalize_ - optional function to normalize text & url of matched result\n *       (for example, for @twitter mentions).\n *\n * `options`:\n *\n * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.\n * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts\n *   like version numbers. Default `false`.\n * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.\n *\n **/\nfunction LinkifyIt(schemas, options) {\n  if (!(this instanceof LinkifyIt)) {\n    return new LinkifyIt(schemas, options);\n  }\n\n  if (!options) {\n    if (isOptionsObj(schemas)) {\n      options = schemas;\n      schemas = {};\n    }\n  }\n\n  this.__opts__           = assign({}, defaultOptions, options);\n\n  // Cache last tested result. Used to skip repeating steps on next `match` call.\n  this.__index__          = -1;\n  this.__last_index__     = -1; // Next scan position\n  this.__schema__         = '';\n  this.__text_cache__     = '';\n\n  this.__schemas__        = assign({}, defaultSchemas, schemas);\n  this.__compiled__       = {};\n\n  this.__tlds__           = tlds_default;\n  this.__tlds_replaced__  = false;\n\n  this.re = {};\n\n  compile(this);\n}\n\n\n/** chainable\n * LinkifyIt#add(schema, definition)\n * - schema (String): rule name (fixed pattern prefix)\n * - definition (String|RegExp|Object): schema definition\n *\n * Add new rule definition. See constructor description for details.\n **/\nLinkifyIt.prototype.add = function add(schema, definition) {\n  this.__schemas__[schema] = definition;\n  compile(this);\n  return this;\n};\n\n\n/** chainable\n * LinkifyIt#set(options)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Set recognition options for links without schema.\n **/\nLinkifyIt.prototype.set = function set(options) {\n  this.__opts__ = assign(this.__opts__, options);\n  return this;\n};\n\n\n/**\n * LinkifyIt#test(text) -> Boolean\n *\n * Searches linkifiable pattern and returns `true` on success or `false` on fail.\n **/\nLinkifyIt.prototype.test = function test(text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__      = -1;\n\n  if (!text.length) { return false; }\n\n  var m, ml, me, len, shift, next, re, tld_pos, at_pos;\n\n  // try to scan for link with schema - that's the most simple rule\n  if (this.re.schema_test.test(text)) {\n    re = this.re.schema_search;\n    re.lastIndex = 0;\n    while ((m = re.exec(text)) !== null) {\n      len = this.testSchemaAt(text, m[2], re.lastIndex);\n      if (len) {\n        this.__schema__     = m[2];\n        this.__index__      = m.index + m[1].length;\n        this.__last_index__ = m.index + m[0].length + len;\n        break;\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {\n    // guess schemaless links\n    tld_pos = text.search(this.re.host_fuzzy_test);\n    if (tld_pos >= 0) {\n      // if tld is located after found link - no need to check fuzzy pattern\n      if (this.__index__ < 0 || tld_pos < this.__index__) {\n        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {\n\n          shift = ml.index + ml[1].length;\n\n          if (this.__index__ < 0 || shift < this.__index__) {\n            this.__schema__     = '';\n            this.__index__      = shift;\n            this.__last_index__ = ml.index + ml[0].length;\n          }\n        }\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {\n    // guess schemaless emails\n    at_pos = text.indexOf('@');\n    if (at_pos >= 0) {\n      // We can't skip this check, because this cases are possible:\n      // 192.168.1.1@gmail.com, my.in@example.com\n      if ((me = text.match(this.re.email_fuzzy)) !== null) {\n\n        shift = me.index + me[1].length;\n        next  = me.index + me[0].length;\n\n        if (this.__index__ < 0 || shift < this.__index__ ||\n            (shift === this.__index__ && next > this.__last_index__)) {\n          this.__schema__     = 'mailto:';\n          this.__index__      = shift;\n          this.__last_index__ = next;\n        }\n      }\n    }\n  }\n\n  return this.__index__ >= 0;\n};\n\n\n/**\n * LinkifyIt#pretest(text) -> Boolean\n *\n * Very quick check, that can give false positives. Returns true if link MAY BE\n * can exists. Can be used for speed optimization, when you need to check that\n * link NOT exists.\n **/\nLinkifyIt.prototype.pretest = function pretest(text) {\n  return this.re.pretest.test(text);\n};\n\n\n/**\n * LinkifyIt#testSchemaAt(text, name, position) -> Number\n * - text (String): text to scan\n * - name (String): rule (schema) name\n * - position (Number): text offset to check from\n *\n * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly\n * at given position. Returns length of found pattern (0 on fail).\n **/\nLinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {\n  // If not supported schema check requested - terminate\n  if (!this.__compiled__[schema.toLowerCase()]) {\n    return 0;\n  }\n  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);\n};\n\n\n/**\n * LinkifyIt#match(text) -> Array|null\n *\n * Returns array of found link descriptions or `null` on fail. We strongly\n * recommend to use [[LinkifyIt#test]] first, for best speed.\n *\n * ##### Result match description\n *\n * - __schema__ - link schema, can be empty for fuzzy links, or `//` for\n *   protocol-neutral  links.\n * - __index__ - offset of matched text\n * - __lastIndex__ - index of next char after mathch end\n * - __raw__ - matched text\n * - __text__ - normalized text\n * - __url__ - link, generated from matched text\n **/\nLinkifyIt.prototype.match = function match(text) {\n  var shift = 0, result = [];\n\n  // Try to take previous element from cache, if .test() called before\n  if (this.__index__ >= 0 && this.__text_cache__ === text) {\n    result.push(createMatch(this, shift));\n    shift = this.__last_index__;\n  }\n\n  // Cut head if cache was used\n  var tail = shift ? text.slice(shift) : text;\n\n  // Scan string until end reached\n  while (this.test(tail)) {\n    result.push(createMatch(this, shift));\n\n    tail = tail.slice(this.__last_index__);\n    shift += this.__last_index__;\n  }\n\n  if (result.length) {\n    return result;\n  }\n\n  return null;\n};\n\n\n/**\n * LinkifyIt#matchAtStart(text) -> Match|null\n *\n * Returns fully-formed (not fuzzy) link if it starts at the beginning\n * of the string, and null otherwise.\n **/\nLinkifyIt.prototype.matchAtStart = function matchAtStart(text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__      = -1;\n\n  if (!text.length) return null;\n\n  var m = this.re.schema_at_start.exec(text);\n  if (!m) return null;\n\n  var len = this.testSchemaAt(text, m[2], m[0].length);\n  if (!len) return null;\n\n  this.__schema__     = m[2];\n  this.__index__      = m.index + m[1].length;\n  this.__last_index__ = m.index + m[0].length + len;\n\n  return createMatch(this, 0);\n};\n\n\n/** chainable\n * LinkifyIt#tlds(list [, keepOld]) -> this\n * - list (Array): list of tlds\n * - keepOld (Boolean): merge with current list if `true` (`false` by default)\n *\n * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)\n * to avoid false positives. By default this algorythm used:\n *\n * - hostname with any 2-letter root zones are ok.\n * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n *   are ok.\n * - encoded (`xn--...`) root zones are ok.\n *\n * If list is replaced, then exact match for 2-chars root zones will be checked.\n **/\nLinkifyIt.prototype.tlds = function tlds(list, keepOld) {\n  list = Array.isArray(list) ? list : [ list ];\n\n  if (!keepOld) {\n    this.__tlds__ = list.slice();\n    this.__tlds_replaced__ = true;\n    compile(this);\n    return this;\n  }\n\n  this.__tlds__ = this.__tlds__.concat(list)\n                                  .sort()\n                                  .filter(function (el, idx, arr) {\n                                    return el !== arr[idx - 1];\n                                  })\n                                  .reverse();\n\n  compile(this);\n  return this;\n};\n\n/**\n * LinkifyIt#normalize(match)\n *\n * Default normalizer (if schema does not define it's own).\n **/\nLinkifyIt.prototype.normalize = function normalize(match) {\n\n  // Do minimal possible changes by default. Need to collect feedback prior\n  // to move forward https://github.com/markdown-it/linkify-it/issues/1\n\n  if (!match.schema) { match.url = 'http://' + match.url; }\n\n  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {\n    match.url = 'mailto:' + match.url;\n  }\n};\n\n\n/**\n * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\nLinkifyIt.prototype.onCompile = function onCompile() {\n};\n\n\nmodule.exports = LinkifyIt;\n\n\n/***/ }),\n\n/***/ 6066:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\n\nmodule.exports = function (opts) {\n  var re = {};\n  opts = opts || {};\n\n  // Use direct extract instead of `regenerate` to reduse browserified size\n  re.src_Any = (__webpack_require__(9369).source);\n  re.src_Cc  = (__webpack_require__(9413).source);\n  re.src_Z   = (__webpack_require__(5045).source);\n  re.src_P   = (__webpack_require__(3189).source);\n\n  // \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\n  re.src_ZPCc = [ re.src_Z, re.src_P, re.src_Cc ].join('|');\n\n  // \\p{\\Z\\Cc} (white spaces + control)\n  re.src_ZCc = [ re.src_Z, re.src_Cc ].join('|');\n\n  // Experimental. List of chars, completely prohibited in links\n  // because can separate it from other part of text\n  var text_separators = '[><\\uff5c]';\n\n  // All possible word characters (everything without punctuation, spaces & controls)\n  // Defined via punctuation & spaces to save space\n  // Should be something like \\p{\\L\\N\\S\\M} (\\w but without `_`)\n  re.src_pseudo_letter       = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';\n  // The same as abothe but without [0-9]\n  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';\n\n  ////////////////////////////////////////////////////////////////////////////////\n\n  re.src_ip4 =\n\n    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';\n\n  // Prohibit any of \"@/[]()\" in user/pass to avoid wrong domain fetch.\n  re.src_auth    = '(?:(?:(?!' + re.src_ZCc + '|[@/\\\\[\\\\]()]).)+@)?';\n\n  re.src_port =\n\n    '(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?';\n\n  re.src_host_terminator =\n\n    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')' +\n    '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\\\d|\\\\.-|\\\\.(?!$|' + re.src_ZPCc + '))';\n\n  re.src_path =\n\n    '(?:' +\n      '[/?#]' +\n        '(?:' +\n          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\\\]{}.,\"\\'?!\\\\-;]).|' +\n          '\\\\[(?:(?!' + re.src_ZCc + '|\\\\]).)*\\\\]|' +\n          '\\\\((?:(?!' + re.src_ZCc + '|[)]).)*\\\\)|' +\n          '\\\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\\\}|' +\n          '\\\\\"(?:(?!' + re.src_ZCc + '|[\"]).)+\\\\\"|' +\n          \"\\\\'(?:(?!\" + re.src_ZCc + \"|[']).)+\\\\'|\" +\n          \"\\\\'(?=\" + re.src_pseudo_letter + '|[-])|' +  // allow `I'm_king` if no pair found\n          '\\\\.{2,}[a-zA-Z0-9%/&]|' + // google has many dots in \"google search\" links (#66, #81).\n                                     // github has ... in commit range links,\n                                     // Restrict to\n                                     // - english\n                                     // - percent-encoded\n                                     // - parts of file path\n                                     // - params separator\n                                     // until more examples found.\n          '\\\\.(?!' + re.src_ZCc + '|[.]|$)|' +\n          (opts['---'] ?\n            '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n            :\n            '\\\\-+|'\n          ) +\n          ',(?!' + re.src_ZCc + '|$)|' +       // allow `,,,` in paths\n          ';(?!' + re.src_ZCc + '|$)|' +       // allow `;` if not followed by space-like char\n          '\\\\!+(?!' + re.src_ZCc + '|[!]|$)|' +  // allow `!!!` in paths, but not at the end\n          '\\\\?(?!' + re.src_ZCc + '|[?]|$)' +\n        ')+' +\n      '|\\\\/' +\n    ')?';\n\n  // Allow anything in markdown spec, forbid quote (\") at the first position\n  // because emails enclosed in quotes are far more common\n  re.src_email_name =\n\n    '[\\\\-;:&=\\\\+\\\\$,\\\\.a-zA-Z0-9_][\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]*';\n\n  re.src_xn =\n\n    'xn--[a-z0-9\\\\-]{1,59}';\n\n  // More to read about domain names\n  // http://serverfault.com/questions/638260/\n\n  re.src_domain_root =\n\n    // Allow letters & digits (http://test1)\n    '(?:' +\n      re.src_xn +\n      '|' +\n      re.src_pseudo_letter + '{1,63}' +\n    ')';\n\n  re.src_domain =\n\n    '(?:' +\n      re.src_xn +\n      '|' +\n      '(?:' + re.src_pseudo_letter + ')' +\n      '|' +\n      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +\n    ')';\n\n  re.src_host =\n\n    '(?:' +\n    // Don't need IP check, because digits are already allowed in normal domain names\n    //   src_ip4 +\n    // '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)*' + re.src_domain/*_root*/ + ')' +\n    ')';\n\n  re.tpl_host_fuzzy =\n\n    '(?:' +\n      re.src_ip4 +\n    '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))' +\n    ')';\n\n  re.tpl_host_no_ip_fuzzy =\n\n    '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))';\n\n  re.src_host_strict =\n\n    re.src_host + re.src_host_terminator;\n\n  re.tpl_host_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_host_terminator;\n\n  re.src_host_port_strict =\n\n    re.src_host + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_no_ip_fuzzy_strict =\n\n    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;\n\n\n  ////////////////////////////////////////////////////////////////////////////////\n  // Main rules\n\n  // Rude test fuzzy links by host, for quick deny\n  re.tpl_host_fuzzy_test =\n\n    'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';\n\n  re.tpl_email_fuzzy =\n\n      '(^|' + text_separators + '|\"|\\\\(|' + re.src_ZCc + ')' +\n      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';\n\n  re.tpl_link_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';\n\n  re.tpl_link_no_ip_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';\n\n  return re;\n};\n\n\n/***/ }),\n\n/***/ 9980:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\n\nmodule.exports = __webpack_require__(7024);\n\n\n/***/ }),\n\n/***/ 6233:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// HTML5 entities map: { name -> utf16string }\n//\n\n\n/*eslint quotes:0*/\nmodule.exports = __webpack_require__(9323);\n\n\n/***/ }),\n\n/***/ 813:\n/***/ ((module) => {\n\n\"use strict\";\n// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n\n\n\n\nmodule.exports = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n];\n\n\n/***/ }),\n\n/***/ 1947:\n/***/ ((module) => {\n\n\"use strict\";\n// Regexps to match html elements\n\n\n\nvar attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\n\nvar unquoted      = '[^\"\\'=<>`\\\\x00-\\\\x20]+';\nvar single_quoted = \"'[^']*'\";\nvar double_quoted = '\"[^\"]*\"';\n\nvar attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';\n\nvar attribute   = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)';\n\nvar open_tag    = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\n\nvar close_tag   = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment     = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing  = '<[?][\\\\s\\\\S]*?[?]>';\nvar declaration = '<![A-Z]+\\\\s+[^>]*>';\nvar cdata       = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\n\nvar HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +\n                        '|' + processing + '|' + declaration + '|' + cdata + ')');\nvar HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');\n\nmodule.exports.n = HTML_TAG_RE;\nmodule.exports.q = HTML_OPEN_CLOSE_TAG_RE;\n\n\n/***/ }),\n\n/***/ 7022:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n// Utilities\n//\n\n\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\n\nfunction isString(obj) { return _class(obj) === '[object String]'; }\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return _hasOwnProperty.call(object, key);\n}\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\n// Remove element from array and put another array at those position.\n// Useful for some operations with tokens\nfunction arrayReplaceAt(src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) { return false; }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false; }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false; }\n  if (c === 0x0B) { return false; }\n  if (c >= 0x0E && c <= 0x1F) { return false; }\n  if (c >= 0x7F && c <= 0x9F) { return false; }\n  // out of range\n  if (c > 0x10FFFF) { return false; }\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\n\n\nvar UNESCAPE_MD_RE  = /\\\\([!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~])/g;\nvar ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi;\nvar UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\n\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nvar entities = __webpack_require__(6233);\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n\n  if (has(entities, name)) {\n    return entities[name];\n  }\n\n  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ?\n      parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n\n  return match;\n}\n\n/*function replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n}*/\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) { return str; }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped; }\n    return replaceEntityPattern(match, entity);\n  });\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\n\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&');\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isSpace(code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true;\n  }\n  return false;\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace(code) {\n  if (code >= 0x2000 && code <= 0x200A) { return true; }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true;\n  }\n  return false;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n/*eslint-disable max-len*/\nvar UNICODE_PUNCT_RE = __webpack_require__(3189);\n\n// Currently without astral characters support.\nfunction isPunctChar(ch) {\n  return UNICODE_PUNCT_RE.test(ch);\n}\n\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\nfunction isMdAsciiPunct(ch) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference(str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ');\n\n  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß');\n  }\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase();\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n// Re-export libraries commonly used in both markdown-it and its plugins,\n// so plugins won't have to depend on them explicitly, which reduces their\n// bundled size (e.g. a browser build).\n//\nexports.lib                 = {};\nexports.lib.mdurl = __webpack_require__(8765);\nexports.lib.ucmicro = __webpack_require__(4205);\n\nexports.assign              = assign;\nexports.isString            = isString;\nexports.has                 = has;\nexports.unescapeMd          = unescapeMd;\nexports.unescapeAll         = unescapeAll;\nexports.isValidEntityCode   = isValidEntityCode;\nexports.fromCodePoint       = fromCodePoint;\n// exports.replaceEntities     = replaceEntities;\nexports.escapeHtml          = escapeHtml;\nexports.arrayReplaceAt      = arrayReplaceAt;\nexports.isSpace             = isSpace;\nexports.isWhiteSpace        = isWhiteSpace;\nexports.isMdAsciiPunct      = isMdAsciiPunct;\nexports.isPunctChar         = isPunctChar;\nexports.escapeRE            = escapeRE;\nexports.normalizeReference  = normalizeReference;\n\n\n/***/ }),\n\n/***/ 1685:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n// Just a shortcut for bulk export\n\n\n\nexports.parseLinkLabel = __webpack_require__(3595);\nexports.parseLinkDestination = __webpack_require__(2548);\nexports.parseLinkTitle = __webpack_require__(8040);\n\n\n/***/ }),\n\n/***/ 2548:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Parse link destination\n//\n\n\n\nvar unescapeAll = (__webpack_require__(7022).unescapeAll);\n\n\nmodule.exports = function parseLinkDestination(str, pos, max) {\n  var code, level,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (str.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = str.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return result; }\n      if (code === 0x3C /* < */) { return result; }\n      if (code === 0x3E /* > */) {\n        result.pos = pos + 1;\n        result.str = unescapeAll(str.slice(start + 1, pos));\n        result.ok = true;\n        return result;\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '>'\n    return result;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) { break; }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      if (str.charCodeAt(pos + 1) === 0x20) { break; }\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++;\n      if (level > 32) { return result; }\n    }\n\n    if (code === 0x29 /* ) */) {\n      if (level === 0) { break; }\n      level--;\n    }\n\n    pos++;\n  }\n\n  if (start === pos) { return result; }\n  if (level !== 0) { return result; }\n\n  result.str = unescapeAll(str.slice(start, pos));\n  result.lines = lines;\n  result.pos = pos;\n  result.ok = true;\n  return result;\n};\n\n\n/***/ }),\n\n/***/ 3595:\n/***/ ((module) => {\n\n\"use strict\";\n// Parse link label\n//\n// this function assumes that first character (\"[\") already matches;\n// returns the end of the label\n//\n\n\nmodule.exports = function parseLinkLabel(state, start, disableNested) {\n  var level, found, marker, prevPos,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos;\n\n  state.pos = start + 1;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    prevPos = state.pos;\n    state.md.inline.skipToken(state);\n    if (marker === 0x5B /* [ */) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++;\n      } else if (disableNested) {\n        state.pos = oldPos;\n        return -1;\n      }\n    }\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n  }\n\n  // restore old state\n  state.pos = oldPos;\n\n  return labelEnd;\n};\n\n\n/***/ }),\n\n/***/ 8040:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Parse link title\n//\n\n\n\nvar unescapeAll = (__webpack_require__(7022).unescapeAll);\n\n\nmodule.exports = function parseLinkTitle(str, pos, max) {\n  var code,\n      marker,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (pos >= max) { return result; }\n\n  marker = str.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return result; }\n\n  pos++;\n\n  // if opening marker is \"(\", switch it to closing marker \")\"\n  if (marker === 0x28) { marker = 0x29; }\n\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n    if (code === marker) {\n      result.pos = pos + 1;\n      result.lines = lines;\n      result.str = unescapeAll(str.slice(start + 1, pos));\n      result.ok = true;\n      return result;\n    } else if (code === 0x28 /* ( */ && marker === 0x29 /* ) */) {\n      return result;\n    } else if (code === 0x0A) {\n      lines++;\n    } else if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos++;\n      if (str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n\n    pos++;\n  }\n\n  return result;\n};\n\n\n/***/ }),\n\n/***/ 7024:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Main parser class\n\n\n\n\nvar utils        = __webpack_require__(7022);\nvar helpers      = __webpack_require__(1685);\nvar Renderer     = __webpack_require__(7529);\nvar ParserCore   = __webpack_require__(7346);\nvar ParserBlock  = __webpack_require__(2471);\nvar ParserInline = __webpack_require__(4485);\nvar LinkifyIt    = __webpack_require__(8337);\nvar mdurl        = __webpack_require__(8765);\nvar punycode     = __webpack_require__(3689);\n\n\nvar config = {\n  default: __webpack_require__(4218),\n  zero: __webpack_require__(873),\n  commonmark: __webpack_require__(6895)\n};\n\n////////////////////////////////////////////////////////////////////////////////\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nvar BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;\nvar GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/;\n\nfunction validateLink(url) {\n  // url should be normalized at this point, and existing entities are decoded\n  var str = url.trim().toLowerCase();\n\n  return BAD_PROTO_RE.test(str) ? (GOOD_DATA_RE.test(str) ? true : false) : true;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar RECODE_HOSTNAME_FOR = [ 'http:', 'https:', 'mailto:' ];\n\nfunction normalizeLink(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname);\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.encode(mdurl.format(parsed));\n}\n\nfunction normalizeLinkText(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname);\n      } catch (er) { /**/ }\n    }\n  }\n\n  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%');\n}\n\n\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre class=\"hljs\"><code>' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre class=\"hljs\"><code>' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt(presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options);\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {};\n      presetName = 'default';\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline();\n\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock();\n\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new ParserCore();\n\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).\n   **/\n  this.renderer = new Renderer();\n\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt();\n\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink;\n\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink;\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText;\n\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).\n   **/\n  this.utils = utils;\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = utils.assign({}, helpers);\n\n\n  this.options = {};\n  this.configure(presetName);\n\n  if (options) { this.set(options); }\n}\n\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options);\n  return this;\n};\n\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you will - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n  var self = this, presetName;\n\n  if (utils.isString(presets)) {\n    presetName = presets;\n    presets = config[presetName];\n    if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name'); }\n  }\n\n  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty'); }\n\n  if (presets.options) { self.set(presets.options); }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules);\n      }\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2);\n      }\n    });\n  }\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.enable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.disable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);\n  }\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  var args = [ this ].concat(Array.prototype.slice.call(arguments, 1));\n  plugin.apply(plugin, args);\n  return this;\n};\n\n\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and return list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String');\n  }\n\n  var state = new this.core.State(src, this, env);\n\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parse(src, env), this.options, env);\n};\n\n\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  var state = new this.core.State(src, this, env);\n\n  state.inlineMode = true;\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env);\n};\n\n\nmodule.exports = MarkdownIt;\n\n\n/***/ }),\n\n/***/ 2471:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n\n\n\nvar Ruler           = __webpack_require__(9580);\n\n\nvar _rules = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  [ 'table',      __webpack_require__(1785),      [ 'paragraph', 'reference' ] ],\n  [ 'code',       __webpack_require__(8768) ],\n  [ 'fence',      __webpack_require__(3542),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'blockquote', __webpack_require__(5258), [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'hr',         __webpack_require__(5634),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'list',       __webpack_require__(8532),       [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'reference',  __webpack_require__(3804) ],\n  [ 'html_block', __webpack_require__(6329), [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'heading',    __webpack_require__(1630),    [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'lheading',   __webpack_require__(6850) ],\n  [ 'paragraph',  __webpack_require__(6864) ]\n];\n\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });\n  }\n}\n\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      line = startLine,\n      hasEmptyLines = false,\n      maxNesting = state.md.options.maxNesting;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) { break; }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break; }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) { break; }\n    }\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n      state.line = line;\n    }\n  }\n};\n\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  var state;\n\n  if (!src) { return; }\n\n  state = new this.State(src, md, env, outTokens);\n\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n\nParserBlock.prototype.State = __webpack_require__(2948);\n\n\nmodule.exports = ParserBlock;\n\n\n/***/ }),\n\n/***/ 7346:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n\n\n\nvar Ruler  = __webpack_require__(9580);\n\n\nvar _rules = [\n  [ 'normalize',      __webpack_require__(4129)      ],\n  [ 'block',          __webpack_require__(898)          ],\n  [ 'inline',         __webpack_require__(9827)         ],\n  [ 'linkify',        __webpack_require__(7830)        ],\n  [ 'replacements',   __webpack_require__(2834)   ],\n  [ 'smartquotes',    __webpack_require__(8450)    ],\n  // `text_join` finds `text_special` tokens (for escape sequences)\n  // and joins them with the rest of the text\n  [ 'text_join',      __webpack_require__(6633)      ]\n];\n\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  var i, l, rules;\n\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\nCore.prototype.State = __webpack_require__(6480);\n\n\nmodule.exports = Core;\n\n\n/***/ }),\n\n/***/ 4485:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n\n\n\nvar Ruler           = __webpack_require__(9580);\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\nvar _rules = [\n  [ 'text',            __webpack_require__(9941) ],\n  [ 'linkify',         __webpack_require__(2906) ],\n  [ 'newline',         __webpack_require__(3905) ],\n  [ 'escape',          __webpack_require__(1917) ],\n  [ 'backticks',       __webpack_require__(40) ],\n  [ 'strikethrough',   (__webpack_require__(4814)/* .tokenize */ .w) ],\n  [ 'emphasis',        (__webpack_require__(7894)/* .tokenize */ .w) ],\n  [ 'link',            __webpack_require__(1727) ],\n  [ 'image',           __webpack_require__(3006) ],\n  [ 'autolink',        __webpack_require__(3420) ],\n  [ 'html_inline',     __webpack_require__(1779) ],\n  [ 'entity',          __webpack_require__(9391) ]\n];\n\n// `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\nvar _rules2 = [\n  [ 'balance_pairs',   __webpack_require__(9354) ],\n  [ 'strikethrough',   (__webpack_require__(4814)/* .postProcess */ .g) ],\n  [ 'emphasis',        (__webpack_require__(7894)/* .postProcess */ .g) ],\n  // rules for pairs separate '**' into its own text tokens, which may be left unused,\n  // rule below merges unused segments back with the rest of the text\n  [ 'fragments_join',  __webpack_require__(9969) ]\n];\n\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  var i;\n\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n\n  for (i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  var ok, i, pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\n\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n\n  if (state.level < maxNesting) {\n    for (i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++;\n      ok = rules[i](state, true);\n      state.level--;\n\n      if (ok) { break; }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax;\n  }\n\n  if (!ok) { state.pos++; }\n  cache[pos] = state.pos;\n};\n\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      end = state.posMax,\n      maxNesting = state.md.options.maxNesting;\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n\n    if (state.level < maxNesting) {\n      for (i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n        if (ok) { break; }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  var i, rules, len;\n  var state = new this.State(str, md, env, outTokens);\n\n  this.tokenize(state);\n\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\n\n\nParserInline.prototype.State = __webpack_require__(670);\n\n\nmodule.exports = ParserInline;\n\n\n/***/ }),\n\n/***/ 6895:\n/***/ ((module) => {\n\n\"use strict\";\n// Commonmark default options\n\n\n\n\nmodule.exports = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'fragments_join'\n      ]\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 4218:\n/***/ ((module) => {\n\n\"use strict\";\n// markdown-it default options\n\n\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   100            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n\n\n/***/ }),\n\n/***/ 873:\n/***/ ((module) => {\n\n\"use strict\";\n// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\n\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'fragments_join'\n      ]\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 7529:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n\n\n\nvar assign          = (__webpack_require__(7022).assign);\nvar unescapeAll     = (__webpack_require__(7022).unescapeAll);\nvar escapeHtml      = (__webpack_require__(7022).escapeHtml);\n\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar default_rules = {};\n\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '<code' + slf.renderAttrs(token) + '>' +\n          escapeHtml(tokens[idx].content) +\n          '</code>';\n};\n\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '<pre' + slf.renderAttrs(token) + '><code>' +\n          escapeHtml(tokens[idx].content) +\n          '</code></pre>\\n';\n};\n\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      info = token.info ? unescapeAll(token.info).trim() : '',\n      langName = '',\n      langAttrs = '',\n      highlighted, i, arr, tmpAttrs, tmpToken;\n\n  if (info) {\n    arr = info.split(/(\\s+)/g);\n    langName = arr[0];\n    langAttrs = arr.slice(2).join('');\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .deepClone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    i        = token.attrIndex('class');\n    tmpAttrs = token.attrs ? token.attrs.slice() : [];\n\n    if (i < 0) {\n      tmpAttrs.push([ 'class', options.langPrefix + langName ]);\n    } else {\n      tmpAttrs[i] = tmpAttrs[i].slice();\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n\n    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'\n          + highlighted\n          + '</code></pre>\\n';\n  }\n\n\n  return  '<pre><code' + slf.renderAttrs(token) + '>'\n        + highlighted\n        + '</code></pre>\\n';\n};\n\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env);\n\n  return slf.renderToken(tokens, idx, options);\n};\n\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n\n  /**\n   * Renderer#rules -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independent static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules);\n}\n\n\n/**\n * Renderer.renderAttrs(token) -> String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) { return ''; }\n\n  result = '';\n\n  for (i = 0, l = token.attrs.length; i < l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.renderToken(tokens, idx, options) -> String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx];\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag;\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  if (token.block) {\n    needLf = true;\n\n    if (token.nesting === 1) {\n      if (idx + 1 < tokens.length) {\n        nextToken = tokens[idx + 1];\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n\n        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n\n  result += needLf ? '>\\n' : '>';\n\n  return result;\n};\n\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var type,\n      result = '',\n      rules = this.rules;\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n\n  return result;\n};\n\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  var result = '';\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    if (tokens[i].type === 'text') {\n      result += tokens[i].content;\n    } else if (tokens[i].type === 'image') {\n      result += this.renderInlineAsText(tokens[i].children, options, env);\n    } else if (tokens[i].type === 'softbreak') {\n      result += '\\n';\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  var i, len, type,\n      result = '',\n      rules = this.rules;\n\n  for (i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[tokens[i].type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n\n  return result;\n};\n\nmodule.exports = Renderer;\n\n\n/***/ }),\n\n/***/ 9580:\n/***/ ((module) => {\n\n\"use strict\";\n/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n\n\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (var i = 0; i < this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return; }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return; }\n\n      if (chain && rule.alt.indexOf(chain) < 0) { return; }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  var index = this.__find__(name);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + name); }\n\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var index = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName); }\n\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var index = this.__find__(afterName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + afterName); }\n\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false; });\n\n  this.enable(list, ignoreInvalid);\n};\n\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.getRules(chainName) -> Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;\n\n\n/***/ }),\n\n/***/ 5258:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Block quotes\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function blockquote(state, startLine, endLine, silent) {\n  var adjustTab,\n      ch,\n      i,\n      initial,\n      l,\n      lastLineEmpty,\n      lines,\n      nextLine,\n      offset,\n      oldBMarks,\n      oldBSCount,\n      oldIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      spaceAfterMarker,\n      terminate,\n      terminatorRules,\n      token,\n      isOutdented,\n      oldLineMax = state.lineMax,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true; }\n\n  // set offset past spaces and \">\"\n  initial = offset = state.sCount[startLine] + 1;\n\n  // skip one optional space after '>'\n  if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n    // ' >   test '\n    //     ^ -- position start of line here:\n    pos++;\n    initial++;\n    offset++;\n    adjustTab = false;\n    spaceAfterMarker = true;\n  } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n    spaceAfterMarker = true;\n\n    if ((state.bsCount[startLine] + offset) % 4 === 3) {\n      // '  >\\t  test '\n      //       ^ -- position start of line here (tab has width===1)\n      pos++;\n      initial++;\n      offset++;\n      adjustTab = false;\n    } else {\n      // ' >\\t  test '\n      //    ^ -- position start of line here + shift bsCount slightly\n      //         to make extra space appear\n      adjustTab = true;\n    }\n  } else {\n    spaceAfterMarker = false;\n  }\n\n  oldBMarks = [ state.bMarks[startLine] ];\n  state.bMarks[startLine] = pos;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (isSpace(ch)) {\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;\n      } else {\n        offset++;\n      }\n    } else {\n      break;\n    }\n\n    pos++;\n  }\n\n  oldBSCount = [ state.bsCount[startLine] ];\n  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n  lastLineEmpty = pos >= max;\n\n  oldSCount = [ state.sCount[startLine] ];\n  state.sCount[startLine] = offset - initial;\n\n  oldTShift = [ state.tShift[startLine] ];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    isOutdented = state.sCount[nextLine] < state.blkIndent;\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \">\"\n      initial = offset = state.sCount[nextLine] + 1;\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        offset++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true;\n\n        if ((state.bsCount[nextLine] + offset) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          offset++;\n          adjustTab = false;\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true;\n        }\n      } else {\n        spaceAfterMarker = false;\n      }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;\n          } else {\n            offset++;\n          }\n        } else {\n          break;\n        }\n\n        pos++;\n      }\n\n      lastLineEmpty = pos >= max;\n\n      oldBSCount.push(state.bsCount[nextLine]);\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n      oldSCount.push(state.sCount[nextLine]);\n      state.sCount[nextLine] = offset - initial;\n\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break; }\n\n    // Case 3: another tag found.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine;\n\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine]);\n        oldBSCount.push(state.bsCount[nextLine]);\n        oldTShift.push(state.tShift[nextLine]);\n        oldSCount.push(state.sCount[nextLine]);\n        state.sCount[nextLine] -= state.blkIndent;\n      }\n\n      break;\n    }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldBSCount.push(state.bsCount[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n    oldSCount.push(state.sCount[nextLine]);\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1;\n  }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n\n  token        = state.push('blockquote_open', 'blockquote', 1);\n  token.markup = '>';\n  token.map    = lines = [ startLine, 0 ];\n\n  state.md.block.tokenize(state, startLine, nextLine);\n\n  token        = state.push('blockquote_close', 'blockquote', -1);\n  token.markup = '>';\n\n  state.lineMax = oldLineMax;\n  state.parentType = oldParentType;\n  lines[1] = state.line;\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n    state.sCount[i + startLine] = oldSCount[i];\n    state.bsCount[i + startLine] = oldBSCount[i];\n  }\n  state.blkIndent = oldIndent;\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 8768:\n/***/ ((module) => {\n\n\"use strict\";\n// Code block (4 spaces padded)\n\n\n\n\nmodule.exports = function code(state, startLine, endLine/*, silent*/) {\n  var nextLine, last, token;\n\n  if (state.sCount[startLine] - state.blkIndent < 4) { return false; }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n\n  state.line = last;\n\n  token         = state.push('code_block', 'code', 0);\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\\n';\n  token.map     = [ startLine, state.line ];\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 3542:\n/***/ ((module) => {\n\n\"use strict\";\n// fences (``` lang, ~~~ lang)\n\n\n\n\nmodule.exports = function fence(state, startLine, endLine, silent) {\n  var marker, len, params, nextLine, mem, token, markup,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (pos + 3 > max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {\n    return false;\n  }\n\n  // scan marker length\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n\n  len = pos - mem;\n\n  if (len < 3) { return false; }\n\n  markup = state.src.slice(mem, pos);\n  params = state.src.slice(pos, max);\n\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) >= 0) {\n      return false;\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true; }\n\n  // search end of block\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue; }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue; }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n\n    if (pos < max) { continue; }\n\n    haveEndMarker = true;\n    // found!\n    break;\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine];\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n\n  token         = state.push('fence', 'code', 0);\n  token.info    = params;\n  token.content = state.getLines(startLine + 1, nextLine, len, true);\n  token.markup  = markup;\n  token.map     = [ startLine, state.line ];\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 1630:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// heading (#, ##, ...)\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function heading(state, startLine, endLine, silent) {\n  var ch, level, tmp, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  ch  = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false; }\n\n  // count heading level\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || (pos < max && !isSpace(ch))) { return false; }\n\n  if (silent) { return true; }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos);\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n\n  token        = state.push('heading_open', 'h' + String(level), 1);\n  token.markup = '########'.slice(0, level);\n  token.map    = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = state.src.slice(pos, max).trim();\n  token.map      = [ startLine, state.line ];\n  token.children = [];\n\n  token        = state.push('heading_close', 'h' + String(level), -1);\n  token.markup = '########'.slice(0, level);\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 5634:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Horizontal rule\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function hr(state, startLine, endLine, silent) {\n  var marker, cnt, ch, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x5F/* _ */) {\n    return false;\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  cnt = 1;\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && !isSpace(ch)) { return false; }\n    if (ch === marker) { cnt++; }\n  }\n\n  if (cnt < 3) { return false; }\n\n  if (silent) { return true; }\n\n  state.line = startLine + 1;\n\n  token        = state.push('hr', 'hr', 0);\n  token.map    = [ startLine, state.line ];\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 6329:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// HTML block\n\n\n\n\nvar block_names = __webpack_require__(813);\nvar HTML_OPEN_CLOSE_TAG_RE = (__webpack_require__(1947)/* .HTML_OPEN_CLOSE_TAG_RE */ .q);\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nvar HTML_SEQUENCES = [\n  [ /^<(script|pre|style|textarea)(?=(\\s|>|$))/i, /<\\/(script|pre|style|textarea)>/i, true ],\n  [ /^<!--/,        /-->/,   true ],\n  [ /^<\\?/,         /\\?>/,   true ],\n  [ /^<![A-Z]/,     />/,     true ],\n  [ /^<!\\[CDATA\\[/, /\\]\\]>/, true ],\n  [ new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true ],\n  [ new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'),  /^$/, false ]\n];\n\n\nmodule.exports = function html_block(state, startLine, endLine, silent) {\n  var i, nextLine, token, lineText,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (!state.md.options.html) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  lineText = state.src.slice(pos, max);\n\n  for (i = 0; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { break; }\n  }\n\n  if (i === HTML_SEQUENCES.length) { return false; }\n\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2];\n  }\n\n  nextLine = startLine + 1;\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n      lineText = state.src.slice(pos, max);\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) { nextLine++; }\n        break;\n      }\n    }\n  }\n\n  state.line = nextLine;\n\n  token         = state.push('html_block', '', 0);\n  token.map     = [ startLine, nextLine ];\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 6850:\n/***/ ((module) => {\n\n\"use strict\";\n// lheading (---, ===)\n\n\n\n\nmodule.exports = function lheading(state, startLine, endLine/*, silent*/) {\n  var content, terminate, i, l, token, pos, max, level, marker,\n      nextLine = startLine + 1, oldParentType,\n      terminatorRules = state.md.block.ruler.getRules('paragraph');\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos);\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n\n          if (pos >= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2);\n            break;\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    return false;\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine + 1;\n\n  token          = state.push('heading_open', 'h' + String(level), 1);\n  token.markup   = String.fromCharCode(marker);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line - 1 ];\n  token.children = [];\n\n  token          = state.push('heading_close', 'h' + String(level), -1);\n  token.markup   = String.fromCharCode(marker);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 8532:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Lists\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max, ch;\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  marker = state.src.charCodeAt(pos++);\n  // Check bullet\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1;\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1;\n    }\n  }\n\n  return pos;\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      pos = start,\n      max = state.eMarks[startLine];\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 >= max) { return -1; }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1; }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) { return -1; }\n\n      continue;\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break;\n    }\n\n    return -1;\n  }\n\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1;\n    }\n  }\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i, l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true;\n      state.tokens[i].hidden = true;\n      i += 2;\n    }\n  }\n}\n\n\nmodule.exports = function list(state, startLine, endLine, silent) {\n  var ch,\n      contentStart,\n      i,\n      indent,\n      indentAfterMarker,\n      initial,\n      isOrdered,\n      itemLines,\n      l,\n      listLines,\n      listTokIdx,\n      markerCharCode,\n      markerValue,\n      max,\n      nextLine,\n      offset,\n      oldListIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      oldTight,\n      pos,\n      posAfterMarker,\n      prevEmptyEnd,\n      start,\n      terminate,\n      terminatorRules,\n      token,\n      isTerminatingParagraph = false,\n      tight = true;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent >= 0 &&\n      state.sCount[startLine] - state.listIndent >= 4 &&\n      state.sCount[startLine] < state.blkIndent) {\n    return false;\n  }\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.sCount[startLine] >= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  }\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.slice(start, posAfterMarker - 1));\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph && markerValue !== 1) return false;\n\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n\n  } else {\n    return false;\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]) return false;\n  }\n\n  // We should terminate list on style change. Remember first one to compare.\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true; }\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    token       = state.push('ordered_list_open', 'ol', 1);\n    if (markerValue !== 1) {\n      token.attrs = [ [ 'start', markerValue ] ];\n    }\n\n  } else {\n    token       = state.push('bullet_list_open', 'ul', 1);\n  }\n\n  token.map    = listLines = [ startLine, 0 ];\n  token.markup = String.fromCharCode(markerCharCode);\n\n  //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.md.block.ruler.getRules('list');\n\n  oldParentType = state.parentType;\n  state.parentType = 'list';\n\n  while (nextLine < endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n\n    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);\n\n    while (pos < max) {\n      ch = state.src.charCodeAt(pos);\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4;\n      } else if (ch === 0x20) {\n        offset++;\n      } else {\n        break;\n      }\n\n      pos++;\n    }\n\n    contentStart = pos;\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = initial + indentAfterMarker;\n\n    // Run subparser & write tokens\n    token        = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    token.map    = itemLines = [ startLine, 0 ];\n    if (isOrdered) {\n      token.info = state.src.slice(start, posAfterMarker - 1);\n    }\n\n    // change current state, then restore it after parser subcall\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldSCount = state.sCount[startLine];\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    oldListIndent = state.listIndent;\n    state.listIndent = state.blkIndent;\n    state.blkIndent = indent;\n\n    state.tight = true;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.sCount[startLine] = offset;\n\n    if (contentStart >= max && state.isEmpty(startLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine);\n    } else {\n      state.md.block.tokenize(state, startLine, endLine, true);\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1);\n\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[startLine] = oldTShift;\n    state.sCount[startLine] = oldSCount;\n    state.tight = oldTight;\n\n    token        = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) { break; }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[startLine] - state.blkIndent >= 4) { break; }\n\n    // fail if terminating block found\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n      start = state.bMarks[nextLine] + state.tShift[nextLine];\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1);\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1);\n  }\n  token.markup = String.fromCharCode(markerCharCode);\n\n  listLines[1] = nextLine;\n  state.line = nextLine;\n\n  state.parentType = oldParentType;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 6864:\n/***/ ((module) => {\n\n\"use strict\";\n// Paragraph\n\n\n\n\nmodule.exports = function paragraph(state, startLine/*, endLine*/) {\n  var content, terminate, i, l, token, oldParentType,\n      nextLine = startLine + 1,\n      terminatorRules = state.md.block.ruler.getRules('paragraph'),\n      endLine = state.lineMax;\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph';\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine;\n\n  token          = state.push('paragraph_open', 'p', 1);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line ];\n  token.children = [];\n\n  token          = state.push('paragraph_close', 'p', -1);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 3804:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\n\nvar normalizeReference   = (__webpack_require__(7022).normalizeReference);\nvar isSpace              = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function reference(state, startLine, _endLine, silent) {\n  var ch,\n      destEndPos,\n      destEndLineNo,\n      endLine,\n      href,\n      i,\n      l,\n      label,\n      labelEnd,\n      oldParentType,\n      res,\n      start,\n      str,\n      terminate,\n      terminatorRules,\n      title,\n      lines = 0,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine],\n      nextLine = startLine + 1;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false; }\n\n  // Simple check to quickly interrupt scan on [link](url) at the start of line.\n  // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54\n  while (++pos < max) {\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */ &&\n        state.src.charCodeAt(pos - 1) !== 0x5C/* \\ */) {\n      if (pos + 1 === max) { return false; }\n      if (state.src.charCodeAt(pos + 1) !== 0x3A/* : */) { return false; }\n      break;\n    }\n  }\n\n  endLine = state.lineMax;\n\n  // jump line-by-line until empty one or EOF\n  terminatorRules = state.md.block.ruler.getRules('reference');\n\n  oldParentType = state.parentType;\n  state.parentType = 'reference';\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  max = str.length;\n\n  for (pos = 1; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x5B /* [ */) {\n      return false;\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos;\n      break;\n    } else if (ch === 0x0A /* \\n */) {\n      lines++;\n    } else if (ch === 0x5C /* \\ */) {\n      pos++;\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false; }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  res = state.md.helpers.parseLinkDestination(str, pos, max);\n  if (!res.ok) { return false; }\n\n  href = state.md.normalizeLink(res.str);\n  if (!state.md.validateLink(href)) { return false; }\n\n  pos = res.pos;\n  lines += res.lines;\n\n  // save cursor state, we could require to rollback later\n  destEndPos = pos;\n  destEndLineNo = lines;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  start = pos;\n  for (; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  res = state.md.helpers.parseLinkTitle(str, pos, max);\n  if (pos < max && start !== pos && res.ok) {\n    title = res.str;\n    pos = res.pos;\n    lines += res.lines;\n  } else {\n    title = '';\n    pos = destEndPos;\n    lines = destEndLineNo;\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    ch = str.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n    pos++;\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = '';\n      pos = destEndPos;\n      lines = destEndLineNo;\n      while (pos < max) {\n        ch = str.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false;\n  }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false;\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /*istanbul ignore if*/\n  if (silent) { return true; }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {};\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title: title, href: href };\n  }\n\n  state.parentType = oldParentType;\n\n  state.line = startLine + lines + 1;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 2948:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Parser state class\n\n\n\nvar Token = __webpack_require__(5872);\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nfunction StateBlock(src, md, env, tokens) {\n  var ch, s, start, pos, len, indent, offset, indent_found;\n\n  this.src = src;\n\n  // link to parser instance\n  this.md     = md;\n\n  this.env = env;\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n\n  this.bMarks = [];  // line begin offsets for fast jumps\n  this.eMarks = [];  // line end offsets for fast jumps\n  this.tShift = [];  // offsets of the first non-space characters (tabs not expanded)\n  this.sCount = [];  // indents for each line (tabs expanded)\n\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n  this.bsCount = [];\n\n  // block parser variables\n  this.blkIndent  = 0; // required block content indent (for example, if we are\n                       // inside a list, it would be positioned after list marker)\n  this.line       = 0; // line index in src\n  this.lineMax    = 0; // lines count\n  this.tight      = false;  // loose/tight mode for lists\n  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)\n  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  this.parentType = 'root';\n\n  this.level = 0;\n\n  // renderer\n  this.result = '';\n\n  // Create caches\n  // Generate markers.\n  s = this.src;\n  indent_found = false;\n\n  for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (isSpace(ch)) {\n        indent++;\n\n        if (ch === 0x09) {\n          offset += 4 - offset % 4;\n        } else {\n          offset++;\n        }\n        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) { pos++; }\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n      this.sCount.push(offset);\n      this.bsCount.push(0);\n\n      indent_found = false;\n      indent = 0;\n      offset = 0;\n      start = pos + 1;\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n  this.sCount.push(0);\n  this.bsCount.push(0);\n\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\n// Push new token to \"stream\".\n//\nStateBlock.prototype.push = function (type, tag, nesting) {\n  var token = new Token(type, tag, nesting);\n  token.block = true;\n\n  if (nesting < 0) this.level--; // closing tag\n  token.level = this.level;\n  if (nesting > 0) this.level++; // opening tag\n\n  this.tokens.push(token);\n  return token;\n};\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n  return from;\n};\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  var ch;\n\n  for (var max = this.src.length; pos < max; pos++) {\n    ch = this.src.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n  }\n  return pos;\n};\n\n// Skip spaces from given position in reverse.\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {\n  if (pos <= min) { return pos; }\n\n  while (pos > min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1; }\n  }\n  return pos;\n};\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break; }\n  }\n  return pos;\n};\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) { return pos; }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1; }\n  }\n  return pos;\n};\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i, lineIndent, ch, first, last, queue, lineStart,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    lineIndent = 0;\n    lineStart = first = this.bMarks[line];\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    while (first < last && lineIndent < indent) {\n      ch = this.src.charCodeAt(first);\n\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;\n        } else {\n          lineIndent++;\n        }\n      } else if (first - lineStart < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++;\n      } else {\n        break;\n      }\n\n      first++;\n    }\n\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);\n    } else {\n      queue[i] = this.src.slice(first, last);\n    }\n  }\n\n  return queue.join('');\n};\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token;\n\n\nmodule.exports = StateBlock;\n\n\n/***/ }),\n\n/***/ 1785:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// GFM table, https://github.github.com/gfm/#tables-extension-\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.tShift[line],\n      max = state.eMarks[line];\n\n  return state.src.slice(pos, max);\n}\n\nfunction escapedSplit(str) {\n  var result = [],\n      pos = 0,\n      max = str.length,\n      ch,\n      isEscaped = false,\n      lastPos = 0,\n      current = '';\n\n  ch  = str.charCodeAt(pos);\n\n  while (pos < max) {\n    if (ch === 0x7c/* | */) {\n      if (!isEscaped) {\n        // pipe separating cells, '|'\n        result.push(current + str.substring(lastPos, pos));\n        current = '';\n        lastPos = pos + 1;\n      } else {\n        // escaped pipe, '\\|'\n        current += str.substring(lastPos, pos - 1);\n        lastPos = pos;\n      }\n    }\n\n    isEscaped = (ch === 0x5c/* \\ */);\n    pos++;\n\n    ch = str.charCodeAt(pos);\n  }\n\n  result.push(current + str.substring(lastPos));\n\n  return result;\n}\n\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, l, nextLine, columns, columnCount, token,\n      aligns, t, tableLines, tbodyLines, oldParentType, terminate,\n      terminatorRules, firstCh, secondCh;\n\n  // should have at least two lines\n  if (startLine + 2 > endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.sCount[nextLine] < state.blkIndent) { return false; }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false; }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n  if (pos >= state.eMarks[nextLine]) { return false; }\n\n  firstCh = state.src.charCodeAt(pos++);\n  if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false; }\n\n  if (pos >= state.eMarks[nextLine]) { return false; }\n\n  secondCh = state.src.charCodeAt(pos++);\n  if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !isSpace(secondCh)) {\n    return false;\n  }\n\n  // if first character is '-', then second character must not be a space\n  // (due to parsing ambiguity with list)\n  if (firstCh === 0x2D/* - */ && isSpace(secondCh)) { return false; }\n\n  while (pos < state.eMarks[nextLine]) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false; }\n\n    pos++;\n  }\n\n  lineText = getLine(state, startLine + 1);\n\n  columns = lineText.split('|');\n  aligns = [];\n  for (i = 0; i < columns.length; i++) {\n    t = columns[i].trim();\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) { return false; }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n  if (lineText.indexOf('|') === -1) { return false; }\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n  columns = escapedSplit(lineText);\n  if (columns.length && columns[0] === '') columns.shift();\n  if (columns.length && columns[columns.length - 1] === '') columns.pop();\n\n  // header row will define an amount of columns in the entire table,\n  // and align row should be exactly the same (the rest of the rows can differ)\n  columnCount = columns.length;\n  if (columnCount === 0 || columnCount !== aligns.length) { return false; }\n\n  if (silent) { return true; }\n\n  oldParentType = state.parentType;\n  state.parentType = 'table';\n\n  // use 'blockquote' lists for termination because it's\n  // the most similar to tables\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n\n  token     = state.push('table_open', 'table', 1);\n  token.map = tableLines = [ startLine, 0 ];\n\n  token     = state.push('thead_open', 'thead', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  token     = state.push('tr_open', 'tr', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  for (i = 0; i < columns.length; i++) {\n    token          = state.push('th_open', 'th', 1);\n    if (aligns[i]) {\n      token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];\n    }\n\n    token          = state.push('inline', '', 0);\n    token.content  = columns[i].trim();\n    token.children = [];\n\n    token          = state.push('th_close', 'th', -1);\n  }\n\n  token     = state.push('tr_close', 'tr', -1);\n  token     = state.push('thead_close', 'thead', -1);\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) { break; }\n    lineText = getLine(state, nextLine).trim();\n    if (!lineText) { break; }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break; }\n    columns = escapedSplit(lineText);\n    if (columns.length && columns[0] === '') columns.shift();\n    if (columns.length && columns[columns.length - 1] === '') columns.pop();\n\n    if (nextLine === startLine + 2) {\n      token     = state.push('tbody_open', 'tbody', 1);\n      token.map = tbodyLines = [ startLine + 2, 0 ];\n    }\n\n    token     = state.push('tr_open', 'tr', 1);\n    token.map = [ nextLine, nextLine + 1 ];\n\n    for (i = 0; i < columnCount; i++) {\n      token          = state.push('td_open', 'td', 1);\n      if (aligns[i]) {\n        token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];\n      }\n\n      token          = state.push('inline', '', 0);\n      token.content  = columns[i] ? columns[i].trim() : '';\n      token.children = [];\n\n      token          = state.push('td_close', 'td', -1);\n    }\n    token = state.push('tr_close', 'tr', -1);\n  }\n\n  if (tbodyLines) {\n    token = state.push('tbody_close', 'tbody', -1);\n    tbodyLines[1] = nextLine;\n  }\n\n  token = state.push('table_close', 'table', -1);\n  tableLines[1] = nextLine;\n\n  state.parentType = oldParentType;\n  state.line = nextLine;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 898:\n/***/ ((module) => {\n\n\"use strict\";\n\n\n\nmodule.exports = function block(state) {\n  var token;\n\n  if (state.inlineMode) {\n    token          = new state.Token('inline', '', 0);\n    token.content  = state.src;\n    token.map      = [ 0, 1 ];\n    token.children = [];\n    state.tokens.push(token);\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens);\n  }\n};\n\n\n/***/ }),\n\n/***/ 9827:\n/***/ ((module) => {\n\n\"use strict\";\n\n\nmodule.exports = function inline(state) {\n  var tokens = state.tokens, tok, i, l;\n\n  // Parse inlines\n  for (i = 0, l = tokens.length; i < l; i++) {\n    tok = tokens[i];\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children);\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 7830:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n\n\n\nvar arrayReplaceAt = (__webpack_require__(7022).arrayReplaceAt);\n\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\n\n\nmodule.exports = function linkify(state) {\n  var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos,\n      level, htmlLinkLevel, url, fullUrl, urlText,\n      blockTokens = state.tokens,\n      links;\n\n  if (!state.md.options.linkify) { return; }\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue;\n    }\n\n    tokens = blockTokens[j].children;\n\n    htmlLinkLevel = 0;\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (i = tokens.length - 1; i >= 0; i--) {\n      currentToken = tokens[i];\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--;\n        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {\n          i--;\n        }\n        continue;\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n      if (htmlLinkLevel > 0) { continue; }\n\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n\n        text = currentToken.content;\n        links = state.md.linkify.match(text);\n\n        // Now split string to nodes\n        nodes = [];\n        level = currentToken.level;\n        lastPos = 0;\n\n        // forbid escape sequence at the start of the string,\n        // this avoids http\\://example.com/ from being linkified as\n        // http:<a href=\"//example.com/\">//example.com/</a>\n        if (links.length > 0 &&\n            links[0].index === 0 &&\n            i > 0 &&\n            tokens[i - 1].type === 'text_special') {\n          links = links.slice(1);\n        }\n\n        for (ln = 0; ln < links.length; ln++) {\n          url = links[ln].url;\n          fullUrl = state.md.normalizeLink(url);\n          if (!state.md.validateLink(fullUrl)) { continue; }\n\n          urlText = links[ln].text;\n\n          // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '');\n          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');\n          } else {\n            urlText = state.md.normalizeLinkText(urlText);\n          }\n\n          pos = links[ln].index;\n\n          if (pos > lastPos) {\n            token         = new state.Token('text', '', 0);\n            token.content = text.slice(lastPos, pos);\n            token.level   = level;\n            nodes.push(token);\n          }\n\n          token         = new state.Token('link_open', 'a', 1);\n          token.attrs   = [ [ 'href', fullUrl ] ];\n          token.level   = level++;\n          token.markup  = 'linkify';\n          token.info    = 'auto';\n          nodes.push(token);\n\n          token         = new state.Token('text', '', 0);\n          token.content = urlText;\n          token.level   = level;\n          nodes.push(token);\n\n          token         = new state.Token('link_close', 'a', -1);\n          token.level   = --level;\n          token.markup  = 'linkify';\n          token.info    = 'auto';\n          nodes.push(token);\n\n          lastPos = links[ln].lastIndex;\n        }\n        if (lastPos < text.length) {\n          token         = new state.Token('text', '', 0);\n          token.content = text.slice(lastPos);\n          token.level   = level;\n          nodes.push(token);\n        }\n\n        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);\n      }\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 4129:\n/***/ ((module) => {\n\n\"use strict\";\n// Normalize input string\n\n\n\n\n// https://spec.commonmark.org/0.29/#line-ending\nvar NEWLINES_RE  = /\\r\\n?|\\n/g;\nvar NULL_RE      = /\\0/g;\n\n\nmodule.exports = function normalize(state) {\n  var str;\n\n  // Normalize newlines\n  str = state.src.replace(NEWLINES_RE, '\\n');\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD');\n\n  state.src = str;\n};\n\n\n/***/ }),\n\n/***/ 2834:\n/***/ ((module) => {\n\n\"use strict\";\n// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// (p) (P) -> §\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - multiplications 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nvar SCOPED_ABBR_TEST_RE = /\\((c|tm|r)\\)/i;\n\nvar SCOPED_ABBR_RE = /\\((c|tm|r)\\)/ig;\nvar SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  tm: '™'\n};\n\nfunction replaceFn(match, name) {\n  return SCOPED_ABBR[name.toLowerCase()];\n}\n\nfunction replace_scoped(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nfunction replace_rare(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n          // en-dash\n          .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013')\n          .replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013');\n      }\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\n\nmodule.exports = function replace(state) {\n  var blkIdx;\n\n  if (!state.md.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\n\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children);\n    }\n\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children);\n    }\n\n  }\n};\n\n\n/***/ }),\n\n/***/ 8450:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Convert straight quotation marks to typographic ones\n//\n\n\n\nvar isWhiteSpace   = (__webpack_require__(7022).isWhiteSpace);\nvar isPunctChar    = (__webpack_require__(7022).isPunctChar);\nvar isMdAsciiPunct = (__webpack_require__(7022).isMdAsciiPunct);\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar APOSTROPHE = '\\u2019'; /* ’ */\n\n\nfunction replaceAt(str, index, ch) {\n  return str.slice(0, index) + ch + str.slice(index + 1);\n}\n\nfunction process_inlines(tokens, state) {\n  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar,\n      isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace,\n      canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;\n\n  stack = [];\n\n  for (i = 0; i < tokens.length; i++) {\n    token = tokens[i];\n\n    thisLevel = tokens[i].level;\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) { break; }\n    }\n    stack.length = j + 1;\n\n    if (token.type !== 'text') { continue; }\n\n    text = token.content;\n    pos = 0;\n    max = text.length;\n\n    /*eslint no-labels:0,block-scoped-var:0*/\n    OUTER:\n    while (pos < max) {\n      QUOTE_RE.lastIndex = pos;\n      t = QUOTE_RE.exec(text);\n      if (!t) { break; }\n\n      canOpen = canClose = true;\n      pos = t.index + 1;\n      isSingle = (t[0] === \"'\");\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      lastChar = 0x20;\n\n      if (t.index - 1 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\n          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);\n          break;\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      nextChar = 0x20;\n\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\n          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          nextChar = tokens[j].content.charCodeAt(0);\n          break;\n        }\n      }\n\n      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n\n      isLastWhiteSpace = isWhiteSpace(lastChar);\n      isNextWhiteSpace = isWhiteSpace(nextChar);\n\n      if (isNextWhiteSpace) {\n        canOpen = false;\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false;\n        }\n      }\n\n      if (isLastWhiteSpace) {\n        canClose = false;\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false;\n        }\n      }\n\n      if (nextChar === 0x22 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n\n      if (canOpen && canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar;\n        canClose = isNextPunctChar;\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n        continue;\n      }\n\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          item = stack[j];\n          if (stack[j].level < thisLevel) { break; }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j];\n\n            if (isSingle) {\n              openQuote = state.md.options.quotes[2];\n              closeQuote = state.md.options.quotes[3];\n            } else {\n              openQuote = state.md.options.quotes[0];\n              closeQuote = state.md.options.quotes[1];\n            }\n\n            // replace token.content *before* tokens[item.token].content,\n            // because, if they are pointing at the same token, replaceAt\n            // could mess up indices when quote length != 1\n            token.content = replaceAt(token.content, t.index, closeQuote);\n            tokens[item.token].content = replaceAt(\n              tokens[item.token].content, item.pos, openQuote);\n\n            pos += closeQuote.length - 1;\n            if (item.token === i) { pos += openQuote.length - 1; }\n\n            text = token.content;\n            max = text.length;\n\n            stack.length = j;\n            continue OUTER;\n          }\n        }\n      }\n\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\n        });\n      } else if (canClose && isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE);\n      }\n    }\n  }\n}\n\n\nmodule.exports = function smartquotes(state) {\n  /*eslint max-depth:0*/\n  var blkIdx;\n\n  if (!state.md.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline' ||\n        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue;\n    }\n\n    process_inlines(state.tokens[blkIdx].children, state);\n  }\n};\n\n\n/***/ }),\n\n/***/ 6480:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Core state object\n//\n\n\nvar Token = __webpack_require__(5872);\n\n\nfunction StateCore(src, md, env) {\n  this.src = src;\n  this.env = env;\n  this.tokens = [];\n  this.inlineMode = false;\n  this.md = md; // link to parser instance\n}\n\n// re-export Token class to use in core rules\nStateCore.prototype.Token = Token;\n\n\nmodule.exports = StateCore;\n\n\n/***/ }),\n\n/***/ 6633:\n/***/ ((module) => {\n\n\"use strict\";\n// Join raw text tokens with the rest of the text\n//\n// This is set as a separate rule to provide an opportunity for plugins\n// to run text replacements after text join, but before escape join.\n//\n// For example, `\\:)` shouldn't be replaced with an emoji.\n//\n\n\n\nmodule.exports = function text_join(state) {\n  var j, l, tokens, curr, max, last,\n      blockTokens = state.tokens;\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') continue;\n\n    tokens = blockTokens[j].children;\n    max = tokens.length;\n\n    for (curr = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text_special') {\n        tokens[curr].type = 'text';\n      }\n    }\n\n    for (curr = last = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text' &&\n          curr + 1 < max &&\n          tokens[curr + 1].type === 'text') {\n\n        // collapse two adjacent text nodes\n        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n      } else {\n        if (curr !== last) { tokens[last] = tokens[curr]; }\n\n        last++;\n      }\n    }\n\n    if (curr !== last) {\n      tokens.length = last;\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 3420:\n/***/ ((module) => {\n\n\"use strict\";\n// Process autolinks '<protocol:...>'\n\n\n\n\n/*eslint max-len:0*/\nvar EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;\nvar AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\\-]{1,31}):([^<>\\x00-\\x20]*)$/;\n\n\nmodule.exports = function autolink(state, silent) {\n  var url, fullUrl, token, ch, start, max,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  start = state.pos;\n  max = state.posMax;\n\n  for (;;) {\n    if (++pos >= max) return false;\n\n    ch = state.src.charCodeAt(pos);\n\n    if (ch === 0x3C /* < */) return false;\n    if (ch === 0x3E /* > */) break;\n  }\n\n  url = state.src.slice(start + 1, pos);\n\n  if (AUTOLINK_RE.test(url)) {\n    fullUrl = state.md.normalizeLink(url);\n    if (!state.md.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      token         = state.push('link_open', 'a', 1);\n      token.attrs   = [ [ 'href', fullUrl ] ];\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\n      token         = state.push('link_close', 'a', -1);\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n    }\n\n    state.pos += url.length + 2;\n    return true;\n  }\n\n  if (EMAIL_RE.test(url)) {\n    fullUrl = state.md.normalizeLink('mailto:' + url);\n    if (!state.md.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      token         = state.push('link_open', 'a', 1);\n      token.attrs   = [ [ 'href', fullUrl ] ];\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\n      token         = state.push('link_close', 'a', -1);\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n    }\n\n    state.pos += url.length + 2;\n    return true;\n  }\n\n  return false;\n};\n\n\n/***/ }),\n\n/***/ 40:\n/***/ ((module) => {\n\n\"use strict\";\n// Parse backticks\n\n\n\n\nmodule.exports = function backtick(state, silent) {\n  var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60/* ` */) { return false; }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  // scan marker length\n  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }\n\n  marker = state.src.slice(start, pos);\n  openerLength = marker.length;\n\n  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {\n    if (!silent) state.pending += marker;\n    state.pos += openerLength;\n    return true;\n  }\n\n  matchStart = matchEnd = pos;\n\n  // Nothing found in the cache, scan until the end of the line (or until marker is found)\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    // scan marker length\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }\n\n    closerLength = matchEnd - matchStart;\n\n    if (closerLength === openerLength) {\n      // Found matching closer length.\n      if (!silent) {\n        token     = state.push('code_inline', 'code', 0);\n        token.markup  = marker;\n        token.content = state.src.slice(pos, matchStart)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1');\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n\n    // Some different length found, put it in cache as upper limit of where closer can be found\n    state.backticks[closerLength] = matchStart;\n  }\n\n  // Scanned through the end, didn't find anything\n  state.backticksScanned = true;\n\n  if (!silent) state.pending += marker;\n  state.pos += openerLength;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 9354:\n/***/ ((module) => {\n\n\"use strict\";\n// For each opening emphasis-like marker find a matching closing one\n//\n\n\n\nfunction processDelimiters(state, delimiters) {\n  var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx,\n      isOddMatch, lastJump,\n      openersBottom = {},\n      max = delimiters.length;\n\n  if (!max) return;\n\n  // headerIdx is the first delimiter of the current (where closer is) delimiter run\n  var headerIdx = 0;\n  var lastTokenIdx = -2; // needs any value lower than -1\n  var jumps = [];\n\n  for (closerIdx = 0; closerIdx < max; closerIdx++) {\n    closer = delimiters[closerIdx];\n\n    jumps.push(0);\n\n    // markers belong to same delimiter run if:\n    //  - they have adjacent tokens\n    //  - AND markers are the same\n    //\n    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n      headerIdx = closerIdx;\n    }\n\n    lastTokenIdx = closer.token;\n\n    // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n    closer.length = closer.length || 0;\n\n    if (!closer.close) continue;\n\n    // Previously calculated lower bounds (previous fails)\n    // for each marker, each delimiter length modulo 3,\n    // and for whether this closer can be an opener;\n    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [ -1, -1, -1, -1, -1, -1 ];\n    }\n\n    minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)];\n\n    openerIdx = headerIdx - jumps[headerIdx] - 1;\n\n    newMinOpenerIdx = openerIdx;\n\n    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      opener = delimiters[openerIdx];\n\n      if (opener.marker !== closer.marker) continue;\n\n      if (opener.open && opener.end < 0) {\n\n        isOddMatch = false;\n\n        // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n        if (opener.close || closer.open) {\n          if ((opener.length + closer.length) % 3 === 0) {\n            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true;\n            }\n          }\n        }\n\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ?\n            jumps[openerIdx - 1] + 1 :\n            0;\n\n          jumps[closerIdx] = closerIdx - openerIdx + lastJump;\n          jumps[openerIdx] = lastJump;\n\n          closer.open  = false;\n          opener.end   = closerIdx;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          // treat next token as start of run,\n          // it optimizes skips in **<...>**a**<...>** pathological case\n          lastTokenIdx = -2;\n          break;\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx;\n    }\n  }\n}\n\n\nmodule.exports = function link_pairs(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  processDelimiters(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      processDelimiters(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 7894:\n/***/ ((module) => {\n\n\"use strict\";\n// Process *this* and _that_\n//\n\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.w = function emphasis(state, silent) {\n  var i, scanned, token,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false; }\n\n  scanned = state.scanDelims(state.pos, marker === 0x2A);\n\n  for (i = 0; i < scanned.length; i++) {\n    token         = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker: marker,\n\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n\n      // A position of the token this delimiter corresponds to.\n      //\n      token:  state.tokens.length - 1,\n\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end:    -1,\n\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open:   scanned.can_open,\n      close:  scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n\n  return true;\n};\n\n\nfunction postProcess(state, delimiters) {\n  var i,\n      startDelim,\n      endDelim,\n      token,\n      ch,\n      isStrong,\n      max = delimiters.length;\n\n  for (i = max - 1; i >= 0; i--) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {\n      continue;\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    isStrong = i > 0 &&\n               delimiters[i - 1].end === startDelim.end + 1 &&\n               // check that first two markers match and adjacent\n               delimiters[i - 1].marker === startDelim.marker &&\n               delimiters[i - 1].token === startDelim.token - 1 &&\n               // check that last two markers are adjacent (we can safely assume they match)\n               delimiters[startDelim.end + 1].token === endDelim.token + 1;\n\n    ch = String.fromCharCode(startDelim.marker);\n\n    token         = state.tokens[startDelim.token];\n    token.type    = isStrong ? 'strong_open' : 'em_open';\n    token.tag     = isStrong ? 'strong' : 'em';\n    token.nesting = 1;\n    token.markup  = isStrong ? ch + ch : ch;\n    token.content = '';\n\n    token         = state.tokens[endDelim.token];\n    token.type    = isStrong ? 'strong_close' : 'em_close';\n    token.tag     = isStrong ? 'strong' : 'em';\n    token.nesting = -1;\n    token.markup  = isStrong ? ch + ch : ch;\n    token.content = '';\n\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = '';\n      state.tokens[delimiters[startDelim.end + 1].token].content = '';\n      i--;\n    }\n  }\n}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.g = function emphasis(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 9391:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Process html entity - &#123;, &#xAF;, &quot;, ...\n\n\n\nvar entities          = __webpack_require__(6233);\nvar has               = (__webpack_require__(7022).has);\nvar isValidEntityCode = (__webpack_require__(7022).isValidEntityCode);\nvar fromCodePoint     = (__webpack_require__(7022).fromCodePoint);\n\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nvar NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;\n\n\nmodule.exports = function entity(state, silent) {\n  var ch, code, match, token, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26/* & */) return false;\n\n  if (pos + 1 >= max) return false;\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch === 0x23 /* # */) {\n    match = state.src.slice(pos).match(DIGITAL_RE);\n    if (match) {\n      if (!silent) {\n        code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n\n        token         = state.push('text_special', '', 0);\n        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n        token.markup  = match[0];\n        token.info    = 'entity';\n      }\n      state.pos += match[0].length;\n      return true;\n    }\n  } else {\n    match = state.src.slice(pos).match(NAMED_RE);\n    if (match) {\n      if (has(entities, match[1])) {\n        if (!silent) {\n          token         = state.push('text_special', '', 0);\n          token.content = entities[match[1]];\n          token.markup  = match[0];\n          token.info    = 'entity';\n        }\n        state.pos += match[0].length;\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n\n\n/***/ }),\n\n/***/ 1917:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Process escaped chars and hardbreaks\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\nvar ESCAPED = [];\n\nfor (var i = 0; i < 256; i++) { ESCAPED.push(0); }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });\n\n\nmodule.exports = function escape(state, silent) {\n  var ch1, ch2, origStr, escapedStr, token, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) return false;\n  pos++;\n\n  // '\\' at the end of the inline block\n  if (pos >= max) return false;\n\n  ch1 = state.src.charCodeAt(pos);\n\n  if (ch1 === 0x0A) {\n    if (!silent) {\n      state.push('hardbreak', 'br', 0);\n    }\n\n    pos++;\n    // skip leading whitespaces from next line\n    while (pos < max) {\n      ch1 = state.src.charCodeAt(pos);\n      if (!isSpace(ch1)) break;\n      pos++;\n    }\n\n    state.pos = pos;\n    return true;\n  }\n\n  escapedStr = state.src[pos];\n\n  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {\n    ch2 = state.src.charCodeAt(pos + 1);\n\n    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\n      escapedStr += state.src[pos + 1];\n      pos++;\n    }\n  }\n\n  origStr = '\\\\' + escapedStr;\n\n  if (!silent) {\n    token = state.push('text_special', '', 0);\n\n    if (ch1 < 256 && ESCAPED[ch1] !== 0) {\n      token.content = escapedStr;\n    } else {\n      token.content = origStr;\n    }\n\n    token.markup = origStr;\n    token.info   = 'escape';\n  }\n\n  state.pos = pos + 1;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 9969:\n/***/ ((module) => {\n\n\"use strict\";\n// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n\n\n\nmodule.exports = function fragments_join(state) {\n  var curr, last,\n      level = 0,\n      tokens = state.tokens,\n      max = state.tokens.length;\n\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level--; // closing tag\n    tokens[curr].level = level;\n    if (tokens[curr].nesting > 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\n        tokens[curr + 1].type === 'text') {\n\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr]; }\n\n      last++;\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last;\n  }\n};\n\n\n/***/ }),\n\n/***/ 1779:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Process html tags\n\n\n\n\nvar HTML_TAG_RE = (__webpack_require__(1947)/* .HTML_TAG_RE */ .n);\n\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\n\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);\n}\n\n\nmodule.exports = function html_inline(state, silent) {\n  var ch, match, max, token,\n      pos = state.pos;\n\n  if (!state.md.options.html) { return false; }\n\n  // Check start\n  max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||\n      pos + 2 >= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\n      !isLetter(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n  if (!match) { return false; }\n\n  if (!silent) {\n    token         = state.push('html_inline', '', 0);\n    token.content = state.src.slice(pos, pos + match[0].length);\n\n    if (isLinkOpen(token.content))  state.linkLevel++;\n    if (isLinkClose(token.content)) state.linkLevel--;\n  }\n  state.pos += match[0].length;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 3006:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Process ![image](<src> \"title\")\n\n\n\nvar normalizeReference   = (__webpack_require__(7022).normalizeReference);\nvar isSpace              = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function image(state, silent) {\n  var attrs,\n      code,\n      content,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      ref,\n      res,\n      title,\n      token,\n      tokens,\n      start,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false; }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false; }\n\n  labelStart = state.pos + 2;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos;\n      return false;\n    }\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd);\n\n    state.md.inline.parse(\n      content,\n      state.md,\n      state.env,\n      tokens = []\n    );\n\n    token          = state.push('image', 'img', 0);\n    token.attrs    = attrs = [ [ 'src', href ], [ 'alt', '' ] ];\n    token.children = tokens;\n    token.content  = content;\n\n    if (title) {\n      attrs.push([ 'title', title ]);\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 1727:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Process [link](<to> \"stuff\")\n\n\n\nvar normalizeReference   = (__webpack_require__(7022).normalizeReference);\nvar isSpace              = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function link(state, silent) {\n  var attrs,\n      code,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      res,\n      ref,\n      token,\n      href = '',\n      title = '',\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      parseReference = true;\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false; }\n\n  labelStart = state.pos + 1;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false;\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos;\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n      if (pos < max && start !== pos && res.ok) {\n        title = res.str;\n        pos = res.pos;\n\n        // [link](  <href>  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos < max; pos++) {\n          code = state.src.charCodeAt(pos);\n          if (!isSpace(code) && code !== 0x0A) { break; }\n        }\n      }\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true;\n    }\n    pos++;\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    token        = state.push('link_open', 'a', 1);\n    token.attrs  = attrs = [ [ 'href', href ] ];\n    if (title) {\n      attrs.push([ 'title', title ]);\n    }\n\n    state.linkLevel++;\n    state.md.inline.tokenize(state);\n    state.linkLevel--;\n\n    token        = state.push('link_close', 'a', -1);\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 2906:\n/***/ ((module) => {\n\n\"use strict\";\n// Process links like https://example.org/\n\n\n\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nvar SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;\n\n\nmodule.exports = function linkify(state, silent) {\n  var pos, max, match, proto, link, url, fullUrl, token;\n\n  if (!state.md.options.linkify) return false;\n  if (state.linkLevel > 0) return false;\n\n  pos = state.pos;\n  max = state.posMax;\n\n  if (pos + 3 > max) return false;\n  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false;\n  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false;\n  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false;\n\n  match = state.pending.match(SCHEME_RE);\n  if (!match) return false;\n\n  proto = match[1];\n\n  link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));\n  if (!link) return false;\n\n  url = link.url;\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  url = url.replace(/\\*+$/, '');\n\n  fullUrl = state.md.normalizeLink(url);\n  if (!state.md.validateLink(fullUrl)) return false;\n\n  if (!silent) {\n    state.pending = state.pending.slice(0, -proto.length);\n\n    token         = state.push('link_open', 'a', 1);\n    token.attrs   = [ [ 'href', fullUrl ] ];\n    token.markup  = 'linkify';\n    token.info    = 'auto';\n\n    token         = state.push('text', '', 0);\n    token.content = state.md.normalizeLinkText(url);\n\n    token         = state.push('link_close', 'a', -1);\n    token.markup  = 'linkify';\n    token.info    = 'auto';\n  }\n\n  state.pos += url.length - proto.length;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 3905:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Proceess '\\n'\n\n\n\nvar isSpace = (__webpack_require__(7022).isSpace);\n\n\nmodule.exports = function newline(state, silent) {\n  var pmax, max, ws, pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false; }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax;\n\n  // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        ws = pmax - 1;\n        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--;\n\n        state.pending = state.pending.slice(0, ws);\n        state.push('hardbreak', 'br', 0);\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push('softbreak', 'br', 0);\n      }\n\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++; }\n\n  state.pos = pos;\n  return true;\n};\n\n\n/***/ }),\n\n/***/ 670:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n// Inline parser state\n\n\n\n\nvar Token          = __webpack_require__(5872);\nvar isWhiteSpace   = (__webpack_require__(7022).isWhiteSpace);\nvar isPunctChar    = (__webpack_require__(7022).isPunctChar);\nvar isMdAsciiPunct = (__webpack_require__(7022).isMdAsciiPunct);\n\n\nfunction StateInline(src, md, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.md = md;\n  this.tokens = outTokens;\n  this.tokens_meta = Array(outTokens.length);\n\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  this.cache = {};\n\n  // List of emphasis-like delimiters for current tag\n  this.delimiters = [];\n\n  // Stack of delimiter lists for upper level tags\n  this._prev_delimiters = [];\n\n  // backtick length => last seen position\n  this.backticks = {};\n  this.backticksScanned = false;\n\n  // Counter used to disable inline linkify-it execution\n  // inside <a> and markdown links\n  this.linkLevel = 0;\n}\n\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  var token = new Token('text', '', 0);\n  token.content = this.pending;\n  token.level = this.pendingLevel;\n  this.tokens.push(token);\n  this.pending = '';\n  return token;\n};\n\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (type, tag, nesting) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  var token = new Token(type, tag, nesting);\n  var token_meta = null;\n\n  if (nesting < 0) {\n    // closing tag\n    this.level--;\n    this.delimiters = this._prev_delimiters.pop();\n  }\n\n  token.level = this.level;\n\n  if (nesting > 0) {\n    // opening tag\n    this.level++;\n    this._prev_delimiters.push(this.delimiters);\n    this.delimiters = [];\n    token_meta = { delimiters: this.delimiters };\n  }\n\n  this.pendingLevel = this.level;\n  this.tokens.push(token);\n  this.tokens_meta.push(token_meta);\n  return token;\n};\n\n\n// Scan a sequence of emphasis-like markers, and determine whether\n// it can start an emphasis sequence or end an emphasis sequence.\n//\n//  - start - position to scan from (it should point at a valid marker);\n//  - canSplitWord - determine if these markers can be found inside a word\n//\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  var pos = start, lastChar, nextChar, count, can_open, can_close,\n      isLastWhiteSpace, isLastPunctChar,\n      isNextWhiteSpace, isNextPunctChar,\n      left_flanking = true,\n      right_flanking = true,\n      max = this.posMax,\n      marker = this.src.charCodeAt(start);\n\n  // treat beginning of the line as a whitespace\n  lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;\n\n  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++; }\n\n  count = pos - start;\n\n  // treat end of the line as a whitespace\n  nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;\n\n  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n\n  isLastWhiteSpace = isWhiteSpace(lastChar);\n  isNextWhiteSpace = isWhiteSpace(nextChar);\n\n  if (isNextWhiteSpace) {\n    left_flanking = false;\n  } else if (isNextPunctChar) {\n    if (!(isLastWhiteSpace || isLastPunctChar)) {\n      left_flanking = false;\n    }\n  }\n\n  if (isLastWhiteSpace) {\n    right_flanking = false;\n  } else if (isLastPunctChar) {\n    if (!(isNextWhiteSpace || isNextPunctChar)) {\n      right_flanking = false;\n    }\n  }\n\n  if (!canSplitWord) {\n    can_open  = left_flanking  && (!right_flanking || isLastPunctChar);\n    can_close = right_flanking && (!left_flanking  || isNextPunctChar);\n  } else {\n    can_open  = left_flanking;\n    can_close = right_flanking;\n  }\n\n  return {\n    can_open:  can_open,\n    can_close: can_close,\n    length:    count\n  };\n};\n\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token;\n\n\nmodule.exports = StateInline;\n\n\n/***/ }),\n\n/***/ 4814:\n/***/ ((module) => {\n\n\"use strict\";\n// ~~strike through~~\n//\n\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.w = function strikethrough(state, silent) {\n  var i, scanned, token, len, ch,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x7E/* ~ */) { return false; }\n\n  scanned = state.scanDelims(state.pos, true);\n  len = scanned.length;\n  ch = String.fromCharCode(marker);\n\n  if (len < 2) { return false; }\n\n  if (len % 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch;\n    len--;\n  }\n\n  for (i = 0; i < len; i += 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch + ch;\n\n    state.delimiters.push({\n      marker: marker,\n      length: 0,     // disable \"rule of 3\" length checks meant for emphasis\n      token:  state.tokens.length - 1,\n      end:    -1,\n      open:   scanned.can_open,\n      close:  scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n\n  return true;\n};\n\n\nfunction postProcess(state, delimiters) {\n  var i, j,\n      startDelim,\n      endDelim,\n      token,\n      loneMarkers = [],\n      max = delimiters.length;\n\n  for (i = 0; i < max; i++) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x7E/* ~ */) {\n      continue;\n    }\n\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\n    token         = state.tokens[startDelim.token];\n    token.type    = 's_open';\n    token.tag     = 's';\n    token.nesting = 1;\n    token.markup  = '~~';\n    token.content = '';\n\n    token         = state.tokens[endDelim.token];\n    token.type    = 's_close';\n    token.tag     = 's';\n    token.nesting = -1;\n    token.markup  = '~~';\n    token.content = '';\n\n    if (state.tokens[endDelim.token - 1].type === 'text' &&\n        state.tokens[endDelim.token - 1].content === '~') {\n\n      loneMarkers.push(endDelim.token - 1);\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n  while (loneMarkers.length) {\n    i = loneMarkers.pop();\n    j = i + 1;\n\n    while (j < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++;\n    }\n\n    j--;\n\n    if (i !== j) {\n      token = state.tokens[j];\n      state.tokens[j] = state.tokens[i];\n      state.tokens[i] = token;\n    }\n  }\n}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.g = function strikethrough(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n\n\n/***/ }),\n\n/***/ 9941:\n/***/ ((module) => {\n\n\"use strict\";\n// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n\n\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos;\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) { return false; }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos); }\n\n  state.pos = pos;\n\n  return true;\n};\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParcerInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n};*/\n\n\n/***/ }),\n\n/***/ 5872:\n/***/ ((module) => {\n\n\"use strict\";\n// Token class\n\n\n\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type;\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag;\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null;\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null;\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting  = nesting;\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0;\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = '';\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = '';\n\n  /**\n   * Token#info -> String\n   *\n   * Additional information:\n   *\n   * - Info string for \"fence\" tokens\n   * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n   * - The string value of the item marker for ordered-list \"list_item_open\" tokens\n   **/\n  this.info     = '';\n\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null;\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false;\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false;\n}\n\n\n/**\n * Token.attrIndex(name) -> Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex(name) {\n  var attrs, i, len;\n\n  if (!this.attrs) { return -1; }\n\n  attrs = this.attrs;\n\n  for (i = 0, len = attrs.length; i < len; i++) {\n    if (attrs[i][0] === name) { return i; }\n  }\n  return -1;\n};\n\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\nToken.prototype.attrPush = function attrPush(attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData);\n  } else {\n    this.attrs = [ attrData ];\n  }\n};\n\n\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet(name, value) {\n  var idx = this.attrIndex(name),\n      attrData = [ name, value ];\n\n  if (idx < 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet(name) {\n  var idx = this.attrIndex(name), value = null;\n  if (idx >= 0) {\n    value = this.attrs[idx][1];\n  }\n  return value;\n};\n\n\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  var idx = this.attrIndex(name);\n\n  if (idx < 0) {\n    this.attrPush([ name, value ]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\n\nmodule.exports = Token;\n\n\n/***/ }),\n\n/***/ 3122:\n/***/ ((module) => {\n\n\"use strict\";\n\n\n\n\n/* eslint-disable no-bitwise */\n\nvar decodeCache = {};\n\nfunction getDecodeCache(exclude) {\n  var i, ch, cache = decodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = decodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n    cache.push(ch);\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    ch = exclude.charCodeAt(i);\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);\n  }\n\n  return cache;\n}\n\n\n// Decode percent-encoded string.\n//\nfunction decode(string, exclude) {\n  var cache;\n\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars;\n  }\n\n  cache = getDecodeCache(exclude);\n\n  return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {\n    var i, l, b1, b2, b3, b4, chr,\n        result = '';\n\n    for (i = 0, l = seq.length; i < l; i += 3) {\n      b1 = parseInt(seq.slice(i + 1, i + 3), 16);\n\n      if (b1 < 0x80) {\n        result += cache[b1];\n        continue;\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {\n        // 110xxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n\n        if ((b2 & 0xC0) === 0x80) {\n          chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);\n\n          if (chr < 0x80) {\n            result += '\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 3;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);\n\n          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {\n            result += '\\ufffd\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 6;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n        b4 = parseInt(seq.slice(i + 10, i + 12), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += '\\ufffd\\ufffd\\ufffd\\ufffd';\n          } else {\n            chr -= 0x10000;\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));\n          }\n\n          i += 9;\n          continue;\n        }\n      }\n\n      result += '\\ufffd';\n    }\n\n    return result;\n  });\n}\n\n\ndecode.defaultChars   = ';/?:@&=+$,#';\ndecode.componentChars = '';\n\n\nmodule.exports = decode;\n\n\n/***/ }),\n\n/***/ 729:\n/***/ ((module) => {\n\n\"use strict\";\n\n\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\n\n\n/***/ }),\n\n/***/ 2201:\n/***/ ((module) => {\n\n\"use strict\";\n\n\n\n\nmodule.exports = function format(url) {\n  var result = '';\n\n  result += url.protocol || '';\n  result += url.slashes ? '//' : '';\n  result += url.auth ? url.auth + '@' : '';\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']';\n  } else {\n    result += url.hostname || '';\n  }\n\n  result += url.port ? ':' + url.port : '';\n  result += url.pathname || '';\n  result += url.search || '';\n  result += url.hash || '';\n\n  return result;\n};\n\n\n/***/ }),\n\n/***/ 8765:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\n\nmodule.exports.encode = __webpack_require__(729);\nmodule.exports.decode = __webpack_require__(3122);\nmodule.exports.format = __webpack_require__(2201);\nmodule.exports.parse = __webpack_require__(9553);\n\n\n/***/ }),\n\n/***/ 9553:\n/***/ ((module) => {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\n//\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.pathname = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = [ '<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t' ],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = [ '{', '}', '|', '\\\\', '^', '`' ].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = [ '\\'' ].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = [ '%', '/', '?', ';', '#' ].concat(autoEscape),\n    hostEndingChars = [ '/', '?', '#' ],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    /* eslint-disable no-script-url */\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    };\n    /* eslint-enable no-script-url */\n\nfunction urlParse(url, slashesDenoteHost) {\n  if (url && url instanceof Url) { return url; }\n\n  var u = new Url();\n  u.parse(url, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, slashesDenoteHost) {\n  var i, l, lowerProto, hec, slashes,\n      rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    lowerProto = proto.toLowerCase();\n    this.protocol = proto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = auth;\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) {\n      hostEnd = rest.length;\n    }\n\n    if (rest[hostEnd - 1] === ':') { hostEnd--; }\n    var host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost(host);\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) { continue; }\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    }\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n    }\n  }\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    rest = rest.slice(0, qm);\n  }\n  if (rest) { this.pathname = rest; }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '';\n  }\n\n  return this;\n};\n\nUrl.prototype.parseHost = function(host) {\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) { this.hostname = host; }\n};\n\nmodule.exports = urlParse;\n\n\n/***/ }),\n\n/***/ 7268:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Aggregator = void 0;\nconst core_1 = __webpack_require__(9587);\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Provides functionality for the mongoDB aggregation pipeline\n *\n * @param pipeline an Array of pipeline operators\n * @param options An optional Options to pass the aggregator\n * @constructor\n */\nclass Aggregator {\n    constructor(pipeline, options) {\n        this.pipeline = pipeline;\n        this.options = (0, core_1.initOptions)(options);\n    }\n    /**\n     * Returns an `Lazy` iterator for processing results of pipeline\n     *\n     * @param {*} collection An array or iterator object\n     * @returns {Iterator} an iterator object\n     */\n    stream(collection) {\n        let iterator = (0, lazy_1.Lazy)(collection);\n        const mode = this.options.processingMode;\n        if (mode == core_1.ProcessingMode.CLONE_ALL ||\n            mode == core_1.ProcessingMode.CLONE_INPUT) {\n            iterator.map(util_1.cloneDeep);\n        }\n        const pipelineOperators = new Array();\n        if (!(0, util_1.isEmpty)(this.pipeline)) {\n            // run aggregation pipeline\n            for (const operator of this.pipeline) {\n                const operatorKeys = Object.keys(operator);\n                const opName = operatorKeys[0];\n                const call = (0, core_1.getOperator)(core_1.OperatorType.PIPELINE, opName, this.options);\n                (0, util_1.assert)(operatorKeys.length === 1 && !!call, `invalid pipeline operator ${opName}`);\n                pipelineOperators.push(opName);\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n                iterator = call(iterator, operator[opName], this.options);\n            }\n        }\n        // operators that may share object graphs of inputs.\n        // we only need to clone the output for these since the objects will already be distinct for other operators.\n        if (mode == core_1.ProcessingMode.CLONE_OUTPUT ||\n            (mode == core_1.ProcessingMode.CLONE_ALL &&\n                !!(0, util_1.intersection)([[\"$group\", \"$unwind\"], pipelineOperators]).length)) {\n            iterator.map(util_1.cloneDeep);\n        }\n        return iterator;\n    }\n    /**\n     * Return the results of the aggregation as an array.\n     *\n     * @param {*} collection\n     * @param {*} query\n     */\n    run(collection) {\n        return this.stream(collection).value();\n    }\n}\nexports.Aggregator = Aggregator;\n\n\n/***/ }),\n\n/***/ 9587:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.redact = exports.computeValue = exports.getOperator = exports.useOperators = exports.Context = exports.OperatorType = exports.initOptions = exports.ComputeOptions = exports.ProcessingMode = void 0;\nconst util_1 = __webpack_require__(7216);\n/**\n * This controls how input and output documents are processed to meet different application needs.\n * Each mode has different trade offs for; immutability, reference sharing, and performance.\n */\nvar ProcessingMode;\n(function (ProcessingMode) {\n    /**\n     * Clone inputs prior to processing, and the outputs if some objects graphs may be shared.\n     * Use this option to keep input collection immutable and to get distinct output objects.\n     *\n     * Note: This option is expensive and reduces performance.\n     */\n    ProcessingMode[\"CLONE_ALL\"] = \"CLONE_ALL\";\n    /**\n     * Clones inputs prior to processing.\n     * This option will return output objects with shared graphs in their path if specific operators are used.\n     * Use this option to keep the input collection immutable.\n     *\n     */\n    ProcessingMode[\"CLONE_INPUT\"] = \"CLONE_INPUT\";\n    /**\n     * Clones the output to return distinct objects with no shared paths.\n     * This option modifies the input collection and during processing.\n     */\n    ProcessingMode[\"CLONE_OUTPUT\"] = \"CLONE_OUTPUT\";\n    /**\n     * Turn off cloning and modifies the input collection as needed.\n     * This option will also return output objects with shared paths in their graph when specific operators are used.\n     * This option provides the greatest speedup for the biggest tradeoff.\n     * When using the aggregation pipeline, you can use the \"$out\" operator to collect immutable intermediate results.\n     *\n     * @default\n     */\n    ProcessingMode[\"CLONE_OFF\"] = \"CLONE_OFF\";\n})(ProcessingMode = exports.ProcessingMode || (exports.ProcessingMode = {}));\n/** Custom type to facilitate type checking for global options */\nclass ComputeOptions {\n    constructor(_opts, \n    /** Reference to the root object when processing subgraphs of the object. */\n    _root, _local, \n    /** The current time in milliseconds. Remains the same throughout all stages of the aggregation pipeline. */\n    timestamp = Date.now()) {\n        this._opts = _opts;\n        this._root = _root;\n        this._local = _local;\n        this.timestamp = timestamp;\n        this.update(_root, _local);\n    }\n    /**\n     * Initialize new ComputeOptions.\n     *\n     * @param options\n     * @param root\n     * @param local\n     * @returns {ComputeOptions}\n     */\n    static init(options, root, local) {\n        return options instanceof ComputeOptions\n            ? new ComputeOptions(options._opts, (0, util_1.isNil)(options.root) ? root : options.root, Object.assign({}, options.local, local))\n            : new ComputeOptions(options, root, local);\n    }\n    /** Updates the internal mutable state. */\n    update(root, local) {\n        var _a;\n        // NOTE: this is done for efficiency to avoid creating too many intermediate options objects.\n        this._root = root;\n        this._local = local\n            ? Object.assign({}, local, {\n                variables: Object.assign({}, (_a = this._local) === null || _a === void 0 ? void 0 : _a.variables, local === null || local === void 0 ? void 0 : local.variables)\n            })\n            : local;\n        return this;\n    }\n    getOptions() {\n        return Object.freeze(Object.assign(Object.assign({}, this._opts), { context: Context.from(this._opts.context) }));\n    }\n    get root() {\n        return this._root;\n    }\n    get local() {\n        return this._local;\n    }\n    get idKey() {\n        return this._opts.idKey;\n    }\n    get collation() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.collation;\n    }\n    get processingMode() {\n        var _a;\n        return ((_a = this._opts) === null || _a === void 0 ? void 0 : _a.processingMode) || ProcessingMode.CLONE_OFF;\n    }\n    get useStrictMode() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.useStrictMode;\n    }\n    get scriptEnabled() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.scriptEnabled;\n    }\n    get useGlobalContext() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.useGlobalContext;\n    }\n    get hashFunction() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.hashFunction;\n    }\n    get collectionResolver() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.collectionResolver;\n    }\n    get jsonSchemaValidator() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.jsonSchemaValidator;\n    }\n    get variables() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.variables;\n    }\n    get context() {\n        var _a;\n        return (_a = this._opts) === null || _a === void 0 ? void 0 : _a.context;\n    }\n}\nexports.ComputeOptions = ComputeOptions;\n/**\n * Creates an Option from another where required keys are initialized.\n * @param options Options\n */\nfunction initOptions(options) {\n    return options instanceof ComputeOptions\n        ? options.getOptions()\n        : Object.freeze(Object.assign(Object.assign({ idKey: \"_id\", scriptEnabled: true, useStrictMode: true, useGlobalContext: true, processingMode: ProcessingMode.CLONE_OFF }, options), { context: (options === null || options === void 0 ? void 0 : options.context)\n                ? Context.from(options === null || options === void 0 ? void 0 : options.context)\n                : Context.init({}) }));\n}\nexports.initOptions = initOptions;\n/**\n * The different groups of operators\n */\nvar OperatorType;\n(function (OperatorType) {\n    OperatorType[\"ACCUMULATOR\"] = \"accumulator\";\n    OperatorType[\"EXPRESSION\"] = \"expression\";\n    OperatorType[\"PIPELINE\"] = \"pipeline\";\n    OperatorType[\"PROJECTION\"] = \"projection\";\n    OperatorType[\"QUERY\"] = \"query\";\n    OperatorType[\"WINDOW\"] = \"window\";\n})(OperatorType = exports.OperatorType || (exports.OperatorType = {}));\nclass Context {\n    constructor(ops) {\n        this.operators = (0, util_1.cloneDeep)(ops);\n    }\n    static init(ops) {\n        return new Context((0, util_1.merge)({\n            [OperatorType.ACCUMULATOR]: {},\n            [OperatorType.EXPRESSION]: {},\n            [OperatorType.PIPELINE]: {},\n            [OperatorType.PROJECTION]: {},\n            [OperatorType.QUERY]: {},\n            [OperatorType.WINDOW]: {}\n        }, ops, { skipValidation: true }));\n    }\n    static from(ctx) {\n        return new Context(ctx.operators);\n    }\n    addOperators(type, ops) {\n        for (const [name, fn] of Object.entries(ops)) {\n            if (!this.getOperator(type, name)) {\n                this.operators[type][name] = fn;\n            }\n        }\n        return this;\n    }\n    // register\n    addAccumulatorOps(ops) {\n        return this.addOperators(OperatorType.ACCUMULATOR, ops);\n    }\n    addExpressionOps(ops) {\n        return this.addOperators(OperatorType.EXPRESSION, ops);\n    }\n    addQueryOps(ops) {\n        return this.addOperators(OperatorType.QUERY, ops);\n    }\n    addPipelineOps(ops) {\n        return this.addOperators(OperatorType.PIPELINE, ops);\n    }\n    addProjectionOps(ops) {\n        return this.addOperators(OperatorType.PROJECTION, ops);\n    }\n    addWindowOps(ops) {\n        return this.addOperators(OperatorType.WINDOW, ops);\n    }\n    // getters\n    getOperator(type, name) {\n        return type in this.operators ? this.operators[type][name] || null : null;\n    }\n}\nexports.Context = Context;\n// operator definitions\nconst CONTEXT = Context.init({});\n/**\n * Register fully specified operators for the given operator class.\n *\n * @param type The operator type\n * @param operators Map of the operators\n */\nfunction useOperators(type, operators) {\n    for (const [name, fn] of Object.entries(operators)) {\n        (0, util_1.assert)((0, util_1.isFunction)(fn) && (0, util_1.isOperator)(name), `'${name}' is not a valid operator`);\n        const currentFn = getOperator(type, name, null);\n        (0, util_1.assert)(!currentFn || fn === currentFn, `${name} already exists for '${type}' operators. Cannot change operator function once registered.`);\n    }\n    // toss the operator salad :)\n    CONTEXT.addOperators(type, operators);\n}\nexports.useOperators = useOperators;\n/**\n * Returns the operator function or undefined if it is not found\n * @param type Type of operator\n * @param operator Name of the operator\n */\nfunction getOperator(type, operator, options) {\n    const { context: ctx, useGlobalContext: fallback } = options || {};\n    const fn = ctx ? ctx.getOperator(type, operator) : null;\n    return !fn && fallback ? CONTEXT.getOperator(type, operator) : fn;\n}\nexports.getOperator = getOperator;\n/* eslint-disable unused-imports/no-unused-vars-ts */\n/**\n * Implementation of system variables\n * @type {Object}\n */\nconst systemVariables = {\n    $$ROOT(obj, expr, options) {\n        return options.root;\n    },\n    $$CURRENT(obj, expr, options) {\n        return obj;\n    },\n    $$REMOVE(obj, expr, options) {\n        return undefined;\n    },\n    $$NOW(obj, expr, options) {\n        return new Date(options.timestamp);\n    }\n};\n/**\n * Implementation of $redact variables\n *\n * Each function accepts 3 arguments (obj, expr, options)\n *\n * @type {Object}\n */\nconst redactVariables = {\n    $$KEEP(obj, expr, options) {\n        return obj;\n    },\n    $$PRUNE(obj, expr, options) {\n        return undefined;\n    },\n    $$DESCEND(obj, expr, options) {\n        // traverse nested documents iff there is a $cond\n        if (!(0, util_1.has)(expr, \"$cond\"))\n            return obj;\n        let result;\n        for (const [key, current] of Object.entries(obj)) {\n            if ((0, util_1.isObjectLike)(current)) {\n                if (current instanceof Array) {\n                    const array = [];\n                    for (let elem of current) {\n                        if ((0, util_1.isObject)(elem)) {\n                            elem = redact(elem, expr, options.update(elem));\n                        }\n                        if (!(0, util_1.isNil)(elem)) {\n                            array.push(elem);\n                        }\n                    }\n                    result = array;\n                }\n                else {\n                    result = redact(current, expr, options.update(current));\n                }\n                if ((0, util_1.isNil)(result)) {\n                    delete obj[key]; // pruned result\n                }\n                else {\n                    obj[key] = result;\n                }\n            }\n        }\n        return obj;\n    }\n};\n/* eslint-enable unused-imports/no-unused-vars-ts */\n/**\n * Computes the value of the expression on the object for the given operator\n *\n * @param obj the current object from the collection\n * @param expr the expression for the given field\n * @param operator the operator to resolve the field with\n * @param options {Object} extra options\n * @returns {*}\n */\nfunction computeValue(obj, expr, operator, options) {\n    var _a;\n    // ensure valid options exist on first invocation\n    const copts = ComputeOptions.init(options, obj);\n    operator = operator || \"\";\n    if ((0, util_1.isOperator)(operator)) {\n        // if the field of the object is a valid operator\n        const callExpression = getOperator(OperatorType.EXPRESSION, operator, options);\n        if (callExpression)\n            return callExpression(obj, expr, copts);\n        // we also handle $group accumulator operators\n        const callAccumulator = getOperator(OperatorType.ACCUMULATOR, operator, options);\n        if (callAccumulator) {\n            // if object is not an array, first try to compute using the expression\n            if (!(obj instanceof Array)) {\n                obj = computeValue(obj, expr, null, copts);\n                expr = null;\n            }\n            // validate that we have an array\n            (0, util_1.assert)(obj instanceof Array, `'${operator}' target must be an array.`);\n            // for accumulators, we use the global options since the root is specific to each element within array.\n            return callAccumulator(obj, expr, \n            // reset the root object for accumulators.\n            copts.update(null, copts.local));\n        }\n        // operator was not found\n        throw new Error(`operator '${operator}' is not registered`);\n    }\n    // if expr is a string and begins with \"$$\", then we have a variable.\n    //  this can be one of; redact variable, system variable, user-defined variable.\n    //  we check and process them in that order.\n    //\n    // if expr begins only a single \"$\", then it is a path to a field on the object.\n    if ((0, util_1.isString)(expr) && expr.length > 0 && expr[0] === \"$\") {\n        // we return redact variables as literals\n        if ((0, util_1.has)(redactVariables, expr)) {\n            return expr;\n        }\n        // default to root for resolving path.\n        let context = copts.root;\n        // handle selectors with explicit prefix\n        const arr = expr.split(\".\");\n        if ((0, util_1.has)(systemVariables, arr[0])) {\n            // set 'root' only the first time it is required to be used for all subsequent calls\n            // if it already available on the options, it will be used\n            context = systemVariables[arr[0]](obj, null, copts);\n            expr = expr.slice(arr[0].length + 1); //  +1 for '.'\n        }\n        else if (arr[0].slice(0, 2) === \"$$\") {\n            // handle user-defined variables\n            context = Object.assign({}, copts.variables, // global vars\n            // current item is added before local variables because the binding may be changed.\n            { this: obj }, (_a = copts.local) === null || _a === void 0 ? void 0 : _a.variables // local vars\n            );\n            const prefix = arr[0].slice(2);\n            (0, util_1.assert)((0, util_1.has)(context, prefix), `Use of undefined variable: ${prefix}`);\n            expr = expr.slice(2);\n        }\n        else {\n            // 'expr' is a path to a field on the object.\n            expr = expr.slice(1);\n        }\n        if (expr === \"\")\n            return context;\n        return (0, util_1.resolve)(context, expr);\n    }\n    // check and return value if already in a resolved state\n    if ((0, util_1.isArray)(expr)) {\n        return expr.map((item) => computeValue(obj, item, null, copts));\n    }\n    else if ((0, util_1.isObject)(expr)) {\n        const result = {};\n        for (const [key, val] of Object.entries(expr)) {\n            result[key] = computeValue(obj, val, key, copts);\n            // must run ONLY one aggregate operator per expression\n            // if so, return result of the computed value\n            if ([OperatorType.EXPRESSION, OperatorType.ACCUMULATOR].some(t => !!getOperator(t, key, options))) {\n                // there should be only one operator\n                (0, util_1.assert)(Object.keys(expr).length === 1, \"Invalid aggregation expression '\" + JSON.stringify(expr) + \"'\");\n                return result[key];\n            }\n        }\n        return result;\n    }\n    return expr;\n}\nexports.computeValue = computeValue;\n/**\n * Redact an object\n * @param  {Object} obj The object to redact\n * @param  {*} expr The redact expression\n * @param  {*} options  Options for value\n * @return {*} returns the result of the redacted object\n */\nfunction redact(obj, expr, options) {\n    const result = computeValue(obj, expr, null, options);\n    return (0, util_1.has)(redactVariables, result)\n        ? redactVariables[result](obj, expr, options)\n        : result;\n}\nexports.redact = redact;\n\n\n/***/ }),\n\n/***/ 3645:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Cursor = void 0;\nconst aggregator_1 = __webpack_require__(7268);\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Cursor to iterate and perform filtering on matched objects.\n * This object must not be used directly. A cursor may be obtaine from calling `find()` on an instance of `Query`.\n *\n * @param collection The input source of the collection\n * @param predicate A predicate function to test documents\n * @param projection A projection criteria\n * @param options Options\n * @constructor\n */\nclass Cursor {\n    constructor(source, predicate, projection, options) {\n        this.source = source;\n        this.predicate = predicate;\n        this.projection = projection;\n        this.options = options;\n        this.operators = [];\n        this.result = null;\n        this.buffer = [];\n    }\n    /** Returns the iterator from running the query */\n    fetch() {\n        if (this.result)\n            return this.result;\n        // add projection operator\n        if ((0, util_1.isObject)(this.projection)) {\n            this.operators.push({ $project: this.projection });\n        }\n        // filter collection\n        this.result = (0, lazy_1.Lazy)(this.source).filter(this.predicate);\n        if (this.operators.length > 0) {\n            this.result = new aggregator_1.Aggregator(this.operators, this.options).stream(this.result);\n        }\n        return this.result;\n    }\n    /** Returns an iterator with the buffered data included */\n    fetchAll() {\n        const buffered = (0, lazy_1.Lazy)([...this.buffer]);\n        this.buffer = [];\n        return (0, lazy_1.compose)(buffered, this.fetch());\n    }\n    /**\n     * Return remaining objects in the cursor as an array. This method exhausts the cursor\n     * @returns {Array}\n     */\n    all() {\n        return this.fetchAll().value();\n    }\n    /**\n     * Returns the number of objects return in the cursor. This method exhausts the cursor\n     * @returns {Number}\n     */\n    count() {\n        return this.all().length;\n    }\n    /**\n     * Returns a cursor that begins returning results only after passing or skipping a number of documents.\n     * @param {Number} n the number of results to skip.\n     * @return {Cursor} Returns the cursor, so you can chain this call.\n     */\n    skip(n) {\n        this.operators.push({ $skip: n });\n        return this;\n    }\n    /**\n     * Constrains the size of a cursor's result set.\n     * @param {Number} n the number of results to limit to.\n     * @return {Cursor} Returns the cursor, so you can chain this call.\n     */\n    limit(n) {\n        this.operators.push({ $limit: n });\n        return this;\n    }\n    /**\n     * Returns results ordered according to a sort specification.\n     * @param {Object} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending\n     * @return {Cursor} Returns the cursor, so you can chain this call.\n     */\n    sort(modifier) {\n        this.operators.push({ $sort: modifier });\n        return this;\n    }\n    /**\n     * Specifies the collation for the cursor returned by the `mingo.Query.find`\n     * @param {*} spec\n     */\n    collation(spec) {\n        this.options = Object.assign(Object.assign({}, this.options), { collation: spec });\n        return this;\n    }\n    /**\n     * Returns the next document in a cursor.\n     * @returns {Object | Boolean}\n     */\n    next() {\n        // yield value obtains in hasNext()\n        if (this.buffer.length > 0) {\n            return this.buffer.pop();\n        }\n        const o = this.fetch().next();\n        if (o.done)\n            return;\n        return o.value;\n    }\n    /**\n     * Returns true if the cursor has documents and can be iterated.\n     * @returns {boolean}\n     */\n    hasNext() {\n        // there is a value in the buffer\n        if (this.buffer.length > 0)\n            return true;\n        const o = this.fetch().next();\n        if (o.done)\n            return false;\n        this.buffer.push(o.value);\n        return true;\n    }\n    /**\n     * Applies a function to each document in a cursor and collects the return values in an array.\n     * @param callback\n     * @returns {Array}\n     */\n    map(callback) {\n        return this.all().map(callback);\n    }\n    /**\n     * Applies a JavaScript function for every document in a cursor.\n     * @param callback\n     */\n    forEach(callback) {\n        this.all().forEach(callback);\n    }\n    [Symbol.iterator]() {\n        return this.fetchAll();\n    }\n}\nexports.Cursor = Cursor;\n\n\n/***/ }),\n\n/***/ 6090:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.aggregate = exports.remove = exports.find = exports.Query = exports.Aggregator = void 0;\n// loads basic operators\n__webpack_require__(9207);\nconst aggregator_1 = __webpack_require__(7268);\nconst query_1 = __webpack_require__(809);\nvar aggregator_2 = __webpack_require__(7268);\nObject.defineProperty(exports, \"Aggregator\", ({ enumerable: true, get: function () { return aggregator_2.Aggregator; } }));\nvar query_2 = __webpack_require__(809);\nObject.defineProperty(exports, \"Query\", ({ enumerable: true, get: function () { return query_2.Query; } }));\n/**\n * Performs a query on a collection and returns a cursor object.\n * Shorthand for `Query(criteria).find(collection, projection)`\n *\n * @param collection Array of objects\n * @param criteria Query criteria\n * @param projection Projection criteria\n * @param options\n * @returns {Cursor} A cursor of results\n */\nfunction find(collection, criteria, projection, options) {\n    return new query_1.Query(criteria, options).find(collection, projection);\n}\nexports.find = find;\n/**\n * Returns a new array without objects which match the criteria\n *\n * @param collection Array of objects\n * @param criteria Query criteria of objects to remove\n * @param options\n * @returns {Array} New filtered array\n */\nfunction remove(collection, criteria, options) {\n    return new query_1.Query(criteria, options).remove(collection);\n}\nexports.remove = remove;\n/**\n * Return the result collection after running the aggregation pipeline for the given collection.\n * Shorthand for `(new Aggregator(pipeline, options)).run(collection)`\n *\n * @param collection array or stream of objects\n * @param pipeline The pipeline operators to use\n * @param options\n * @returns {Array} New array of results\n */\nfunction aggregate(collection, pipeline, options) {\n    return new aggregator_1.Aggregator(pipeline, options).run(collection);\n}\nexports.aggregate = aggregate;\n// default interface\nexports[\"default\"] = {\n    Aggregator: aggregator_1.Aggregator,\n    Query: query_1.Query,\n    aggregate,\n    find,\n    remove\n};\n\n\n/***/ }),\n\n/***/ 9207:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.BASIC_CONTEXT = void 0;\n/**\n * Loads all Query and Projection operators\n */\nconst core_1 = __webpack_require__(9587);\nconst booleanOperators = __importStar(__webpack_require__(628));\nconst comparisonOperators = __importStar(__webpack_require__(4591));\nconst pipeline_1 = __webpack_require__(6582);\nconst projectionOperators = __importStar(__webpack_require__(3791));\nconst queryOperators = __importStar(__webpack_require__(5444));\n(0, core_1.useOperators)(core_1.OperatorType.EXPRESSION, Object.assign(Object.assign({}, booleanOperators), comparisonOperators));\n(0, core_1.useOperators)(core_1.OperatorType.PIPELINE, {\n    $project: pipeline_1.$project,\n    $skip: pipeline_1.$skip,\n    $limit: pipeline_1.$limit,\n    $sort: pipeline_1.$sort\n});\n(0, core_1.useOperators)(core_1.OperatorType.PROJECTION, projectionOperators);\n(0, core_1.useOperators)(core_1.OperatorType.QUERY, queryOperators);\n/** The basic context for queries. */\nexports.BASIC_CONTEXT = core_1.Context.init({\n    [core_1.OperatorType.EXPRESSION]: Object.assign(Object.assign({}, booleanOperators), comparisonOperators),\n    [core_1.OperatorType.PIPELINE]: {\n        $project: pipeline_1.$project,\n        $skip: pipeline_1.$skip,\n        $limit: pipeline_1.$limit,\n        $sort: pipeline_1.$sort\n    },\n    [core_1.OperatorType.PROJECTION]: projectionOperators,\n    [core_1.OperatorType.QUERY]: queryOperators\n});\n\n\n/***/ }),\n\n/***/ 9176:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Iterator = exports.compose = exports.Lazy = void 0;\n/**\n * Returns an iterator\n * @param {*} source An iterable source (Array, Function, Generator, or Iterator)\n */\nfunction Lazy(source) {\n    return source instanceof Iterator ? source : new Iterator(source);\n}\nexports.Lazy = Lazy;\nfunction compose(...iterators) {\n    let index = 0;\n    return Lazy(() => {\n        while (index < iterators.length) {\n            const o = iterators[index].next();\n            if (!o.done)\n                return o;\n            index++;\n        }\n        return { done: true };\n    });\n}\nexports.compose = compose;\n/**\n * Checks whether the given object is compatible with a generator i.e Object{next:Function}\n * @param {*} o An object\n */\nfunction isGenerator(o) {\n    return (!!o && typeof o === \"object\" && (o === null || o === void 0 ? void 0 : o.next) instanceof Function);\n}\nfunction dropItem(array, i) {\n    const rest = array.slice(i + 1);\n    array.splice(i);\n    Array.prototype.push.apply(array, rest);\n}\n// stop iteration error\nconst DONE = new Error();\n// Lazy function actions\nvar Action;\n(function (Action) {\n    Action[Action[\"MAP\"] = 0] = \"MAP\";\n    Action[Action[\"FILTER\"] = 1] = \"FILTER\";\n    Action[Action[\"TAKE\"] = 2] = \"TAKE\";\n    Action[Action[\"DROP\"] = 3] = \"DROP\";\n})(Action || (Action = {}));\nfunction createCallback(nextFn, iteratees, buffer) {\n    let done = false;\n    let index = -1;\n    let bufferIndex = 0; // index for the buffer\n    return function (storeResult) {\n        // special hack to collect all values into buffer\n        try {\n            outer: while (!done) {\n                let o = nextFn();\n                index++;\n                let i = -1;\n                const size = iteratees.length;\n                let innerDone = false;\n                while (++i < size) {\n                    const r = iteratees[i];\n                    switch (r.action) {\n                        case Action.MAP:\n                            o = r.func(o, index);\n                            break;\n                        case Action.FILTER:\n                            if (!r.func(o, index))\n                                continue outer;\n                            break;\n                        case Action.TAKE:\n                            --r.count;\n                            if (!r.count)\n                                innerDone = true;\n                            break;\n                        case Action.DROP:\n                            --r.count;\n                            if (!r.count)\n                                dropItem(iteratees, i);\n                            continue outer;\n                        default:\n                            break outer;\n                    }\n                }\n                done = innerDone;\n                if (storeResult) {\n                    buffer[bufferIndex++] = o;\n                }\n                else {\n                    return { value: o, done: false };\n                }\n            }\n        }\n        catch (e) {\n            if (e !== DONE)\n                throw e;\n        }\n        done = true;\n        return { done };\n    };\n}\n/**\n * A lazy collection iterator yields a single value at time upon request\n */\nclass Iterator {\n    /**\n     * @param {*} source An iterable object or function.\n     *    Array - return one element per cycle\n     *    Object{next:Function} - call next() for the next value (this also handles generator functions)\n     *    Function - call to return the next value\n     * @param {Function} fn An optional transformation function\n     */\n    constructor(source) {\n        this.iteratees = [];\n        this.yieldedValues = [];\n        this.isDone = false;\n        let nextVal;\n        if (source instanceof Function) {\n            // make iterable\n            source = { next: source };\n        }\n        if (isGenerator(source)) {\n            const src = source;\n            nextVal = () => {\n                const o = src.next();\n                if (o.done)\n                    throw DONE;\n                return o.value;\n            };\n        }\n        else if (source instanceof Array) {\n            const data = source;\n            const size = data.length;\n            let index = 0;\n            nextVal = () => {\n                if (index < size)\n                    return data[index++];\n                throw DONE;\n            };\n        }\n        else if (!(source instanceof Function)) {\n            throw new Error(`Source is of type '${typeof source}'. Must be Array, Function, or Generator`);\n        }\n        // create next function\n        this.getNext = createCallback(nextVal, this.iteratees, this.yieldedValues);\n    }\n    /**\n     * Add an iteratee to this lazy sequence\n     */\n    push(action, value) {\n        if (typeof value === \"function\") {\n            this.iteratees.push({ action, func: value });\n        }\n        else if (typeof value === \"number\") {\n            this.iteratees.push({ action, count: value });\n        }\n        return this;\n    }\n    next() {\n        return this.getNext();\n    }\n    // Iteratees methods\n    /**\n     * Transform each item in the sequence to a new value\n     * @param {Function} f\n     */\n    map(f) {\n        return this.push(Action.MAP, f);\n    }\n    /**\n     * Select only items matching the given predicate\n     * @param {Function} pred\n     */\n    filter(predicate) {\n        return this.push(Action.FILTER, predicate);\n    }\n    /**\n     * Take given numbe for values from sequence\n     * @param {Number} n A number greater than 0\n     */\n    take(n) {\n        return n > 0 ? this.push(Action.TAKE, n) : this;\n    }\n    /**\n     * Drop a number of values from the sequence\n     * @param {Number} n Number of items to drop greater than 0\n     */\n    drop(n) {\n        return n > 0 ? this.push(Action.DROP, n) : this;\n    }\n    // Transformations\n    /**\n     * Returns a new lazy object with results of the transformation\n     * The entire sequence is realized.\n     *\n     * @param {Function} fn Tranform function of type (Array) => (Any)\n     */\n    transform(fn) {\n        const self = this;\n        let iter;\n        return Lazy(() => {\n            if (!iter) {\n                iter = Lazy(fn(self.value()));\n            }\n            return iter.next();\n        });\n    }\n    // Terminal methods\n    /**\n     * Returns the fully realized values of the iterators.\n     * The return value will be an array unless `lazy.first()` was used.\n     * The realized values are cached for subsequent calls\n     */\n    value() {\n        if (!this.isDone) {\n            this.isDone = this.getNext(true).done;\n        }\n        return this.yieldedValues;\n    }\n    /**\n     * Execute the funcion for each value. Will stop when an execution returns false.\n     * @param {Function} f\n     * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true\n     */\n    each(f) {\n        for (;;) {\n            const o = this.next();\n            if (o.done)\n                break;\n            if (f(o.value) === false)\n                return false;\n        }\n        return true;\n    }\n    /**\n     * Returns the reduction of sequence according the reducing function\n     *\n     * @param {*} f a reducing function\n     * @param {*} init\n     */\n    reduce(f, initialValue) {\n        let o = this.next();\n        if (initialValue === undefined && !o.done) {\n            initialValue = o.value;\n            o = this.next();\n        }\n        while (!o.done) {\n            initialValue = f(initialValue, o.value);\n            o = this.next();\n        }\n        return initialValue;\n    }\n    /**\n     * Returns the number of matched items in the sequence\n     */\n    size() {\n        return this.reduce(((acc, _) => ++acc), 0);\n    }\n    [Symbol.iterator]() {\n        /* eslint-disable @typescript-eslint/no-unsafe-return */\n        return this;\n    }\n}\nexports.Iterator = Iterator;\n\n\n/***/ }),\n\n/***/ 4414:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Predicates used for Query and Expression operators.\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$type = exports.$elemMatch = exports.$size = exports.$all = exports.$exists = exports.$regex = exports.$mod = exports.$gte = exports.$gt = exports.$lte = exports.$lt = exports.$nin = exports.$in = exports.$ne = exports.$eq = exports.createExpressionOperator = exports.createQueryOperator = void 0;\nconst core_1 = __webpack_require__(9587);\nconst query_1 = __webpack_require__(809);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a query operator created from the predicate\n *\n * @param predicate Predicate function\n */\nfunction createQueryOperator(predicate) {\n    const f = (selector, value, options) => {\n        const opts = { unwrapArray: true };\n        const depth = Math.max(1, selector.split(\".\").length - 1);\n        return (obj) => {\n            // value of field must be fully resolved.\n            const lhs = (0, util_1.resolve)(obj, selector, opts);\n            return predicate(lhs, value, Object.assign(Object.assign({}, options), { depth }));\n        };\n    };\n    f.op = \"query\";\n    return f; // as QueryOperator;\n}\nexports.createQueryOperator = createQueryOperator;\n/**\n * Returns an expression operator created from the predicate\n *\n * @param predicate Predicate function\n */\nfunction createExpressionOperator(predicate) {\n    return (obj, expr, options) => {\n        const args = (0, core_1.computeValue)(obj, expr, null, options);\n        return predicate(...args);\n    };\n}\nexports.createExpressionOperator = createExpressionOperator;\n/**\n * Checks that two values are equal.\n *\n * @param a         The lhs operand as resolved from the object by the given selector\n * @param b         The rhs operand provided by the user\n * @returns {*}\n */\nfunction $eq(a, b, options) {\n    // start with simple equality check\n    if ((0, util_1.isEqual)(a, b))\n        return true;\n    // https://docs.mongodb.com/manual/tutorial/query-for-null-fields/\n    if ((0, util_1.isNil)(a) && (0, util_1.isNil)(b))\n        return true;\n    // check\n    if (a instanceof Array) {\n        const eq = util_1.isEqual.bind(null, b);\n        return a.some(eq) || (0, util_1.flatten)(a, options === null || options === void 0 ? void 0 : options.depth).some(eq);\n    }\n    return false;\n}\nexports.$eq = $eq;\n/**\n * Matches all values that are not equal to the value specified in the query.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $ne(a, b, options) {\n    return !$eq(a, b, options);\n}\nexports.$ne = $ne;\n/**\n * Matches any of the values that exist in an array specified in the query.\n *\n * @param a\n * @param b\n * @returns {*}\n */\nfunction $in(a, b, options) {\n    // queries for null should be able to find undefined fields\n    if ((0, util_1.isNil)(a))\n        return b.some(v => v === null);\n    return (0, util_1.intersection)([(0, util_1.ensureArray)(a), b], options === null || options === void 0 ? void 0 : options.hashFunction).length > 0;\n}\nexports.$in = $in;\n/**\n * Matches values that do not exist in an array specified to the query.\n *\n * @param a\n * @param b\n * @returns {*|boolean}\n */\nfunction $nin(a, b, options) {\n    return !$in(a, b, options);\n}\nexports.$nin = $nin;\n/**\n * Matches values that are less than the value specified in the query.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $lt(a, b, options) {\n    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) < 0);\n}\nexports.$lt = $lt;\n/**\n * Matches values that are less than or equal to the value specified in the query.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $lte(a, b, options) {\n    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) <= 0);\n}\nexports.$lte = $lte;\n/**\n * Matches values that are greater than the value specified in the query.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $gt(a, b, options) {\n    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) > 0);\n}\nexports.$gt = $gt;\n/**\n * Matches values that are greater than or equal to the value specified in the query.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $gte(a, b, options) {\n    return compare(a, b, (x, y) => (0, util_1.compare)(x, y) >= 0);\n}\nexports.$gte = $gte;\n/**\n * Performs a modulo operation on the value of a field and selects documents with a specified result.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $mod(a, b, options) {\n    return (0, util_1.ensureArray)(a).some(((x) => b.length === 2 && x % b[0] === b[1]));\n}\nexports.$mod = $mod;\n/**\n * Selects documents where values match a specified regular expression.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $regex(a, b, options) {\n    const lhs = (0, util_1.ensureArray)(a);\n    const match = (x) => (0, util_1.isString)(x) && (0, util_1.truthy)(b.exec(x), options === null || options === void 0 ? void 0 : options.useStrictMode);\n    return lhs.some(match) || (0, util_1.flatten)(lhs, 1).some(match);\n}\nexports.$regex = $regex;\n/**\n * Matches documents that have the specified field.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $exists(a, b, options) {\n    return (((b === false || b === 0) && a === undefined) ||\n        ((b === true || b === 1) && a !== undefined));\n}\nexports.$exists = $exists;\n/**\n * Matches arrays that contain all elements specified in the query.\n *\n * @param values\n * @param queries\n * @returns boolean\n */\nfunction $all(values, queries, options) {\n    if (!(0, util_1.isArray)(values) ||\n        !(0, util_1.isArray)(queries) ||\n        !values.length ||\n        !queries.length) {\n        return false;\n    }\n    let matched = true;\n    for (const query of queries) {\n        // no need to check all the queries.\n        if (!matched)\n            break;\n        if ((0, util_1.isObject)(query) && (0, util_1.inArray)(Object.keys(query), \"$elemMatch\")) {\n            matched = $elemMatch(values, query[\"$elemMatch\"], options);\n        }\n        else if (query instanceof RegExp) {\n            matched = values.some(s => typeof s === \"string\" && query.test(s));\n        }\n        else {\n            matched = values.some(v => (0, util_1.isEqual)(query, v));\n        }\n    }\n    return matched;\n}\nexports.$all = $all;\n/**\n * Selects documents if the array field is a specified size.\n *\n * @param a\n * @param b\n * @returns {*|boolean}\n */\nfunction $size(a, b, options) {\n    return Array.isArray(a) && a.length === b;\n}\nexports.$size = $size;\nfunction isNonBooleanOperator(name) {\n    return (0, util_1.isOperator)(name) && [\"$and\", \"$or\", \"$nor\"].indexOf(name) === -1;\n}\n/**\n * Selects documents if element in the array field matches all the specified $elemMatch condition.\n *\n * @param a {Array} element to match against\n * @param b {Object} subquery\n */\nfunction $elemMatch(a, b, options) {\n    // should return false for non-matching input\n    if ((0, util_1.isArray)(a) && !(0, util_1.isEmpty)(a)) {\n        let format = (x) => x;\n        let criteria = b;\n        // If we find a boolean operator in the subquery, we fake a field to point to it. This is an\n        // attempt to ensure that it is a valid criteria. We cannot make this substitution for operators\n        // like $and/$or/$nor; as otherwise, this faking will break our query.\n        if (Object.keys(b).every(isNonBooleanOperator)) {\n            criteria = { temp: b };\n            format = x => ({ temp: x });\n        }\n        const query = new query_1.Query(criteria, options);\n        for (let i = 0, len = a.length; i < len; i++) {\n            if (query.test(format(a[i]))) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\nexports.$elemMatch = $elemMatch;\n// helper functions\nconst isNull = (a) => a === null;\nconst isInt = (a) => (0, util_1.isNumber)(a) &&\n    a >= util_1.MIN_INT &&\n    a <= util_1.MAX_INT &&\n    a.toString().indexOf(\".\") === -1;\nconst isLong = (a) => (0, util_1.isNumber)(a) &&\n    a >= util_1.MIN_LONG &&\n    a <= util_1.MAX_LONG &&\n    a.toString().indexOf(\".\") === -1;\n/** Mapping of type to predicate */\nconst compareFuncs = {\n    array: util_1.isArray,\n    bool: util_1.isBoolean,\n    boolean: util_1.isBoolean,\n    date: util_1.isDate,\n    decimal: util_1.isNumber,\n    double: util_1.isNumber,\n    int: isInt,\n    long: isLong,\n    number: util_1.isNumber,\n    null: isNull,\n    object: util_1.isObject,\n    regex: util_1.isRegExp,\n    regexp: util_1.isRegExp,\n    string: util_1.isString,\n    // added for completeness\n    undefined: util_1.isNil,\n    function: (_) => {\n        throw new Error(\"unsupported type key `function`.\");\n    },\n    // Mongo identifiers\n    1: util_1.isNumber,\n    2: util_1.isString,\n    3: util_1.isObject,\n    4: util_1.isArray,\n    6: util_1.isNil,\n    8: util_1.isBoolean,\n    9: util_1.isDate,\n    10: isNull,\n    11: util_1.isRegExp,\n    16: isInt,\n    18: isLong,\n    19: util_1.isNumber //decimal\n};\n/**\n * Selects documents if a field is of the specified type.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction compareType(a, b, _) {\n    const f = compareFuncs[b];\n    return f ? f(a) : false;\n}\n/**\n * Selects documents if a field is of the specified type.\n *\n * @param a\n * @param b\n * @returns {boolean}\n */\nfunction $type(a, b, options) {\n    return Array.isArray(b)\n        ? b.findIndex(t => compareType(a, t, options)) >= 0\n        : compareType(a, b, options);\n}\nexports.$type = $type;\nfunction compare(a, b, f) {\n    return (0, util_1.ensureArray)(a).some(x => (0, util_1.getType)(x) === (0, util_1.getType)(b) && f(x, b));\n}\n\n\n/***/ }),\n\n/***/ 8680:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.covariance = exports.stddev = void 0;\n/**\n * Compute the standard deviation of the data set\n * @param {Array} array of numbers\n * @param {Boolean} if true calculates a sample standard deviation, otherwise calculates a population stddev\n * @return {Number}\n */\nfunction stddev(data, sampled = true) {\n    const sum = data.reduce((acc, n) => acc + n, 0);\n    const N = data.length || 1;\n    const avg = sum / N;\n    return Math.sqrt(data.reduce((acc, n) => acc + Math.pow(n - avg, 2), 0) /\n        (N - Number(sampled)));\n}\nexports.stddev = stddev;\nfunction covariance(dataset, sampled = true) {\n    if (!dataset)\n        return null;\n    if (dataset.length < 2)\n        return sampled ? null : 0;\n    let meanX = 0.0;\n    let meanY = 0.0;\n    for (const [x, y] of dataset) {\n        meanX += x;\n        meanY += y;\n    }\n    meanX /= dataset.length;\n    meanY /= dataset.length;\n    let result = 0;\n    for (const [x, y] of dataset) {\n        result += (x - meanX) * (y - meanY);\n    }\n    return result / (dataset.length - Number(sampled));\n}\nexports.covariance = covariance;\n\n\n/***/ }),\n\n/***/ 9329:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Custom Aggregation Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#custom-aggregation-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$accumulator = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Defines a custom accumulator function.\n *\n * @param {Array} collection The input array\n * @param {*} expr The expression for the operator\n * @param {Options} options Options\n */\nconst $accumulator = (collection, expr, options) => {\n    var _a;\n    (0, util_1.assert)(!!options && options.scriptEnabled, \"$accumulator operator requires 'scriptEnabled' option to be true\");\n    if (collection.length == 0)\n        return expr.initArgs;\n    const copts = core_1.ComputeOptions.init(options);\n    const initArgs = (0, core_1.computeValue)({}, expr.initArgs || [], null, copts.update(((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId) || {}));\n    let state = expr.init.call(null, ...initArgs);\n    for (const doc of collection) {\n        // get arguments for document\n        const args = (0, core_1.computeValue)(doc, expr.accumulateArgs, null, copts.update(doc));\n        // update the state with each documents value\n        // eslint-disable-next-line\n        state = expr.accumulate.call(null, ...[state, ...args]);\n    }\n    return (expr.finalize ? expr.finalize.call(null, state) : state);\n};\nexports.$accumulator = $accumulator;\n\n\n/***/ }),\n\n/***/ 8911:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$addToSet = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an array of all the unique values for the selected field among for each document in that group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $addToSet = (collection, expr, options) => {\n    return (0, util_1.unique)((0, push_1.$push)(collection, expr, options), options === null || options === void 0 ? void 0 : options.hashFunction);\n};\nexports.$addToSet = $addToSet;\n\n\n/***/ }),\n\n/***/ 9891:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$avg = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an average of all the values in a group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {Number}\n */\nconst $avg = (collection, expr, options) => {\n    const data = (0, push_1.$push)(collection, expr, options).filter(util_1.isNumber);\n    const sum = data.reduce((acc, n) => acc + n, 0);\n    return sum / (data.length || 1);\n};\nexports.$avg = $avg;\n\n\n/***/ }),\n\n/***/ 8474:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bottom = void 0;\nconst bottomN_1 = __webpack_require__(2102);\n/**\n * Returns the bottom element within a group according to the specified sort order.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $bottom = (collection, expr, options) => (0, bottomN_1.$bottomN)(collection, Object.assign(Object.assign({}, expr), { n: 1 }), options);\nexports.$bottom = $bottom;\n\n\n/***/ }),\n\n/***/ 2102:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bottomN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottomN/#mongodb-group-grp.-bottomN\nconst aggregator_1 = __webpack_require__(7268);\nconst core_1 = __webpack_require__(9587);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the bottom n elements within a group, according to the specified sort order.\n * If the group contains fewer than n elements, $bottomN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $bottomN = (collection, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    const { n, sortBy } = (0, core_1.computeValue)(copts.local.groupId, expr, null, copts);\n    const result = new aggregator_1.Aggregator([{ $sort: sortBy }], copts).run(collection);\n    const m = result.length;\n    const p = n;\n    return (0, push_1.$push)(m <= p ? result : result.slice(m - p), expr.output, copts);\n};\nexports.$bottomN = $bottomN;\n\n\n/***/ }),\n\n/***/ 1514:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$count = void 0;\n/**\n * Returns the number of documents in the group or window.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @returns {*}\n */\nconst $count = (collection, _expr, _options) => collection.length;\nexports.$count = $count;\n\n\n/***/ }),\n\n/***/ 7212:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$covariancePop = void 0;\nconst _internal_1 = __webpack_require__(8680);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the population covariance of two numeric expressions.\n * @param  {Array} collection\n * @param  {Object} expr\n * @return {Number|null}\n */\nconst $covariancePop = (collection, expr, options) => (0, _internal_1.covariance)((0, push_1.$push)(collection, expr, options), false);\nexports.$covariancePop = $covariancePop;\n\n\n/***/ }),\n\n/***/ 1662:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$covarianceSamp = void 0;\nconst _internal_1 = __webpack_require__(8680);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the sample covariance of two numeric expressions.\n * @param  {Array} collection\n * @param  {Object} expr\n * @return {Number|null}\n */\nconst $covarianceSamp = (collection, expr, options) => (0, _internal_1.covariance)((0, push_1.$push)(collection, expr, options), true);\nexports.$covarianceSamp = $covarianceSamp;\n\n\n/***/ }),\n\n/***/ 2452:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$first = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Returns the first value in a group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @returns {*}\n */\nconst $first = (collection, expr, options) => {\n    return collection.length > 0\n        ? (0, core_1.computeValue)(collection[0], expr, null, options)\n        : undefined;\n};\nexports.$first = $first;\n\n\n/***/ }),\n\n/***/ 3445:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$firstN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN/\nconst core_1 = __webpack_require__(9587);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the first n elements within a group. The elements returned are meaningful only if in a specified sort order.\n * If the group contains fewer than n elements, $firstN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $firstN = (collection, expr, options) => {\n    var _a;\n    const copts = core_1.ComputeOptions.init(options);\n    const m = collection.length;\n    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);\n    return (0, push_1.$push)(m <= n ? collection : collection.slice(0, n), expr.input, options);\n};\nexports.$firstN = $firstN;\n\n\n/***/ }),\n\n/***/ 3424:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\n/**\n * Group stage Accumulator Operators. https://docs.mongodb.com/manual/reference/operator/aggregation-\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9329), exports);\n__exportStar(__webpack_require__(8911), exports);\n__exportStar(__webpack_require__(9891), exports);\n__exportStar(__webpack_require__(8474), exports);\n__exportStar(__webpack_require__(2102), exports);\n__exportStar(__webpack_require__(1514), exports);\n__exportStar(__webpack_require__(7212), exports);\n__exportStar(__webpack_require__(1662), exports);\n__exportStar(__webpack_require__(2452), exports);\n__exportStar(__webpack_require__(3445), exports);\n__exportStar(__webpack_require__(5026), exports);\n__exportStar(__webpack_require__(9799), exports);\n__exportStar(__webpack_require__(7133), exports);\n__exportStar(__webpack_require__(8542), exports);\n__exportStar(__webpack_require__(4785), exports);\n__exportStar(__webpack_require__(5613), exports);\n__exportStar(__webpack_require__(3946), exports);\n__exportStar(__webpack_require__(7835), exports);\n__exportStar(__webpack_require__(2257), exports);\n__exportStar(__webpack_require__(4393), exports);\n__exportStar(__webpack_require__(7970), exports);\n__exportStar(__webpack_require__(1382), exports);\n__exportStar(__webpack_require__(7097), exports);\n\n\n/***/ }),\n\n/***/ 5026:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$last = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Returns the last value in the collection.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $last = (collection, expr, options) => {\n    return collection.length > 0\n        ? (0, core_1.computeValue)(collection[collection.length - 1], expr, null, options)\n        : undefined;\n};\nexports.$last = $last;\n\n\n/***/ }),\n\n/***/ 9799:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lastN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN/\nconst core_1 = __webpack_require__(9587);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the last n elements within a group. The elements returned are meaningful only if in a specified sort order.\n * If the group contains fewer than n elements, $lastN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $lastN = (collection, expr, options) => {\n    var _a;\n    const copts = core_1.ComputeOptions.init(options);\n    const m = collection.length;\n    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);\n    return (0, push_1.$push)(m <= n ? collection : collection.slice(m - n), expr.input, options);\n};\nexports.$lastN = $lastN;\n\n\n/***/ }),\n\n/***/ 7133:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$max = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the highest value in a group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $max = (collection, expr, options) => {\n    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNotNaN);\n    const n = nums.reduce((acc, n) => ((0, util_1.compare)(n, acc) >= 0 ? n : acc), -Infinity);\n    return n === -Infinity ? undefined : n;\n};\nexports.$max = $max;\n\n\n/***/ }),\n\n/***/ 8542:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$maxN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the maxmimum value n elements within a group.\n * If the group contains fewer than n elements, $maxN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $maxN = (collection, expr, options) => {\n    var _a;\n    const copts = core_1.ComputeOptions.init(options);\n    const m = collection.length;\n    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);\n    const arr = (0, push_1.$push)(collection, expr.input, options).filter(o => !(0, util_1.isNil)(o));\n    arr.sort((a, b) => -1 * (0, util_1.compare)(a, b));\n    return m <= n ? arr : arr.slice(0, n);\n};\nexports.$maxN = $maxN;\n\n\n/***/ }),\n\n/***/ 4785:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$mergeObjects = void 0;\nconst mergeObjects_1 = __webpack_require__(9531);\n/**\n * Combines multiple documents into a single document.\n *\n * @param {Array} collection The input array\n * @param {Object} _ The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {Array|*}\n */\nconst $mergeObjects = (collection, _, options) => (0, mergeObjects_1.$mergeObjects)({ docs: collection }, \"$docs\", options);\nexports.$mergeObjects = $mergeObjects;\n\n\n/***/ }),\n\n/***/ 5613:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$min = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the lowest value in a group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} The options to use for this operator\n * @returns {*}\n */\nconst $min = (collection, expr, options) => {\n    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNotNaN);\n    const n = nums.reduce((acc, n) => ((0, util_1.compare)(n, acc) <= 0 ? n : acc), Infinity);\n    return n === Infinity ? undefined : n;\n};\nexports.$min = $min;\n\n\n/***/ }),\n\n/***/ 3946:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$minN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the minimum value n elements within a group.\n * If the group contains fewer than n elements, $minN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $minN = (collection, expr, options) => {\n    var _a;\n    const copts = core_1.ComputeOptions.init(options);\n    const m = collection.length;\n    const n = (0, core_1.computeValue)((_a = copts === null || copts === void 0 ? void 0 : copts.local) === null || _a === void 0 ? void 0 : _a.groupId, expr.n, null, copts);\n    const arr = (0, push_1.$push)(collection, expr.input, options).filter(o => !(0, util_1.isNil)(o));\n    arr.sort(util_1.compare);\n    return m <= n ? arr : arr.slice(0, n);\n};\nexports.$minN = $minN;\n\n\n/***/ }),\n\n/***/ 7835:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$push = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns an array of all values for the selected field among for each document in that group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {Array|*}\n */\nconst $push = (collection, expr, options) => {\n    if ((0, util_1.isNil)(expr))\n        return collection;\n    const copts = core_1.ComputeOptions.init(options);\n    return collection.map(obj => (0, core_1.computeValue)(obj, expr, null, copts.update(obj)));\n};\nexports.$push = $push;\n\n\n/***/ }),\n\n/***/ 2257:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$stdDevPop = void 0;\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(8680);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the population standard deviation of the input values.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @return {Number}\n */\nconst $stdDevPop = (collection, expr, options) => (0, _internal_1.stddev)((0, push_1.$push)(collection, expr, options).filter(util_1.isNumber), false);\nexports.$stdDevPop = $stdDevPop;\n\n\n/***/ }),\n\n/***/ 4393:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$stdDevSamp = void 0;\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(8680);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the sample standard deviation of the input values.\n * @param  {Array} collection\n * @param  {Object} expr\n * @return {Number|null}\n */\nconst $stdDevSamp = (collection, expr, options) => (0, _internal_1.stddev)((0, push_1.$push)(collection, expr, options).filter(util_1.isNumber), true);\nexports.$stdDevSamp = $stdDevSamp;\n\n\n/***/ }),\n\n/***/ 7970:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sum = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns the sum of all the values in a group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @returns {Number}\n */\nconst $sum = (collection, expr, options) => {\n    if (!(0, util_1.isArray)(collection))\n        return 0;\n    // take a short cut if expr is number literal\n    if ((0, util_1.isNumber)(expr))\n        return collection.length * expr;\n    const nums = (0, push_1.$push)(collection, expr, options).filter(util_1.isNumber);\n    return nums.reduce((acc, n) => acc + n, 0);\n};\nexports.$sum = $sum;\n\n\n/***/ }),\n\n/***/ 1382:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$top = void 0;\nconst topN_1 = __webpack_require__(7097);\n/**\n * Returns the top element within a group according to the specified sort order.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $top = (collection, expr, options) => (0, topN_1.$topN)(collection, Object.assign(Object.assign({}, expr), { n: 1 }), options);\nexports.$top = $top;\n\n\n/***/ }),\n\n/***/ 7097:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$topN = void 0;\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/topN/#mongodb-group-grp.-topN\nconst aggregator_1 = __webpack_require__(7268);\nconst core_1 = __webpack_require__(9587);\nconst push_1 = __webpack_require__(7835);\n/**\n * Returns an aggregation of the top n elements within a group, according to the specified sort order.\n * If the group contains fewer than n elements, $topN returns all elements in the group.\n *\n * @param {Array} collection The input array\n * @param {Object} expr The right-hand side expression value of the operator\n * @param {Options} options The options to use for this operation\n * @returns {*}\n */\nconst $topN = (collection, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    const { n, sortBy } = (0, core_1.computeValue)(copts.local.groupId, expr, null, copts);\n    const result = new aggregator_1.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(collection);\n    return (0, push_1.$push)(result, expr.output, copts);\n};\nexports.$topN = $topN;\n\n\n/***/ }),\n\n/***/ 6026:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.truncate = void 0;\n/**\n * Truncates integer value to number of places. If roundOff is specified round value instead to the number of places\n * @param {Number} num\n * @param {Number} places\n * @param {Boolean} roundOff\n */\nfunction truncate(num, places, roundOff) {\n    const sign = Math.abs(num) === num ? 1 : -1;\n    num = Math.abs(num);\n    let result = Math.trunc(num);\n    const decimals = parseFloat((num - result).toFixed(places + 1));\n    if (places === 0) {\n        const firstDigit = Math.trunc(10 * decimals);\n        if (roundOff &&\n            (((result & 1) === 1 && firstDigit >= 5) || firstDigit > 5)) {\n            result++;\n        }\n    }\n    else if (places > 0) {\n        const offset = Math.pow(10, places);\n        let remainder = Math.trunc(decimals * offset);\n        // last digit before cut off\n        const lastDigit = Math.trunc(decimals * offset * 10) % 10;\n        // add one if last digit is greater than 5\n        if (roundOff && lastDigit > 5) {\n            remainder += 1;\n        }\n        // compute decimal remainder and add to whole number\n        // manually formatting float re\n        result = (result * offset + remainder) / offset;\n    }\n    else if (places < 0) {\n        // handle negative decimal places\n        const offset = Math.pow(10, -1 * places);\n        let excess = result % offset;\n        result = Math.max(0, result - excess);\n        // for negative values the absolute must increase so we round up the last digit if >= 5\n        if (roundOff && sign === -1) {\n            while (excess > 10) {\n                excess -= excess % 10;\n            }\n            if (result > 0 && excess >= 5) {\n                result += offset;\n            }\n        }\n    }\n    return result * sign;\n}\nexports.truncate = truncate;\n\n\n/***/ }),\n\n/***/ 2062:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$abs = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the absolute value of a number.\n *\n * @param obj\n * @param expr\n * @return {Number|null|NaN}\n */\nconst $abs = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.isNil)(n) ? null : Math.abs(n);\n};\nexports.$abs = $abs;\n\n\n/***/ }),\n\n/***/ 7254:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$add = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Computes the sum of an array of numbers.\n *\n * @param obj\n * @param expr\n * @returns {Object}\n */\nconst $add = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    let foundDate = false;\n    const result = args.reduce((acc, val) => {\n        if ((0, util_1.isDate)(val)) {\n            (0, util_1.assert)(!foundDate, \"'$add' can only have one date value\");\n            foundDate = true;\n            val = val.getTime();\n        }\n        // assume val is a number\n        acc += val;\n        return acc;\n    }, 0);\n    return foundDate ? new Date(result) : result;\n};\nexports.$add = $add;\n\n\n/***/ }),\n\n/***/ 4489:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ceil = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the smallest integer greater than or equal to the specified number.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $ceil = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), \"$ceil expression must resolve to a number.\");\n    return Math.ceil(n);\n};\nexports.$ceil = $ceil;\n\n\n/***/ }),\n\n/***/ 4203:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$divide = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Takes two numbers and divides the first number by the second.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $divide = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args[0] / args[1];\n};\nexports.$divide = $divide;\n\n\n/***/ }),\n\n/***/ 8216:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$exp = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Raises Euler’s number (i.e. e ) to the specified exponent and returns the result.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $exp = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), \"$exp expression must resolve to a number.\");\n    return Math.exp(n);\n};\nexports.$exp = $exp;\n\n\n/***/ }),\n\n/***/ 7827:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$floor = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the largest integer less than or equal to the specified number.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $floor = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), \"$floor expression must resolve to a number.\");\n    return Math.floor(n);\n};\nexports.$floor = $floor;\n\n\n/***/ }),\n\n/***/ 1744:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(2062), exports);\n__exportStar(__webpack_require__(7254), exports);\n__exportStar(__webpack_require__(4489), exports);\n__exportStar(__webpack_require__(4203), exports);\n__exportStar(__webpack_require__(8216), exports);\n__exportStar(__webpack_require__(7827), exports);\n__exportStar(__webpack_require__(1424), exports);\n__exportStar(__webpack_require__(368), exports);\n__exportStar(__webpack_require__(7654), exports);\n__exportStar(__webpack_require__(5971), exports);\n__exportStar(__webpack_require__(4325), exports);\n__exportStar(__webpack_require__(8519), exports);\n__exportStar(__webpack_require__(2151), exports);\n__exportStar(__webpack_require__(7625), exports);\n__exportStar(__webpack_require__(7709), exports);\n__exportStar(__webpack_require__(8736), exports);\n\n\n/***/ }),\n\n/***/ 1424:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ln = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Calculates the natural logarithm ln (i.e loge) of a number and returns the result as a double.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $ln = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), \"$ln expression must resolve to a number.\");\n    return Math.log(n);\n};\nexports.$ln = $ln;\n\n\n/***/ }),\n\n/***/ 368:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$log = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Calculates the log of a number in the specified base and returns the result as a double.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $log = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const msg = \"$log expression must resolve to array(2) of numbers\";\n    (0, util_1.assert)((0, util_1.isArray)(args) && args.length === 2, msg);\n    if (args.some(util_1.isNil))\n        return null;\n    (0, util_1.assert)(args.some(isNaN) || args.every(util_1.isNumber), msg);\n    return Math.log10(args[0]) / Math.log10(args[1]);\n};\nexports.$log = $log;\n\n\n/***/ }),\n\n/***/ 7654:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$log10 = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Calculates the log base 10 of a number and returns the result as a double.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $log10 = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)((0, util_1.isNumber)(n) || isNaN(n), \"$log10 expression must resolve to a number.\");\n    return Math.log10(n);\n};\nexports.$log10 = $log10;\n\n\n/***/ }),\n\n/***/ 5971:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$mod = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Takes two numbers and calculates the modulo of the first number divided by the second.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $mod = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args[0] % args[1];\n};\nexports.$mod = $mod;\n\n\n/***/ }),\n\n/***/ 4325:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$multiply = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Computes the product of an array of numbers.\n *\n * @param obj\n * @param expr\n * @returns {Object}\n */\nconst $multiply = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args.reduce((acc, num) => acc * num, 1);\n};\nexports.$multiply = $multiply;\n\n\n/***/ }),\n\n/***/ 8519:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$pow = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Raises a number to the specified exponent and returns the result.\n *\n * @param obj\n * @param expr\n * @returns {Object}\n */\nconst $pow = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(args) && args.length === 2 && args.every(util_1.isNumber), \"$pow expression must resolve to array(2) of numbers\");\n    (0, util_1.assert)(!(args[0] === 0 && args[1] < 0), \"$pow cannot raise 0 to a negative exponent\");\n    return Math.pow(args[0], args[1]);\n};\nexports.$pow = $pow;\n\n\n/***/ }),\n\n/***/ 2151:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$round = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(6026);\n/**\n * Rounds a number to to a whole integer or to a specified decimal place.\n * @param {*} obj\n * @param {*} expr\n */\nconst $round = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const num = args[0];\n    const place = args[1];\n    if ((0, util_1.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)\n        return num;\n    (0, util_1.assert)((0, util_1.isNumber)(num), \"$round expression must resolve to a number.\");\n    return (0, _internal_1.truncate)(num, place, true);\n};\nexports.$round = $round;\n\n\n/***/ }),\n\n/***/ 7625:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sqrt = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Calculates the square root of a positive number and returns the result as a double.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $sqrt = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(n))\n        return null;\n    (0, util_1.assert)(((0, util_1.isNumber)(n) && n > 0) || isNaN(n), \"$sqrt expression must resolve to non-negative number.\");\n    return Math.sqrt(n);\n};\nexports.$sqrt = $sqrt;\n\n\n/***/ }),\n\n/***/ 7709:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$subtract = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Takes an array that contains two numbers or two dates and subtracts the second value from the first.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $subtract = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args[0] - args[1];\n};\nexports.$subtract = $subtract;\n\n\n/***/ }),\n\n/***/ 8736:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Arithmetic Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#arithmetic-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$trunc = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(6026);\n/**\n * Truncates a number to a whole integer or to a specified decimal place.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $trunc = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    const num = arr[0];\n    const places = arr[1];\n    if ((0, util_1.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity)\n        return num;\n    (0, util_1.assert)((0, util_1.isNumber)(num), \"$trunc expression must resolve to a number.\");\n    (0, util_1.assert)((0, util_1.isNil)(places) || ((0, util_1.isNumber)(places) && places > -20 && places < 100), \"$trunc expression has invalid place\");\n    return (0, _internal_1.truncate)(num, places, false);\n};\nexports.$trunc = $trunc;\n\n\n/***/ }),\n\n/***/ 5614:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$arrayElemAt = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the element at the specified array index.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $arrayElemAt = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)(args instanceof Array && args.length === 2, \"$arrayElemAt expression must resolve to array(2)\");\n    if (args.some(util_1.isNil))\n        return null;\n    const index = args[1];\n    const arr = args[0];\n    if (index < 0 && Math.abs(index) <= arr.length) {\n        return arr[(index + arr.length) % arr.length];\n    }\n    else if (index >= 0 && index < arr.length) {\n        return arr[index];\n    }\n    return undefined;\n};\nexports.$arrayElemAt = $arrayElemAt;\n\n\n/***/ }),\n\n/***/ 608:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$arrayToObject = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Converts an array of key value pairs to a document.\n */\nconst $arrayToObject = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"$arrayToObject expression must resolve to an array\");\n    return arr.reduce((newObj, val) => {\n        // flatten\n        while ((0, util_1.isArray)(val) && val.length === 1)\n            val = val[0];\n        if (val instanceof Array && val.length == 2) {\n            newObj[val[0]] = val[1];\n        }\n        else {\n            const valObj = val;\n            (0, util_1.assert)((0, util_1.isObject)(valObj) && (0, util_1.has)(valObj, \"k\") && (0, util_1.has)(valObj, \"v\"), \"$arrayToObject expression is invalid.\");\n            newObj[valObj.k] = valObj.v;\n        }\n        return newObj;\n    }, {});\n};\nexports.$arrayToObject = $arrayToObject;\n\n\n/***/ }),\n\n/***/ 5579:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$concatArrays = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Concatenates arrays to return the concatenated array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $concatArrays = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"$concatArrays must resolve to an array\");\n    if (arr.some(util_1.isNil))\n        return null;\n    return arr.reduce((acc, item) => (0, util_1.into)(acc, item), []);\n};\nexports.$concatArrays = $concatArrays;\n\n\n/***/ }),\n\n/***/ 2903:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$filter = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Selects a subset of the array to return an array with only the elements that match the filter condition.\n *\n * @param  {Object} obj The current document\n * @param  {*} expr The filter spec\n * @return {*}\n */\nconst $filter = (obj, expr, options) => {\n    const input = (0, core_1.computeValue)(obj, expr.input, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(input), \"$filter 'input' expression must resolve to an array\");\n    const copts = core_1.ComputeOptions.init(options, obj);\n    const k = expr.as || \"this\";\n    const local = {\n        variables: { [k]: null }\n    };\n    return input.filter((o) => {\n        local.variables[k] = o;\n        const b = (0, core_1.computeValue)(obj, expr.cond, null, copts.update(copts.root, local));\n        // allow empty strings only in strict MongoDB mode (default).\n        return (0, util_1.truthy)(b, options.useStrictMode);\n    });\n};\nexports.$filter = $filter;\n\n\n/***/ }),\n\n/***/ 9975:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$first = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst accumulator_1 = __webpack_require__(3424);\n/**\n * Returns the first element in an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $first = (obj, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    if (obj instanceof Array)\n        return (0, accumulator_1.$first)(obj, expr, copts.update());\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(arr))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"Must resolve to an array/null or missing\");\n    return (0, accumulator_1.$first)(arr, \"$$this\", options);\n};\nexports.$first = $first;\n\n\n/***/ }),\n\n/***/ 3425:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN-array-element/#mongodb-expression-exp.-firstN\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$firstN = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst firstN_1 = __webpack_require__(3445);\n/**\n * Returns a specified number of elements from the beginning of an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $firstN = (obj, expr, options) => {\n    // first try the accumulator if input is an array.\n    if (obj instanceof Array)\n        return (0, firstN_1.$firstN)(obj, expr, options);\n    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"Must resolve to an array/null or missing\");\n    return (0, firstN_1.$firstN)(input, { n, input: \"$$this\" }, options);\n};\nexports.$firstN = $firstN;\n\n\n/***/ }),\n\n/***/ 7485:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$in = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a boolean indicating whether a specified value is in an array.\n *\n * @param {Object} obj\n * @param {Array} expr\n */\nconst $in = (obj, expr, options) => {\n    const [item, arr] = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"$in second argument must be an array\");\n    return arr.some(util_1.isEqual.bind(null, item));\n};\nexports.$in = $in;\n\n\n/***/ }),\n\n/***/ 1613:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(5614), exports);\n__exportStar(__webpack_require__(608), exports);\n__exportStar(__webpack_require__(5579), exports);\n__exportStar(__webpack_require__(2903), exports);\n__exportStar(__webpack_require__(9975), exports);\n__exportStar(__webpack_require__(3425), exports);\n__exportStar(__webpack_require__(7485), exports);\n__exportStar(__webpack_require__(2686), exports);\n__exportStar(__webpack_require__(5499), exports);\n__exportStar(__webpack_require__(1410), exports);\n__exportStar(__webpack_require__(3927), exports);\n__exportStar(__webpack_require__(1965), exports);\n__exportStar(__webpack_require__(8245), exports);\n__exportStar(__webpack_require__(3051), exports);\n__exportStar(__webpack_require__(893), exports);\n__exportStar(__webpack_require__(9633), exports);\n__exportStar(__webpack_require__(2641), exports);\n__exportStar(__webpack_require__(1951), exports);\n__exportStar(__webpack_require__(5052), exports);\n__exportStar(__webpack_require__(5000), exports);\n__exportStar(__webpack_require__(5450), exports);\n__exportStar(__webpack_require__(7393), exports);\n\n\n/***/ }),\n\n/***/ 2686:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$indexOfArray = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Searches an array for an occurrence of a specified value and returns the array index of the first occurrence.\n * If the substring is not found, returns -1.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $indexOfArray = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(args))\n        return null;\n    let arr = args[0];\n    const searchValue = args[1];\n    if ((0, util_1.isNil)(arr))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"$indexOfArray expression must resolve to an array.\");\n    const start = args[2] || 0;\n    let end = args[3];\n    if ((0, util_1.isNil)(end))\n        end = arr.length;\n    if (start > end)\n        return -1;\n    (0, util_1.assert)(start >= 0 && end >= 0, \"$indexOfArray expression is invalid\");\n    if (start > 0 || end < arr.length) {\n        arr = arr.slice(start, end);\n    }\n    // Array.prototype.findIndex not supported in IE9 hence this workaround\n    let index = -1;\n    arr.some((v, i) => {\n        const b = (0, util_1.isEqual)(v, searchValue);\n        if (b)\n            index = i;\n        return b;\n    });\n    return index + start;\n};\nexports.$indexOfArray = $indexOfArray;\n\n\n/***/ }),\n\n/***/ 5499:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$isArray = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Determines if the operand is an array. Returns a boolean.\n *\n * @param  {Object}  obj\n * @param  {*}  expr\n * @return {Boolean}\n */\nconst $isArray = (obj, expr, options) => {\n    return (0, core_1.computeValue)(obj, expr[0], null, options) instanceof Array;\n};\nexports.$isArray = $isArray;\n\n\n/***/ }),\n\n/***/ 1410:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$last = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst accumulator_1 = __webpack_require__(3424);\n/**\n * Returns the last element in an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $last = (obj, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    if (obj instanceof Array)\n        return (0, accumulator_1.$last)(obj, expr, copts.update());\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(arr))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"Must resolve to an array/null or missing\");\n    return (0, accumulator_1.$last)(arr, \"$$this\", options);\n};\nexports.$last = $last;\n\n\n/***/ }),\n\n/***/ 3927:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN-array-element/#mongodb-expression-exp.-lastN\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lastN = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst lastN_1 = __webpack_require__(9799);\n/**\n * Returns a specified number of elements from the end of an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $lastN = (obj, expr, options) => {\n    // first try the accumulator if input is an array.\n    if (obj instanceof Array)\n        return (0, lastN_1.$lastN)(obj, expr, options);\n    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"Must resolve to an array/null or missing\");\n    return (0, lastN_1.$lastN)(input, { n, input: \"$$this\" }, options);\n};\nexports.$lastN = $lastN;\n\n\n/***/ }),\n\n/***/ 1965:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$map = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Applies a sub-expression to each element of an array and returns the array of resulting values in order.\n *\n * @param obj\n * @param expr\n * @returns {Array|*}\n */\nconst $map = (obj, expr, options) => {\n    const input = (0, core_1.computeValue)(obj, expr.input, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(input), `$map 'input' expression must resolve to an array`);\n    const copts = core_1.ComputeOptions.init(options);\n    const k = expr.as || \"this\";\n    return input.map((o) => {\n        return (0, core_1.computeValue)(obj, expr.in, null, copts.update(copts.root, {\n            variables: { [k]: o }\n        }));\n    });\n};\nexports.$map = $map;\n\n\n/***/ }),\n\n/***/ 8245:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN-array-element/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$maxN = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst maxN_1 = __webpack_require__(8542);\n/**\n * Returns the n largest values in an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $maxN = (obj, expr, options) => {\n    // first try the accumulator if input is an array.\n    if (obj instanceof Array)\n        return (0, maxN_1.$maxN)(obj, expr, options);\n    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"Must resolve to an array/null or missing\");\n    return (0, maxN_1.$maxN)(input, { n, input: \"$$this\" }, options);\n};\nexports.$maxN = $maxN;\n\n\n/***/ }),\n\n/***/ 3051:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN-array-element/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$minN = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst minN_1 = __webpack_require__(3946);\n/**\n * Returns the n smallest values in an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $minN = (obj, expr, options) => {\n    // first try the accumulator if input is an array.\n    if (obj instanceof Array)\n        return (0, minN_1.$minN)(obj, expr, options);\n    const { input, n } = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"Must resolve to an array/null or missing\");\n    return (0, minN_1.$minN)(input, { n, input: \"$$this\" }, options);\n};\nexports.$minN = $minN;\n\n\n/***/ }),\n\n/***/ 893:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$nin = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Returns a boolean indicating whether a specified value is not an array.\n * Note: This expression operator is missing from the documentation\n *\n * @param {Object} obj\n * @param {Array} expr\n */\nexports.$nin = (0, _predicates_1.createExpressionOperator)(_predicates_1.$nin);\n\n\n/***/ }),\n\n/***/ 9633:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$range = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Returns an array whose elements are a generated sequence of numbers.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $range = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    const start = arr[0];\n    const end = arr[1];\n    const step = arr[2] || 1;\n    const result = new Array();\n    let counter = start;\n    while ((counter < end && step > 0) || (counter > end && step < 0)) {\n        result.push(counter);\n        counter += step;\n    }\n    return result;\n};\nexports.$range = $range;\n\n\n/***/ }),\n\n/***/ 2641:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$reduce = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Applies an expression to each element in an array and combines them into a single value.\n *\n * @param {Object} obj\n * @param {*} expr\n */\nconst $reduce = (obj, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    const input = (0, core_1.computeValue)(obj, expr.input, null, copts);\n    const initialValue = (0, core_1.computeValue)(obj, expr.initialValue, null, copts);\n    const inExpr = expr[\"in\"];\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"$reduce 'input' expression must resolve to an array\");\n    return input.reduce((acc, n) => {\n        return (0, core_1.computeValue)(n, inExpr, null, copts.update(copts.root, {\n            variables: { value: acc }\n        }));\n    }, initialValue);\n};\nexports.$reduce = $reduce;\n\n\n/***/ }),\n\n/***/ 1951:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$reverseArray = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns an array with the elements in reverse order.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $reverseArray = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(arr))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(arr), \"$reverseArray expression must resolve to an array\");\n    const result = arr.slice(0);\n    result.reverse();\n    return result;\n};\nexports.$reverseArray = $reverseArray;\n\n\n/***/ }),\n\n/***/ 5052:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$size = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Counts and returns the total the number of items in an array.\n *\n * @param obj\n * @param expr\n */\nconst $size = (obj, expr, options) => {\n    const value = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.isArray)(value) ? value.length : undefined;\n};\nexports.$size = $size;\n\n\n/***/ }),\n\n/***/ 5000:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$slice = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a subset of an array.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $slice = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const arr = args[0];\n    let skip = args[1];\n    let limit = args[2];\n    // MongoDB $slice works a bit differently from Array.slice\n    // Uses single argument for 'limit' and array argument [skip, limit]\n    if ((0, util_1.isNil)(limit)) {\n        if (skip < 0) {\n            skip = Math.max(0, arr.length + skip);\n            limit = arr.length - skip + 1;\n        }\n        else {\n            limit = skip;\n            skip = 0;\n        }\n    }\n    else {\n        if (skip < 0) {\n            skip = Math.max(0, arr.length + skip);\n        }\n        (0, util_1.assert)(limit > 0, `Invalid argument for $slice operator. Limit must be a positive number`);\n        limit += skip;\n    }\n    return arr.slice(skip, limit);\n};\nexports.$slice = $slice;\n\n\n/***/ }),\n\n/***/ 5450:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// https://www.mongodb.com/docs/manual/reference/operator/aggregation/sortArray/#mongodb-expression-exp.-sortArray\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sortArray = void 0;\nconst aggregator_1 = __webpack_require__(7268);\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Sorts an array based on its elements. The sort order is user specified.\n *\n * @param obj The target object\n * @param expr The expression argument\n * @param options Options\n * @returns\n */\nconst $sortArray = (obj, expr, options) => {\n    const { input, sortBy } = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isArray)(input), \"$sortArray expression must resolve to an array\");\n    if ((0, util_1.isObject)(sortBy)) {\n        return new aggregator_1.Aggregator([{ $sort: sortBy }]).run(input);\n    }\n    const result = [...input];\n    result.sort(util_1.compare);\n    if (sortBy === -1)\n        result.reverse();\n    return result;\n};\nexports.$sortArray = $sortArray;\n\n\n/***/ }),\n\n/***/ 7393:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Array Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#array-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$zip = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Merge two lists together.\n *\n * Transposes an array of input arrays so that the first element of the output array would be an array containing,\n * the first element of the first input array, the first element of the second input array, etc.\n *\n * @param  {Obj} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $zip = (obj, expr, options) => {\n    const inputs = (0, core_1.computeValue)(obj, expr.inputs, null, options);\n    const useLongestLength = expr.useLongestLength || false;\n    (0, util_1.assert)((0, util_1.isArray)(inputs), \"'inputs' expression must resolve to an array\");\n    (0, util_1.assert)((0, util_1.isBoolean)(useLongestLength), \"'useLongestLength' must be a boolean\");\n    if ((0, util_1.isArray)(expr.defaults)) {\n        (0, util_1.assert)(useLongestLength, \"'useLongestLength' must be set to true to use 'defaults'\");\n    }\n    let zipCount = 0;\n    for (let i = 0, len = inputs.length; i < len; i++) {\n        const arr = inputs[i];\n        if ((0, util_1.isNil)(arr))\n            return null;\n        (0, util_1.assert)((0, util_1.isArray)(arr), \"'inputs' expression values must resolve to an array or null\");\n        zipCount = useLongestLength\n            ? Math.max(zipCount, arr.length)\n            : Math.min(zipCount || arr.length, arr.length);\n    }\n    const result = [];\n    const defaults = expr.defaults || [];\n    for (let i = 0; i < zipCount; i++) {\n        const temp = inputs.map((val, index) => {\n            return (0, util_1.isNil)(val[i]) ? defaults[index] || null : val[i];\n        });\n        result.push(temp);\n    }\n    return result;\n};\nexports.$zip = $zip;\n\n\n/***/ }),\n\n/***/ 6635:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$and = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true only when all its expressions evaluate to true. Accepts any number of argument expressions.\n *\n * @param obj\n * @param expr\n * @returns {boolean}\n */\nconst $and = (obj, expr, options) => {\n    const value = (0, core_1.computeValue)(obj, expr, null, options);\n    return ((0, util_1.truthy)(value, options.useStrictMode) &&\n        value.every(v => (0, util_1.truthy)(v, options.useStrictMode)));\n};\nexports.$and = $and;\n\n\n/***/ }),\n\n/***/ 628:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(6635), exports);\n__exportStar(__webpack_require__(2560), exports);\n__exportStar(__webpack_require__(497), exports);\n\n\n/***/ }),\n\n/***/ 2560:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$not = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the boolean value that is the opposite of its argument expression. Accepts a single argument expression.\n *\n * @param obj RawObject from collection\n * @param expr Right hand side expression of operator\n * @returns {boolean}\n */\nconst $not = (obj, expr, options) => {\n    const booleanExpr = (0, util_1.ensureArray)(expr);\n    // array values are truthy so an emty array is false\n    if (booleanExpr.length == 0)\n        return false;\n    // use provided value non-array value\n    if (booleanExpr.length == 1)\n        return !(0, core_1.computeValue)(obj, booleanExpr[0], null, options);\n    // expects a single argument\n    throw \"Expression $not takes exactly 1 argument\";\n};\nexports.$not = $not;\n\n\n/***/ }),\n\n/***/ 497:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Boolean Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#boolean-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$or = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true when any of its expressions evaluates to true. Accepts any number of argument expressions.\n *\n * @param obj\n * @param expr\n * @returns {boolean}\n */\nconst $or = (obj, expr, options) => {\n    const value = (0, core_1.computeValue)(obj, expr, null, options);\n    const strict = options.useStrictMode;\n    return (0, util_1.truthy)(value, strict) && value.some(v => (0, util_1.truthy)(v, strict));\n};\nexports.$or = $or;\n\n\n/***/ }),\n\n/***/ 9543:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$cmp = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Compares two values and returns the result of the comparison as an integer.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $cmp = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    if (args[0] > args[1])\n        return 1;\n    if (args[0] < args[1])\n        return -1;\n    return 0;\n};\nexports.$cmp = $cmp;\n\n\n/***/ }),\n\n/***/ 5495:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$eq = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are equal to a specified value.\n */\nexports.$eq = (0, _predicates_1.createExpressionOperator)(_predicates_1.$eq);\n\n\n/***/ }),\n\n/***/ 2005:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$gt = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are greater than a specified value.\n */\nexports.$gt = (0, _predicates_1.createExpressionOperator)(_predicates_1.$gt);\n\n\n/***/ }),\n\n/***/ 9070:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$gte = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * \tMatches values that are greater than or equal to a specified value.\n */\nexports.$gte = (0, _predicates_1.createExpressionOperator)(_predicates_1.$gte);\n\n\n/***/ }),\n\n/***/ 4591:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9543), exports);\n__exportStar(__webpack_require__(5495), exports);\n__exportStar(__webpack_require__(2005), exports);\n__exportStar(__webpack_require__(9070), exports);\n__exportStar(__webpack_require__(1337), exports);\n__exportStar(__webpack_require__(3701), exports);\n__exportStar(__webpack_require__(4267), exports);\n\n\n/***/ }),\n\n/***/ 1337:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lt = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are less than the value specified in the query.\n */\nexports.$lt = (0, _predicates_1.createExpressionOperator)(_predicates_1.$lt);\n\n\n/***/ }),\n\n/***/ 3701:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lte = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are less than or equal to the value specified in the query.\n */\nexports.$lte = (0, _predicates_1.createExpressionOperator)(_predicates_1.$lte);\n\n\n/***/ }),\n\n/***/ 4267:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Comparison Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#comparison-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ne = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches all values that are not equal to the value specified in the query.\n */\nexports.$ne = (0, _predicates_1.createExpressionOperator)(_predicates_1.$ne);\n\n\n/***/ }),\n\n/***/ 3833:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$cond = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * A ternary operator that evaluates one expression,\n * and depending on the result returns the value of one following expressions.\n *\n * @param obj\n * @param expr\n */\nconst $cond = (obj, expr, options) => {\n    let ifExpr;\n    let thenExpr;\n    let elseExpr;\n    const errorMsg = \"$cond: invalid arguments\";\n    if (expr instanceof Array) {\n        (0, util_1.assert)(expr.length === 3, errorMsg);\n        ifExpr = expr[0];\n        thenExpr = expr[1];\n        elseExpr = expr[2];\n    }\n    else {\n        (0, util_1.assert)((0, util_1.isObject)(expr), errorMsg);\n        ifExpr = expr.if;\n        thenExpr = expr.then;\n        elseExpr = expr.else;\n    }\n    const condition = (0, util_1.truthy)((0, core_1.computeValue)(obj, ifExpr, null, options), options.useStrictMode);\n    return (0, core_1.computeValue)(obj, condition ? thenExpr : elseExpr, null, options);\n};\nexports.$cond = $cond;\n\n\n/***/ }),\n\n/***/ 419:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ifNull = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Evaluates an expression and returns the first non-null value.\n *\n * @param obj\n * @param expr\n * @returns {*}\n */\nconst $ifNull = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args.find(arg => !(0, util_1.isNil)(arg));\n};\nexports.$ifNull = $ifNull;\n\n\n/***/ }),\n\n/***/ 5112:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(3833), exports);\n__exportStar(__webpack_require__(419), exports);\n__exportStar(__webpack_require__(9605), exports);\n\n\n/***/ }),\n\n/***/ 9605:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Conditional Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#conditional-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$switch = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * An operator that evaluates a series of case expressions. When it finds an expression which\n * evaluates to true, it returns the resulting expression for that case. If none of the cases\n * evaluate to true, it returns the default expression.\n *\n * @param obj\n * @param expr\n */\nconst $switch = (obj, expr, options) => {\n    let thenExpr = null;\n    // Array.prototype.find not supported in IE, hence the '.some()' proxy\n    expr.branches.some((b) => {\n        const condition = (0, util_1.truthy)((0, core_1.computeValue)(obj, b.case, null, options), options.useStrictMode);\n        if (condition)\n            thenExpr = b.then;\n        return condition;\n    });\n    return (0, core_1.computeValue)(obj, thenExpr !== null ? thenExpr : expr.default, null, options);\n};\nexports.$switch = $switch;\n\n\n/***/ }),\n\n/***/ 1416:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Custom Aggregation Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#custom-aggregation-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$function = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Defines a custom function.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The expression for the operator\n * @param {Options} options Options\n */\nconst $function = (obj, expr, options) => {\n    (0, util_1.assert)(options.scriptEnabled, \"$function operator requires 'scriptEnabled' option to be true\");\n    const fn = (0, core_1.computeValue)(obj, expr, null, options);\n    return fn.body.apply(null, fn.args);\n};\nexports.$function = $function;\n\n\n/***/ }),\n\n/***/ 4052:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(1416), exports);\n\n\n/***/ }),\n\n/***/ 7974:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.regexStrip = exports.regexQuote = exports.padDigits = exports.computeDate = exports.adjustDate = exports.formatTimezone = exports.parseTimezone = exports.DATE_SYM_TABLE = exports.DATE_PART_INTERVAL = exports.DATE_FORMAT = exports.DURATION_IN_MILLIS = exports.MILLIS_PER_DAY = exports.MINUTES_PER_HOUR = exports.isoWeekYear = exports.isoWeek = exports.getDayOfYear = exports.isLeapYear = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst COMMON_YEAR_DAYS_OFFSET = [\n    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334\n];\nconst LEAP_YEAR_DAYS_OFFSET = [\n    0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335\n];\n// https://en.wikipedia.org/wiki/ISO_week_date\nconst p = (y) => (y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400)) % 7;\nconst weeks = (y) => 52 + Number(p(y) == 4 || p(y - 1) == 3);\nconst isLeapYear = (year) => (year & 3) == 0 && (year % 100 != 0 || year % 400 == 0);\nexports.isLeapYear = isLeapYear;\nconst getDayOfYear = (d) => ((0, exports.isLeapYear)(d.getUTCFullYear())\n    ? LEAP_YEAR_DAYS_OFFSET\n    : COMMON_YEAR_DAYS_OFFSET)[d.getUTCMonth()] + d.getUTCDate();\nexports.getDayOfYear = getDayOfYear;\nfunction isoWeek(d) {\n    // algorithm based on https://en.wikipedia.org/wiki/ISO_week_date\n    const w = Math.floor((10 + (0, exports.getDayOfYear)(d) - (d.getUTCDay() || 7)) / 7);\n    if (w < 1)\n        return weeks(d.getUTCFullYear() - 1);\n    if (w > weeks(d.getUTCFullYear()))\n        return 1;\n    return w;\n}\nexports.isoWeek = isoWeek;\nfunction isoWeekYear(d) {\n    return (d.getUTCFullYear() -\n        Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1));\n}\nexports.isoWeekYear = isoWeekYear;\nexports.MINUTES_PER_HOUR = 60;\nexports.MILLIS_PER_DAY = 1000 * 60 * 60 * 24;\nexports.DURATION_IN_MILLIS = {\n    week: exports.MILLIS_PER_DAY * 7,\n    day: exports.MILLIS_PER_DAY,\n    hour: 1000 * 60 * 60,\n    minute: 1000 * 60,\n    second: 1000,\n    millisecond: 1\n};\n// default format if unspecified\nexports.DATE_FORMAT = \"%Y-%m-%dT%H:%M:%S.%LZ\";\n// Inclusive interval of date parts\nexports.DATE_PART_INTERVAL = [\n    [\"year\", 0, 9999],\n    [\"month\", 1, 12],\n    [\"day\", 1, 31],\n    [\"hour\", 0, 23],\n    [\"minute\", 0, 59],\n    [\"second\", 0, 59],\n    [\"millisecond\", 0, 999]\n];\n// used for formatting dates in $dateToString operator\nexports.DATE_SYM_TABLE = {\n    \"%Y\": { name: \"year\", padding: 4, re: /([0-9]{4})/ },\n    \"%G\": { name: \"year\", padding: 4, re: /([0-9]{4})/ },\n    \"%m\": { name: \"month\", padding: 2, re: /(0[1-9]|1[012])/ },\n    \"%d\": { name: \"day\", padding: 2, re: /(0[1-9]|[12][0-9]|3[01])/ },\n    \"%H\": { name: \"hour\", padding: 2, re: /([01][0-9]|2[0-3])/ },\n    \"%M\": { name: \"minute\", padding: 2, re: /([0-5][0-9])/ },\n    \"%S\": { name: \"second\", padding: 2, re: /([0-5][0-9]|60)/ },\n    \"%L\": { name: \"millisecond\", padding: 3, re: /([0-9]{3})/ },\n    \"%u\": { name: \"weekday\", padding: 1, re: /([1-7])/ },\n    \"%U\": { name: \"week\", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },\n    \"%V\": { name: \"isoWeek\", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },\n    \"%z\": {\n        name: \"timezone\",\n        padding: 2,\n        re: /(([+-][01][0-9]|2[0-3]):?([0-5][0-9])?)/\n    },\n    \"%Z\": { name: \"minuteOffset\", padding: 3, re: /([+-][0-9]{3})/ }\n    // \"%%\": \"%\",\n};\n/**\n * Parse and return the timezone string as a number\n * @param tzstr Timezone string matching '+/-hh[:][mm]'\n */\nfunction parseTimezone(tzstr) {\n    if ((0, util_1.isNil)(tzstr))\n        return 0;\n    const m = exports.DATE_SYM_TABLE[\"%z\"].re.exec(tzstr);\n    if (!m)\n        throw Error(`invalid or location-based timezone '${tzstr}' not supported`);\n    const hr = parseInt(m[2]) || 0;\n    const min = parseInt(m[3]) || 0;\n    return (Math.abs(hr * exports.MINUTES_PER_HOUR) + min) * (hr < 0 ? -1 : 1);\n}\nexports.parseTimezone = parseTimezone;\n/**\n * Formats the timezone for output\n * @param tz A timezone object\n */\nfunction formatTimezone(minuteOffset) {\n    return ((minuteOffset < 0 ? \"-\" : \"+\") +\n        padDigits(Math.abs(Math.floor(minuteOffset / exports.MINUTES_PER_HOUR)), 2) +\n        padDigits(Math.abs(minuteOffset) % exports.MINUTES_PER_HOUR, 2));\n}\nexports.formatTimezone = formatTimezone;\n/**\n * Adjust the date by the given timezone\n * @param d Date object\n * @param minuteOffset number\n */\nfunction adjustDate(d, minuteOffset) {\n    d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);\n}\nexports.adjustDate = adjustDate;\n/**\n * Computes a date expression\n * @param obj The target object\n * @param expr Any value that resolves to a valid date expression. Valid expressions include a number, Date, or Object{date: number|Date, timezone?: string}\n */\nfunction computeDate(obj, expr, options) {\n    const d = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isDate)(d))\n        return new Date(d);\n    // timestamp is in seconds\n    if ((0, util_1.isNumber)(d))\n        return new Date(d * 1000);\n    if (d.date) {\n        const date = (0, util_1.isDate)(d.date) ? new Date(d.date) : new Date(d.date * 1000);\n        if (d.timezone) {\n            adjustDate(date, parseTimezone(d.timezone));\n        }\n        return date;\n    }\n    throw Error(`cannot convert ${expr === null || expr === void 0 ? void 0 : expr.toString()} to date`);\n}\nexports.computeDate = computeDate;\nfunction padDigits(n, digits) {\n    return (new Array(Math.max(digits - String(n).length + 1, 0)).join(\"0\") +\n        n.toString());\n}\nexports.padDigits = padDigits;\nfunction regexQuote(s) {\n    \"^.-*?$\".split(\"\").forEach((c) => {\n        s = s.replace(c, `\\\\${c}`);\n    });\n    return s;\n}\nexports.regexQuote = regexQuote;\nfunction regexStrip(s) {\n    return s.replace(/^\\//, \"\").replace(/\\/$/, \"\");\n}\nexports.regexStrip = regexStrip;\n\n\n/***/ }),\n\n/***/ 9784:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateAdd = void 0;\nconst core_1 = __webpack_require__(9587);\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Increments a Date object by a specified number of time units.\n * @param obj\n * @param expr\n */\nconst $dateAdd = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const d = (0, _internal_1.computeDate)(obj, expr.startDate, options);\n    switch (args.unit) {\n        case \"year\":\n            d.setUTCFullYear(d.getUTCFullYear() + args.amount);\n            break;\n        case \"quarter\":\n            addMonth(d, 3 * args.amount);\n            break;\n        case \"month\":\n            addMonth(d, args.amount);\n            break;\n        default:\n            d.setTime(d.getTime() + _internal_1.DURATION_IN_MILLIS[args.unit] * args.amount);\n    }\n    if (args.timezone) {\n        const tz = (0, _internal_1.parseTimezone)(args.timezone);\n        (0, _internal_1.adjustDate)(d, tz);\n    }\n    return d;\n};\nexports.$dateAdd = $dateAdd;\nfunction addMonth(d, amount) {\n    // months start from 0 to 11.\n    const m = d.getUTCMonth() + amount;\n    const yearOffset = Math.floor(m / 12);\n    if (m < 0) {\n        const month = (m % 12) + 12;\n        d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());\n    }\n    else {\n        d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());\n    }\n}\n\n\n/***/ }),\n\n/***/ 6145:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateDiff = void 0;\nconst core_1 = __webpack_require__(9587);\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the difference between two dates.\n * @param obj\n * @param expr\n * @param options Options\n */\nconst $dateDiff = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const d1 = (0, _internal_1.computeDate)(obj, expr.startDate, options);\n    const d2 = (0, _internal_1.computeDate)(obj, expr.endDate, options);\n    let diff;\n    switch (args.unit) {\n        case \"year\":\n        case \"quarter\":\n        case \"month\":\n            diff = diffYQM(d1, d2, args.unit);\n            break;\n        default:\n            diff = (d2.getTime() - d1.getTime()) / _internal_1.DURATION_IN_MILLIS[args.unit];\n    }\n    return diff;\n};\nexports.$dateDiff = $dateDiff;\nconst unitMonths = {\n    year: 12,\n    quarter: 3,\n    month: 1\n};\nfunction diffYQM(d1, d2, unit) {\n    let months = (d2.getUTCFullYear() - d1.getUTCFullYear()) * 12;\n    months -= d1.getUTCMonth();\n    months += d2.getUTCMonth();\n    return Math.trunc(months / unitMonths[unit]);\n}\n\n\n/***/ }),\n\n/***/ 6723:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateFromParts = void 0;\nconst core_1 = __webpack_require__(9587);\nconst _internal_1 = __webpack_require__(7974);\nconst DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\nconst getDaysInMonth = (date) => {\n    return date.month == 2 && (0, _internal_1.isLeapYear)(date.year)\n        ? 29\n        : DAYS_IN_MONTH[date.month - 1];\n};\n/**\n * Constructs and returns a Date object given the date’s constituent properties.\n *\n * @param obj The document\n * @param expr The date expression\n * @param options Options\n */\nconst $dateFromParts = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const minuteOffset = (0, _internal_1.parseTimezone)(args.timezone);\n    // assign default and adjust value ranges of the different parts\n    for (let i = _internal_1.DATE_PART_INTERVAL.length - 1, remainder = 0; i >= 0; i--) {\n        const datePartInterval = _internal_1.DATE_PART_INTERVAL[i];\n        const k = datePartInterval[0];\n        const min = datePartInterval[1];\n        const max = datePartInterval[2];\n        // add remainder from previous part. units should already be correct\n        let part = (args[k] || 0) + remainder;\n        // reset remainder now that it's been used.\n        remainder = 0;\n        // 1. compute the remainder for the next part\n        // 2. adjust the current part to a valid range\n        // 3. assign back to 'args'\n        const limit = max + 1;\n        // invert timezone to adjust the hours to UTC\n        if (k == \"hour\")\n            part += Math.floor(minuteOffset / _internal_1.MINUTES_PER_HOUR) * -1;\n        if (k == \"minute\")\n            part += (minuteOffset % _internal_1.MINUTES_PER_HOUR) * -1;\n        // smaller than lower bound\n        if (part < min) {\n            const delta = min - part;\n            remainder = -1 * Math.ceil(delta / limit);\n            part = limit - (delta % limit);\n        }\n        else if (part > max) {\n            // offset with the 'min' value to adjust non-zero date parts correctly\n            part += min;\n            remainder = Math.trunc(part / limit);\n            part %= limit;\n        }\n        // reassign\n        args[k] = part;\n    }\n    // adjust end of month to correctly handle overflows\n    args.day = Math.min(args.day, getDaysInMonth(args));\n    return new Date(Date.UTC(args.year, args.month - 1, args.day, args.hour, args.minute, args.second, args.millisecond));\n};\nexports.$dateFromParts = $dateFromParts;\n\n\n/***/ }),\n\n/***/ 5342:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateFromString = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(7974);\nconst buildMap = (letters, sign) => {\n    const h = {};\n    letters.split(\"\").forEach((v, i) => (h[v] = sign * (i + 1)));\n    return h;\n};\nconst TZ_LETTER_OFFSETS = Object.assign(Object.assign(Object.assign({}, buildMap(\"ABCDEFGHIKLM\", 1)), buildMap(\"NOPQRSTUVWXY\", -1)), { Z: 0 });\n/**\n * Converts a date/time string to a date object.\n * @param obj\n * @param expr\n */\nconst $dateFromString = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    args.format = args.format || _internal_1.DATE_FORMAT;\n    args.onNull = args.onNull || null;\n    let dateString = args.dateString;\n    if ((0, util_1.isNil)(dateString))\n        return args.onNull;\n    // collect all separators of the format string\n    const separators = args.format.split(/%[YGmdHMSLuVzZ]/);\n    separators.reverse();\n    const matches = args.format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%V|%z|%Z)/g);\n    const dateParts = {};\n    // holds the valid regex of parts that matches input date string\n    let expectedPattern = \"\";\n    for (let i = 0, len = matches.length; i < len; i++) {\n        const formatSpecifier = matches[i];\n        const props = _internal_1.DATE_SYM_TABLE[formatSpecifier];\n        if ((0, util_1.isObject)(props)) {\n            // get pattern and alias from table\n            const m = props.re.exec(dateString);\n            // get the next separtor\n            const delimiter = separators.pop() || \"\";\n            if (m !== null) {\n                // store and cut out matched part\n                dateParts[props.name] = /^\\d+$/.exec(m[0]) ? parseInt(m[0]) : m[0];\n                dateString =\n                    dateString.substr(0, m.index) +\n                        dateString.substr(m.index + m[0].length);\n                // construct expected pattern\n                expectedPattern +=\n                    (0, _internal_1.regexQuote)(delimiter) + (0, _internal_1.regexStrip)(props.re.toString());\n            }\n            else {\n                dateParts[props.name] = null;\n            }\n        }\n    }\n    // 1. validate all required date parts exists\n    // 2. validate original dateString against expected pattern.\n    if ((0, util_1.isNil)(dateParts.year) ||\n        (0, util_1.isNil)(dateParts.month) ||\n        (0, util_1.isNil)(dateParts.day) ||\n        !new RegExp(\"^\" + expectedPattern + \"[A-Z]?$\").exec(args.dateString)) {\n        return args.onError;\n    }\n    const m = args.dateString.match(/([A-Z])$/);\n    (0, util_1.assert)(\n    // only one of in-date timeone or timezone argument but not both.\n    !(m && args.timezone), `$dateFromString: you cannot pass in a date/time string with time zone information ('${m && m[0]}') together with a timezone argument`);\n    const minuteOffset = m\n        ? TZ_LETTER_OFFSETS[m[0]] * _internal_1.MINUTES_PER_HOUR\n        : (0, _internal_1.parseTimezone)(args.timezone);\n    // create the date. month is 0-based in Date\n    const d = new Date(Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0));\n    if (!(0, util_1.isNil)(dateParts.hour))\n        d.setUTCHours(dateParts.hour);\n    if (!(0, util_1.isNil)(dateParts.minute))\n        d.setUTCMinutes(dateParts.minute);\n    if (!(0, util_1.isNil)(dateParts.second))\n        d.setUTCSeconds(dateParts.second);\n    if (!(0, util_1.isNil)(dateParts.millisecond))\n        d.setUTCMilliseconds(dateParts.millisecond);\n    // adjust to the correct represention for UTC\n    (0, _internal_1.adjustDate)(d, -minuteOffset);\n    return d;\n};\nexports.$dateFromString = $dateFromString;\n\n\n/***/ }),\n\n/***/ 9051:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateSubtract = void 0;\nconst core_1 = __webpack_require__(9587);\nconst dateAdd_1 = __webpack_require__(9784);\n/**\n * Decrements a Date object by a specified number of time units.\n * @param obj\n * @param expr\n */\nconst $dateSubtract = (obj, expr, options) => {\n    const amount = (0, core_1.computeValue)(obj, expr === null || expr === void 0 ? void 0 : expr.amount, null, options);\n    return (0, dateAdd_1.$dateAdd)(obj, Object.assign(Object.assign({}, expr), { amount: -1 * amount }), options);\n};\nexports.$dateSubtract = $dateSubtract;\n\n\n/***/ }),\n\n/***/ 281:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateToParts = void 0;\nconst core_1 = __webpack_require__(9587);\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns a document that contains the constituent parts of a given Date value as individual properties.\n * The properties returned are year, month, day, hour, minute, second and millisecond.\n *\n * @param obj\n * @param expr\n * @param options\n */\nconst $dateToParts = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const d = new Date(args.date);\n    const tz = (0, _internal_1.parseTimezone)(args.timezone);\n    (0, _internal_1.adjustDate)(d, tz);\n    const timePart = {\n        hour: d.getUTCHours(),\n        minute: d.getUTCMinutes(),\n        second: d.getUTCSeconds(),\n        millisecond: d.getUTCMilliseconds()\n    };\n    if (args.iso8601 == true) {\n        return Object.assign(timePart, {\n            isoWeekYear: (0, _internal_1.isoWeekYear)(d),\n            isoWeek: (0, _internal_1.isoWeek)(d),\n            isoDayOfWeek: d.getUTCDay() || 7\n        });\n    }\n    return Object.assign(timePart, {\n        year: d.getUTCFullYear(),\n        month: d.getUTCMonth() + 1,\n        day: d.getUTCDate()\n    });\n};\nexports.$dateToParts = $dateToParts;\n\n\n/***/ }),\n\n/***/ 1300:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dateToString = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(7974);\nconst dayOfMonth_1 = __webpack_require__(5327);\nconst hour_1 = __webpack_require__(5882);\nconst isoDayOfWeek_1 = __webpack_require__(404);\nconst isoWeek_1 = __webpack_require__(9812);\nconst millisecond_1 = __webpack_require__(1338);\nconst minute_1 = __webpack_require__(5337);\nconst month_1 = __webpack_require__(6879);\nconst second_1 = __webpack_require__(743);\nconst week_1 = __webpack_require__(626);\nconst year_1 = __webpack_require__(8546);\n// date functions for format specifiers\nconst DATE_FUNCTIONS = {\n    \"%Y\": year_1.$year,\n    \"%G\": year_1.$year,\n    \"%m\": month_1.$month,\n    \"%d\": dayOfMonth_1.$dayOfMonth,\n    \"%H\": hour_1.$hour,\n    \"%M\": minute_1.$minute,\n    \"%S\": second_1.$second,\n    \"%L\": millisecond_1.$millisecond,\n    \"%u\": isoDayOfWeek_1.$isoDayOfWeek,\n    \"%U\": week_1.$week,\n    \"%V\": isoWeek_1.$isoWeek\n};\n/**\n * Returns the date as a formatted string.\n *\n * %d\tDay of Month (2 digits, zero padded)\t01-31\n * %G\tYear in ISO 8601 format\t0000-9999\n * %H\tHour (2 digits, zero padded, 24-hour clock)\t00-23\n * %L\tMillisecond (3 digits, zero padded)\t000-999\n * %m\tMonth (2 digits, zero padded)\t01-12\n * %M\tMinute (2 digits, zero padded)\t00-59\n * %S\tSecond (2 digits, zero padded)\t00-60\n * %u\tDay of week number in ISO 8601 format (1-Monday, 7-Sunday)\t1-7\n * %V\tWeek of Year in ISO 8601 format\t1-53\n * %Y\tYear (4 digits, zero padded)\t0000-9999\n * %z\tThe timezone offset from UTC.\t+/-[hh][mm]\n * %Z\tThe minutes offset from UTC as a number. For example, if the timezone offset (+/-[hhmm]) was +0445, the minutes offset is +285.\t+/-mmm\n * %%\tPercent Character as a Literal\t%\n *\n * @param obj current object\n * @param expr operator expression\n */\nconst $dateToString = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(args.onNull))\n        args.onNull = null;\n    if ((0, util_1.isNil)(args.date))\n        return args.onNull;\n    const date = (0, _internal_1.computeDate)(obj, args.date, options);\n    let format = args.format || _internal_1.DATE_FORMAT;\n    const minuteOffset = (0, _internal_1.parseTimezone)(args.timezone);\n    const matches = format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%U|%V|%z|%Z)/g);\n    // adjust the date to reflect timezone\n    (0, _internal_1.adjustDate)(date, minuteOffset);\n    for (let i = 0, len = matches.length; i < len; i++) {\n        const formatSpecifier = matches[i];\n        const props = _internal_1.DATE_SYM_TABLE[formatSpecifier];\n        const operatorFn = DATE_FUNCTIONS[formatSpecifier];\n        let value;\n        if ((0, util_1.isObject)(props)) {\n            // reuse date\n            if (props.name === \"timezone\") {\n                value = (0, _internal_1.formatTimezone)(minuteOffset);\n            }\n            else if (props.name === \"minuteOffset\") {\n                value = minuteOffset.toString();\n            }\n            else {\n                (0, util_1.assert)(!!operatorFn, `unsupported date format specifier '${formatSpecifier}'`);\n                value = (0, _internal_1.padDigits)(operatorFn(obj, date, options), props.padding);\n            }\n        }\n        // replace the match with resolved value\n        format = format.replace(formatSpecifier, value);\n    }\n    return format;\n};\nexports.$dateToString = $dateToString;\n\n\n/***/ }),\n\n/***/ 5327:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dayOfMonth = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the day of the month for a date as a number between 1 and 31.\n * @param obj\n * @param expr\n */\nconst $dayOfMonth = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDate();\n};\nexports.$dayOfMonth = $dayOfMonth;\n\n\n/***/ }),\n\n/***/ 982:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dayOfWeek = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the day of the week for a date as a number between 1 (Sunday) and 7 (Saturday).\n * @param obj\n * @param expr\n */\nconst $dayOfWeek = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDay() + 1;\n};\nexports.$dayOfWeek = $dayOfWeek;\n\n\n/***/ }),\n\n/***/ 623:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$dayOfYear = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the day of the year for a date as a number between 1 and 366 (leap year).\n * @param obj\n * @param expr\n */\nconst $dayOfYear = (obj, expr, options) => {\n    return (0, _internal_1.getDayOfYear)((0, _internal_1.computeDate)(obj, expr, options));\n};\nexports.$dayOfYear = $dayOfYear;\n\n\n/***/ }),\n\n/***/ 5882:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$hour = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the hour for a date as a number between 0 and 23.\n * @param obj\n * @param expr\n */\nconst $hour = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCHours();\n};\nexports.$hour = $hour;\n\n\n/***/ }),\n\n/***/ 9173:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9784), exports);\n__exportStar(__webpack_require__(6145), exports);\n__exportStar(__webpack_require__(6723), exports);\n__exportStar(__webpack_require__(5342), exports);\n__exportStar(__webpack_require__(9051), exports);\n__exportStar(__webpack_require__(281), exports);\n__exportStar(__webpack_require__(1300), exports);\n__exportStar(__webpack_require__(5327), exports);\n__exportStar(__webpack_require__(982), exports);\n__exportStar(__webpack_require__(623), exports);\n__exportStar(__webpack_require__(5882), exports);\n__exportStar(__webpack_require__(404), exports);\n__exportStar(__webpack_require__(9812), exports);\n__exportStar(__webpack_require__(1123), exports);\n__exportStar(__webpack_require__(1338), exports);\n__exportStar(__webpack_require__(5337), exports);\n__exportStar(__webpack_require__(6879), exports);\n__exportStar(__webpack_require__(743), exports);\n__exportStar(__webpack_require__(626), exports);\n__exportStar(__webpack_require__(8546), exports);\n\n\n/***/ }),\n\n/***/ 404:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$isoDayOfWeek = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the weekday number in ISO 8601 format, ranging from 1 (Monday) to 7 (Sunday).\n * @param obj\n * @param expr\n */\nconst $isoDayOfWeek = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCDay() || 7;\n};\nexports.$isoDayOfWeek = $isoDayOfWeek;\n\n\n/***/ }),\n\n/***/ 9812:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$isoWeek = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the week number in ISO 8601 format, ranging from 1 to 53.\n * Week numbers start at 1 with the week (Monday through Sunday) that contains the year's first Thursday.\n * @param obj\n * @param expr\n */\nconst $isoWeek = (obj, expr, options) => {\n    return (0, _internal_1.isoWeek)((0, _internal_1.computeDate)(obj, expr, options));\n};\nexports.$isoWeek = $isoWeek;\n\n\n/***/ }),\n\n/***/ 1123:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$isoWeekYear = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the year number in ISO 8601 format. The year starts with the Monday of week 1 and ends with the Sunday of the last week.\n * @param obj\n * @param expr\n */\nconst $isoWeekYear = (obj, expr, options) => {\n    const d = (0, _internal_1.computeDate)(obj, expr, options);\n    return (d.getUTCFullYear() -\n        Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1));\n};\nexports.$isoWeekYear = $isoWeekYear;\n\n\n/***/ }),\n\n/***/ 1338:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$millisecond = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the milliseconds of a date as a number between 0 and 999.\n * @param obj\n * @param expr\n */\nconst $millisecond = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMilliseconds();\n};\nexports.$millisecond = $millisecond;\n\n\n/***/ }),\n\n/***/ 5337:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$minute = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the minute for a date as a number between 0 and 59.\n * @param obj\n * @param expr\n */\nconst $minute = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMinutes();\n};\nexports.$minute = $minute;\n\n\n/***/ }),\n\n/***/ 6879:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$month = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the month for a date as a number between 1 (January) and 12 (December).\n * @param obj\n * @param expr\n */\nconst $month = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCMonth() + 1;\n};\nexports.$month = $month;\n\n\n/***/ }),\n\n/***/ 743:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$second = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the seconds for a date as a number between 0 and 60 (leap seconds).\n * @param obj\n * @param expr\n */\nconst $second = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCSeconds();\n};\nexports.$second = $second;\n\n\n/***/ }),\n\n/***/ 626:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$week = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the week of the year for a date as a number between 0 and 53.\n * Weeks begin on Sundays, and week 1 begins with the first Sunday of the year. Days preceding the first Sunday of the year are in week 0\n * @param obj\n * @param expr\n */\nconst $week = (obj, expr, options) => {\n    const d = (0, _internal_1.computeDate)(obj, expr, options);\n    const result = (0, _internal_1.isoWeek)(d);\n    // check for starting of year and adjust accordingly\n    if (d.getUTCDay() > 0 && d.getUTCDate() == 1 && d.getUTCMonth() == 0)\n        return 0;\n    // adjust for week start on Sunday\n    if (d.getUTCDay() == 0)\n        return result + 1;\n    // else\n    return result;\n};\nexports.$week = $week;\n\n\n/***/ }),\n\n/***/ 8546:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Date Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#date-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$year = void 0;\nconst _internal_1 = __webpack_require__(7974);\n/**\n * Returns the year for a date as a number (e.g. 2014).\n * @param obj\n * @param expr\n */\nconst $year = (obj, expr, options) => {\n    return (0, _internal_1.computeDate)(obj, expr, options).getUTCFullYear();\n};\nexports.$year = $year;\n\n\n/***/ }),\n\n/***/ 8985:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(1744), exports);\n__exportStar(__webpack_require__(1613), exports);\n__exportStar(__webpack_require__(628), exports);\n__exportStar(__webpack_require__(4591), exports);\n__exportStar(__webpack_require__(5112), exports);\n__exportStar(__webpack_require__(4052), exports);\n__exportStar(__webpack_require__(9173), exports);\n__exportStar(__webpack_require__(5951), exports);\n__exportStar(__webpack_require__(2385), exports);\n__exportStar(__webpack_require__(6478), exports);\n__exportStar(__webpack_require__(8234), exports);\n__exportStar(__webpack_require__(9266), exports);\n__exportStar(__webpack_require__(4441), exports);\n__exportStar(__webpack_require__(1146), exports);\n__exportStar(__webpack_require__(4354), exports);\n\n\n/***/ }),\n\n/***/ 5951:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Literal Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#literal-expression-operator\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$literal = void 0;\n/**\n * Return a value without parsing.\n * @param obj\n * @param expr\n * @param options\n */\nconst $literal = (_obj, expr, _options) => expr;\nexports.$literal = $literal;\n\n\n/***/ }),\n\n/***/ 8848:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/rand/#mongodb-expression-exp.-rand\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$getField = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Adds, updates, or removes a specified field in a document.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $getField = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    let input = obj;\n    let field = args;\n    if ((0, util_1.isObject)(args) && args.input && args.field) {\n        input = args.input;\n        field = args.field;\n    }\n    if ((0, util_1.isNil)(input))\n        return null;\n    (0, util_1.assert)((0, util_1.isObject)(input), \"$getField expression 'input' must evaluate to an object\");\n    (0, util_1.assert)((0, util_1.isString)(field), \"$getField expression 'field' must evaluate to a string\");\n    return input[field];\n};\nexports.$getField = $getField;\n\n\n/***/ }),\n\n/***/ 2385:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(8848), exports);\n__exportStar(__webpack_require__(2746), exports);\n__exportStar(__webpack_require__(9468), exports);\n\n\n/***/ }),\n\n/***/ 2746:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/rand/#mongodb-expression-exp.-rand\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$rand = void 0;\n/**\n * Returns a random float between 0 and 1.\n *\n * @param {*} _obj The target object for this expression\n * @param {*} _expr The right-hand side of the operator\n * @param {Options} _options Options to use for operation\n */\nconst $rand = (_obj, _expr, _options) => Math.random();\nexports.$rand = $rand;\n\n\n/***/ }),\n\n/***/ 9468:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Miscellaneous Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#miscellaneous-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sampleRate = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Randomly select documents at a given rate.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $sampleRate = (obj, expr, options) => Math.random() <= (0, core_1.computeValue)(obj, expr, null, options);\nexports.$sampleRate = $sampleRate;\n\n\n/***/ }),\n\n/***/ 6478:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9531), exports);\n__exportStar(__webpack_require__(4137), exports);\n__exportStar(__webpack_require__(3514), exports);\n__exportStar(__webpack_require__(5432), exports);\n\n\n/***/ }),\n\n/***/ 9531:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$mergeObjects = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Combines multiple documents into a single document.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $mergeObjects = (obj, expr, options) => {\n    const docs = (0, core_1.computeValue)(obj, expr, null, options);\n    return docs instanceof Array\n        ? docs.reduce((memo, o) => (0, util_1.into)(memo, o), {})\n        : {};\n};\nexports.$mergeObjects = $mergeObjects;\n\n\n/***/ }),\n\n/***/ 4137:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$objectToArray = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Converts a document to an array of documents representing key-value pairs.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $objectToArray = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isObject)(val), \"$objectToArray expression must resolve to an object\");\n    const entries = Object.entries(val);\n    const result = new Array(entries.length);\n    let i = 0;\n    for (const [k, v] of entries) {\n        result[i++] = { k, v };\n    }\n    return result;\n};\nexports.$objectToArray = $objectToArray;\n\n\n/***/ }),\n\n/***/ 3514:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setField = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Adds, updates, or removes a specified field in a document.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $setField = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(args.input))\n        return null;\n    (0, util_1.assert)((0, util_1.isObject)(args.input), \"$setField expression 'input' must evaluate to an object\");\n    (0, util_1.assert)((0, util_1.isString)(args.field), \"$setField expression 'field' must evaluate to a string\");\n    if (expr.value == \"$$REMOVE\") {\n        delete obj[args.field];\n    }\n    else {\n        obj[args.field] = args.value;\n    }\n    return obj;\n};\nexports.$setField = $setField;\n\n\n/***/ }),\n\n/***/ 5432:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Object Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#object-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$unsetField = void 0;\nconst setField_1 = __webpack_require__(3514);\n/**\n * Adds, updates, or removes a specified field in a document.\n *\n * @param {*} obj The target object for this expression\n * @param {*} expr The right-hand side of the operator\n * @param {Options} options Options to use for operation\n */\nconst $unsetField = (obj, expr, options) => {\n    return (0, setField_1.$setField)(obj, Object.assign(Object.assign({}, expr), { value: \"$$REMOVE\" }), options);\n};\nexports.$unsetField = $unsetField;\n\n\n/***/ }),\n\n/***/ 9462:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$allElementsTrue = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true if all elements of a set evaluate to true, and false otherwise.\n * @param obj\n * @param expr\n */\nconst $allElementsTrue = (obj, expr, options) => {\n    // mongodb nests the array expression in another\n    const args = (0, core_1.computeValue)(obj, expr, null, options)[0];\n    return args.every(v => (0, util_1.truthy)(v, options.useStrictMode));\n};\nexports.$allElementsTrue = $allElementsTrue;\n\n\n/***/ }),\n\n/***/ 5459:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$anyElementTrue = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true if any elements of a set evaluate to true, and false otherwise.\n * @param obj\n * @param expr\n */\nconst $anyElementTrue = (obj, expr, options) => {\n    // mongodb nests the array expression in another\n    const args = (0, core_1.computeValue)(obj, expr, null, options)[0];\n    return args.some(v => (0, util_1.truthy)(v, options.useStrictMode));\n};\nexports.$anyElementTrue = $anyElementTrue;\n\n\n/***/ }),\n\n/***/ 8234:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9462), exports);\n__exportStar(__webpack_require__(5459), exports);\n__exportStar(__webpack_require__(5403), exports);\n__exportStar(__webpack_require__(6155), exports);\n__exportStar(__webpack_require__(1860), exports);\n__exportStar(__webpack_require__(5810), exports);\n__exportStar(__webpack_require__(2409), exports);\n\n\n/***/ }),\n\n/***/ 5403:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setDifference = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns elements of a set that do not appear in a second set.\n * @param obj\n * @param expr\n */\nconst $setDifference = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return args[0].filter(util_1.notInArray.bind(null, args[1]));\n};\nexports.$setDifference = $setDifference;\n\n\n/***/ }),\n\n/***/ 6155:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setEquals = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true if two sets have the same elements.\n * @param obj\n * @param expr\n */\nconst $setEquals = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const xs = (0, util_1.unique)(args[0], options === null || options === void 0 ? void 0 : options.hashFunction);\n    const ys = (0, util_1.unique)(args[1], options === null || options === void 0 ? void 0 : options.hashFunction);\n    return (xs.length === ys.length &&\n        xs.length === (0, util_1.intersection)([xs, ys], options === null || options === void 0 ? void 0 : options.hashFunction).length);\n};\nexports.$setEquals = $setEquals;\n\n\n/***/ }),\n\n/***/ 1860:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setIntersection = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the common elements of the input sets.\n * @param obj\n * @param expr\n */\nconst $setIntersection = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(args) && args.every(util_1.isArray), \"$setIntersection: expresssion must resolve to array of arrays\");\n    return (0, util_1.intersection)(args, options === null || options === void 0 ? void 0 : options.hashFunction);\n};\nexports.$setIntersection = $setIntersection;\n\n\n/***/ }),\n\n/***/ 5810:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setIsSubset = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns true if all elements of a set appear in a second set.\n * @param obj\n * @param expr\n */\nconst $setIsSubset = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.intersection)(args, options === null || options === void 0 ? void 0 : options.hashFunction).length === args[0].length;\n};\nexports.$setIsSubset = $setIsSubset;\n\n\n/***/ }),\n\n/***/ 2409:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Set Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#set-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setUnion = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a set that holds all elements of the input sets.\n * @param obj\n * @param expr\n */\nconst $setUnion = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    (0, util_1.assert)((0, util_1.isArray)(args) && args.length == 2 && args.every(util_1.isArray), \"$setUnion: arguments must be arrays\");\n    return (0, util_1.unique)(args[0].concat(args[1]), options === null || options === void 0 ? void 0 : options.hashFunction);\n};\nexports.$setUnion = $setUnion;\n\n\n/***/ }),\n\n/***/ 3421:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.regexSearch = exports.trimString = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/* eslint-disable*/\nconst WHITESPACE_CHARS = [\n    0x0000,\n    0x0020,\n    0x0009,\n    0x000a,\n    0x000b,\n    0x000c,\n    0x000d,\n    0x00a0,\n    0x1680,\n    0x2000,\n    0x2001,\n    0x2002,\n    0x2003,\n    0x2004,\n    0x2005,\n    0x2006,\n    0x2007,\n    0x2008,\n    0x2009,\n    0x200a // Hair space\n];\n/**\n * Trims the resolved string\n *\n * @param obj\n * @param expr\n * @param options\n */\nfunction trimString(obj, expr, options, trimOpts) {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    const s = val.input;\n    if ((0, util_1.isNil)(s))\n        return null;\n    const codepoints = (0, util_1.isNil)(val.chars)\n        ? WHITESPACE_CHARS\n        : val.chars.split(\"\").map((c) => c.codePointAt(0));\n    let i = 0;\n    let j = s.length - 1;\n    while (trimOpts.left &&\n        i <= j &&\n        codepoints.indexOf(s[i].codePointAt(0)) !== -1)\n        i++;\n    while (trimOpts.right &&\n        i <= j &&\n        codepoints.indexOf(s[j].codePointAt(0)) !== -1)\n        j--;\n    return s.substring(i, j + 1);\n}\nexports.trimString = trimString;\n/**\n * Performs a regex search\n *\n * @param obj\n * @param expr\n * @param opts\n */\nfunction regexSearch(obj, expr, options, reOpts) {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if (!(0, util_1.isString)(val.input))\n        return [];\n    const regexOptions = val.options;\n    if (regexOptions) {\n        (0, util_1.assert)(regexOptions.indexOf(\"x\") === -1, \"extended capability option 'x' not supported\");\n        (0, util_1.assert)(regexOptions.indexOf(\"g\") === -1, \"global option 'g' not supported\");\n    }\n    let input = val.input;\n    const re = new RegExp(val.regex, regexOptions);\n    let m;\n    const matches = new Array();\n    let offset = 0;\n    while ((m = re.exec(input))) {\n        const result = {\n            match: m[0],\n            idx: m.index + offset,\n            captures: []\n        };\n        for (let i = 1; i < m.length; i++)\n            result.captures.push(m[i] || null);\n        matches.push(result);\n        if (!reOpts.global)\n            break;\n        offset = m.index + m[0].length;\n        input = input.substring(offset);\n    }\n    return matches;\n}\nexports.regexSearch = regexSearch;\n/*eslint-enable*/\n\n\n/***/ }),\n\n/***/ 8995:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$concat = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Concatenates two strings.\n *\n * @param obj\n * @param expr\n * @returns {string|*}\n */\nconst $concat = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    // does not allow concatenation with nulls\n    if ([null, undefined].some(util_1.inArray.bind(null, args)))\n        return null;\n    return args.join(\"\");\n};\nexports.$concat = $concat;\n\n\n/***/ }),\n\n/***/ 9266:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(8995), exports);\n__exportStar(__webpack_require__(3375), exports);\n__exportStar(__webpack_require__(1366), exports);\n__exportStar(__webpack_require__(5649), exports);\n__exportStar(__webpack_require__(7258), exports);\n__exportStar(__webpack_require__(7433), exports);\n__exportStar(__webpack_require__(4385), exports);\n__exportStar(__webpack_require__(3869), exports);\n__exportStar(__webpack_require__(3648), exports);\n__exportStar(__webpack_require__(7066), exports);\n__exportStar(__webpack_require__(3868), exports);\n__exportStar(__webpack_require__(3837), exports);\n__exportStar(__webpack_require__(5292), exports);\n__exportStar(__webpack_require__(8378), exports);\n__exportStar(__webpack_require__(7476), exports);\n__exportStar(__webpack_require__(4098), exports);\n__exportStar(__webpack_require__(7013), exports);\n__exportStar(__webpack_require__(310), exports);\n__exportStar(__webpack_require__(8745), exports);\n\n\n/***/ }),\n\n/***/ 3375:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$indexOfBytes = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Searches a string for an occurrence of a substring and returns the UTF-8 code point index of the first occurence.\n * If the substring is not found, returns -1.\n *\n * @param  {Object} obj\n * @param  {*} expr\n * @return {*}\n */\nconst $indexOfBytes = (obj, expr, options) => {\n    const arr = (0, core_1.computeValue)(obj, expr, null, options);\n    const errorMsg = \"$indexOfBytes expression resolves to invalid an argument\";\n    if ((0, util_1.isNil)(arr[0]))\n        return null;\n    (0, util_1.assert)((0, util_1.isString)(arr[0]) && (0, util_1.isString)(arr[1]), errorMsg);\n    const str = arr[0];\n    const searchStr = arr[1];\n    let start = arr[2];\n    let end = arr[3];\n    let valid = (0, util_1.isNil)(start) ||\n        ((0, util_1.isNumber)(start) && start >= 0 && Math.round(start) === start);\n    valid =\n        valid &&\n            ((0, util_1.isNil)(end) || ((0, util_1.isNumber)(end) && end >= 0 && Math.round(end) === end));\n    (0, util_1.assert)(valid, errorMsg);\n    start = start || 0;\n    end = end || str.length;\n    if (start > end)\n        return -1;\n    const index = str.substring(start, end).indexOf(searchStr);\n    return index > -1 ? index + start : index;\n};\nexports.$indexOfBytes = $indexOfBytes;\n\n\n/***/ }),\n\n/***/ 1366:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ltrim = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Removes whitespace characters, including null, or the specified characters from the beginning of a string.\n *\n * @param obj\n * @param expr\n */\nconst $ltrim = (obj, expr, options) => {\n    return (0, _internal_1.trimString)(obj, expr, options, { left: true, right: false });\n};\nexports.$ltrim = $ltrim;\n\n\n/***/ }),\n\n/***/ 5649:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$regexFind = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Applies a regular expression (regex) to a string and returns information on the first matched substring.\n *\n * @param obj\n * @param expr\n */\nconst $regexFind = (obj, expr, options) => {\n    const result = (0, _internal_1.regexSearch)(obj, expr, options, { global: false });\n    return result && result.length > 0 ? result[0] : null;\n};\nexports.$regexFind = $regexFind;\n\n\n/***/ }),\n\n/***/ 7258:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$regexFindAll = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Applies a regular expression (regex) to a string and returns information on the all matched substrings.\n *\n * @param obj\n * @param expr\n */\nconst $regexFindAll = (obj, expr, options) => {\n    return (0, _internal_1.regexSearch)(obj, expr, options, { global: true });\n};\nexports.$regexFindAll = $regexFindAll;\n\n\n/***/ }),\n\n/***/ 7433:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$regexMatch = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Applies a regular expression (regex) to a string and returns a boolean that indicates if a match is found or not.\n *\n * @param obj\n * @param expr\n */\nconst $regexMatch = (obj, expr, options) => {\n    return (0, _internal_1.regexSearch)(obj, expr, options, { global: false }).length != 0;\n};\nexports.$regexMatch = $regexMatch;\n\n\n/***/ }),\n\n/***/ 4385:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$replaceAll = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Replaces all instances of a matched string in a given input.\n *\n * @param  {Object} obj\n * @param  {Array} expr\n */\nconst $replaceAll = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const arr = [args.input, args.find, args.replacement];\n    if (arr.some(util_1.isNil))\n        return null;\n    (0, util_1.assert)(arr.every(util_1.isString), \"$replaceAll expression fields must evaluate to string\");\n    return args.input.replace(new RegExp(args.find, \"g\"), args.replacement);\n};\nexports.$replaceAll = $replaceAll;\n\n\n/***/ }),\n\n/***/ 3869:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$replaceOne = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Replaces the first instance of a matched string in a given input.\n *\n * @param  {Object} obj\n * @param  {Array} expr\n */\nconst $replaceOne = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const arr = [args.input, args.find, args.replacement];\n    if (arr.some(util_1.isNil))\n        return null;\n    (0, util_1.assert)(arr.every(util_1.isString), \"$replaceOne expression fields must evaluate to string\");\n    return args.input.replace(args.find, args.replacement);\n};\nexports.$replaceOne = $replaceOne;\n\n\n/***/ }),\n\n/***/ 3648:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$rtrim = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Removes whitespace characters, including null, or the specified characters from the end of a string.\n *\n * @param obj\n * @param expr\n */\nconst $rtrim = (obj, expr, options) => {\n    return (0, _internal_1.trimString)(obj, expr, options, { left: false, right: true });\n};\nexports.$rtrim = $rtrim;\n\n\n/***/ }),\n\n/***/ 7066:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$split = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Splits a string into substrings based on a delimiter.\n * If the delimiter is not found within the string, returns an array containing the original string.\n *\n * @param  {Object} obj\n * @param  {Array} expr\n * @return {Array} Returns an array of substrings.\n */\nconst $split = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(args[0]))\n        return null;\n    (0, util_1.assert)(args.every(util_1.isString), \"$split expression must result to array(2) of strings\");\n    return args[0].split(args[1]);\n};\nexports.$split = $split;\n\n\n/***/ }),\n\n/***/ 3837:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$strLenBytes = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Returns the number of UTF-8 encoded bytes in the specified string.\n *\n * @param  {Object} obj\n * @param  {String} expr\n * @return {Number}\n */\nconst $strLenBytes = (obj, expr, options) => {\n    return ~-encodeURI((0, core_1.computeValue)(obj, expr, null, options)).split(/%..|./).length;\n};\nexports.$strLenBytes = $strLenBytes;\n\n\n/***/ }),\n\n/***/ 5292:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$strLenCP = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Returns the number of UTF-8 code points in the specified string.\n *\n * @param  {Object} obj\n * @param  {String} expr\n * @return {Number}\n */\nconst $strLenCP = (obj, expr, options) => {\n    return (0, core_1.computeValue)(obj, expr, null, options).length;\n};\nexports.$strLenCP = $strLenCP;\n\n\n/***/ }),\n\n/***/ 3868:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$strcasecmp = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Compares two strings and returns an integer that reflects the comparison.\n *\n * @param obj\n * @param expr\n * @returns {number}\n */\nconst $strcasecmp = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    let a = args[0];\n    let b = args[1];\n    if ((0, util_1.isEqual)(a, b) || args.every(util_1.isNil))\n        return 0;\n    (0, util_1.assert)(args.every(util_1.isString), \"$strcasecmp must resolve to array(2) of strings\");\n    a = a.toUpperCase();\n    b = b.toUpperCase();\n    return (a > b && 1) || (a < b && -1) || 0;\n};\nexports.$strcasecmp = $strcasecmp;\n\n\n/***/ }),\n\n/***/ 8378:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$substr = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a substring of a string, starting at a specified index position and including the specified number of characters.\n * The index is zero-based.\n *\n * @param obj\n * @param expr\n * @returns {string}\n */\nconst $substr = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const s = args[0];\n    const index = args[1];\n    const count = args[2];\n    if ((0, util_1.isString)(s)) {\n        if (index < 0) {\n            return \"\";\n        }\n        else if (count < 0) {\n            return s.substr(index);\n        }\n        else {\n            return s.substr(index, count);\n        }\n    }\n    return \"\";\n};\nexports.$substr = $substr;\n\n\n/***/ }),\n\n/***/ 7476:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$substrBytes = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst UTF8_MASK = [0xc0, 0xe0, 0xf0];\n// encodes a unicode code point to a utf8 byte sequence\n// https://encoding.spec.whatwg.org/#utf-8\nfunction toUtf8(n) {\n    if (n < 0x80)\n        return [n];\n    let count = (n < 0x0800 && 1) || (n < 0x10000 && 2) || 3;\n    const offset = UTF8_MASK[count - 1];\n    const utf8 = [(n >> (6 * count)) + offset];\n    while (count > 0)\n        utf8.push(0x80 | ((n >> (6 * --count)) & 0x3f));\n    return utf8;\n}\nfunction utf8Encode(s) {\n    const buf = [];\n    for (let i = 0, len = s.length; i < len; i++) {\n        buf.push(toUtf8(s.codePointAt(i)));\n    }\n    return buf;\n}\n/**\n * Returns a substring of a string, starting at a specified index position and including the specified number of characters.\n * The index is zero-based.\n *\n * @param obj\n * @param expr\n * @returns {string}\n */\nconst $substrBytes = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    const s = args[0];\n    const index = args[1];\n    const count = args[2];\n    (0, util_1.assert)((0, util_1.isString)(s) &&\n        (0, util_1.isNumber)(index) &&\n        index >= 0 &&\n        (0, util_1.isNumber)(count) &&\n        count >= 0, \"$substrBytes: invalid arguments\");\n    const buf = utf8Encode(s);\n    const validIndex = [];\n    let acc = 0;\n    for (let i = 0; i < buf.length; i++) {\n        validIndex.push(acc);\n        acc += buf[i].length;\n    }\n    const begin = validIndex.indexOf(index);\n    const end = validIndex.indexOf(index + count);\n    (0, util_1.assert)(begin > -1 && end > -1, \"$substrBytes: invalid range, start or end index is a UTF-8 continuation byte.\");\n    return s.substring(begin, end);\n};\nexports.$substrBytes = $substrBytes;\n\n\n/***/ }),\n\n/***/ 4098:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$substrCP = void 0;\nconst substr_1 = __webpack_require__(8378);\nconst $substrCP = (obj, expr, options) => {\n    return (0, substr_1.$substr)(obj, expr, options);\n};\nexports.$substrCP = $substrCP;\n\n\n/***/ }),\n\n/***/ 7013:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toLower = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Converts a string to lowercase.\n *\n * @param obj\n * @param expr\n * @returns {string}\n */\nconst $toLower = (obj, expr, options) => {\n    const value = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.isEmpty)(value) ? \"\" : value.toLowerCase();\n};\nexports.$toLower = $toLower;\n\n\n/***/ }),\n\n/***/ 310:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toUpper = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Converts a string to uppercase.\n *\n * @param obj\n * @param expr\n * @returns {string}\n */\nconst $toUpper = (obj, expr, options) => {\n    const value = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.isEmpty)(value) ? \"\" : value.toUpperCase();\n};\nexports.$toUpper = $toUpper;\n\n\n/***/ }),\n\n/***/ 8745:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * String Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#string-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$trim = void 0;\nconst _internal_1 = __webpack_require__(3421);\n/**\n * Removes whitespace characters, including null, or the specified characters from the beginning and end of a string.\n *\n * @param obj\n * @param expr\n */\nconst $trim = (obj, expr, options) => {\n    return (0, _internal_1.trimString)(obj, expr, options, { left: true, right: true });\n};\nexports.$trim = $trim;\n\n\n/***/ }),\n\n/***/ 725:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.createTrignometryOperator = void 0;\nconst core_1 = __webpack_require__(9587);\nconst FIXED_POINTS = {\n    undefined: null,\n    null: null,\n    NaN: NaN,\n    Infinity: new Error(),\n    \"-Infinity\": new Error()\n};\n/**\n * Returns an operator for a given trignometric function\n *\n * @param f The trignometric function\n */\nfunction createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {\n    const fp = Object.assign({}, FIXED_POINTS, fixedPoints);\n    const keySet = new Set(Object.keys(fp));\n    return (obj, expr, options) => {\n        const n = (0, core_1.computeValue)(obj, expr, null, options);\n        if (keySet.has(`${n}`)) {\n            const res = fp[`${n}`];\n            if (res instanceof Error) {\n                throw new Error(`cannot apply $${f.name} to -inf, value must in (-inf,inf)`);\n            }\n            return res;\n        }\n        return f(n);\n    };\n}\nexports.createTrignometryOperator = createTrignometryOperator;\n\n\n/***/ }),\n\n/***/ 4349:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$acos = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse cosine (arc cosine) of a value in radians. */\nexports.$acos = (0, _internal_1.createTrignometryOperator)(Math.acos, {\n    Infinity: Infinity,\n    0: new Error(),\n});\n\n\n/***/ }),\n\n/***/ 1699:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$acosh = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse hyperbolic cosine (hyperbolic arc cosine) of a value in radians. */\nexports.$acosh = (0, _internal_1.createTrignometryOperator)(Math.acosh, {\n    Infinity: Infinity,\n    0: new Error(),\n});\n\n\n/***/ }),\n\n/***/ 160:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$asin = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse sin (arc sine) of a value in radians. */\nexports.$asin = (0, _internal_1.createTrignometryOperator)(Math.asin);\n\n\n/***/ }),\n\n/***/ 5805:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$asinh = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse hyperbolic sine (hyperbolic arc sine) of a value in radians. */\nexports.$asinh = (0, _internal_1.createTrignometryOperator)(Math.asinh, {\n    Infinity: Infinity,\n    \"-Infinity\": -Infinity,\n});\n\n\n/***/ }),\n\n/***/ 8335:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$atan = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse tangent (arc tangent) of a value in radians. */\nexports.$atan = (0, _internal_1.createTrignometryOperator)(Math.atan);\n\n\n/***/ }),\n\n/***/ 5106:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$atan2 = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns the inverse tangent (arc tangent) of y / x in radians, where y and x are the first and second values passed to the expression respectively. */\nconst $atan2 = (obj, expr, options) => {\n    const [y, x] = (0, core_1.computeValue)(obj, expr, null, options);\n    if (isNaN(y) || (0, util_1.isNil)(y))\n        return y;\n    if (isNaN(x) || (0, util_1.isNil)(x))\n        return x;\n    return Math.atan2(y, x);\n};\nexports.$atan2 = $atan2;\n\n\n/***/ }),\n\n/***/ 5133:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$atanh = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the inverse hyperbolic tangent (hyperbolic arc tangent) of a value in radians. */\nexports.$atanh = (0, _internal_1.createTrignometryOperator)(Math.atanh, {\n    1: Infinity,\n    \"-1\": -Infinity,\n});\n\n\n/***/ }),\n\n/***/ 4925:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$cos = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the cosine of a value that is measured in radians. */\nexports.$cos = (0, _internal_1.createTrignometryOperator)(Math.cos);\n\n\n/***/ }),\n\n/***/ 3138:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$cosh = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the hyperbolic cosine of a value that is measured in radians. */\nexports.$cosh = (0, _internal_1.createTrignometryOperator)(Math.cosh, {\n    \"-Infinity\": Infinity,\n    Infinity: Infinity,\n    // [Math.PI]: -1,\n});\n\n\n/***/ }),\n\n/***/ 2989:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$degreesToRadians = void 0;\nconst _internal_1 = __webpack_require__(725);\nconst RADIANS_FACTOR = Math.PI / 180;\n/** Converts a value from degrees to radians. */\nexports.$degreesToRadians = (0, _internal_1.createTrignometryOperator)((n) => n * RADIANS_FACTOR, {\n    Infinity: Infinity,\n    \"-Infinity\": Infinity,\n});\n\n\n/***/ }),\n\n/***/ 4441:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(4349), exports);\n__exportStar(__webpack_require__(1699), exports);\n__exportStar(__webpack_require__(160), exports);\n__exportStar(__webpack_require__(5805), exports);\n__exportStar(__webpack_require__(8335), exports);\n__exportStar(__webpack_require__(5106), exports);\n__exportStar(__webpack_require__(5133), exports);\n__exportStar(__webpack_require__(4925), exports);\n__exportStar(__webpack_require__(3138), exports);\n__exportStar(__webpack_require__(2989), exports);\n__exportStar(__webpack_require__(6019), exports);\n__exportStar(__webpack_require__(8534), exports);\n__exportStar(__webpack_require__(4738), exports);\n__exportStar(__webpack_require__(5295), exports);\n\n\n/***/ }),\n\n/***/ 6019:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$radiansToDegrees = void 0;\nconst _internal_1 = __webpack_require__(725);\nconst DEGREES_FACTOR = 180 / Math.PI;\n/** Converts a value from radians to degrees. */\nexports.$radiansToDegrees = (0, _internal_1.createTrignometryOperator)((n) => n * DEGREES_FACTOR, {\n    Infinity: Infinity,\n    \"-Infinity\": -Infinity,\n});\n\n\n/***/ }),\n\n/***/ 8534:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sin = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the sine of a value that is measured in radians. */\nexports.$sin = (0, _internal_1.createTrignometryOperator)(Math.sin);\n\n\n/***/ }),\n\n/***/ 4738:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sinh = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the hyperbolic sine of a value that is measured in radians. */\nexports.$sinh = (0, _internal_1.createTrignometryOperator)(Math.sinh, {\n    \"-Infinity\": -Infinity,\n    Infinity: Infinity,\n});\n\n\n/***/ }),\n\n/***/ 5295:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Trignometry Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#trigonometry-expression-operators\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$tan = void 0;\nconst _internal_1 = __webpack_require__(725);\n/** Returns the tangent of a value that is measured in radians. */\nexports.$tan = (0, _internal_1.createTrignometryOperator)(Math.tan);\n\n\n/***/ }),\n\n/***/ 1288:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.toInteger = exports.TypeConvertError = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nclass TypeConvertError extends Error {\n    constructor(message) {\n        super(message);\n    }\n}\nexports.TypeConvertError = TypeConvertError;\nfunction toInteger(obj, expr, options, max, min, typename) {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(val))\n        return null;\n    if (val instanceof Date)\n        return val.getTime();\n    if (val === true)\n        return 1;\n    if (val === false)\n        return 0;\n    const n = Number(val);\n    if ((0, util_1.isNumber)(n) && n >= min && n <= max) {\n        // weirdly a decimal in string format cannot be converted to int.\n        // so we must check input if not string or if it is, not in decimal format\n        if (!(0, util_1.isString)(val) || n.toString().indexOf(\".\") === -1) {\n            return Math.trunc(n);\n        }\n    }\n    throw new TypeConvertError(`cannot convert '${val}' to ${typename}`);\n}\nexports.toInteger = toInteger;\n\n\n/***/ }),\n\n/***/ 4910:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$convert = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(1288);\nconst toBool_1 = __webpack_require__(4586);\nconst toDate_1 = __webpack_require__(7309);\nconst toDouble_1 = __webpack_require__(1753);\nconst toInt_1 = __webpack_require__(3706);\nconst toLong_1 = __webpack_require__(6488);\nconst toString_1 = __webpack_require__(6617);\n/**\n * Converts a value to a specified type.\n *\n * @param obj\n * @param expr\n */\nconst $convert = (obj, expr, options) => {\n    const args = (0, core_1.computeValue)(obj, expr, null, options);\n    args.onNull = args.onNull === undefined ? null : args.onNull;\n    if ((0, util_1.isNil)(args.input))\n        return args.onNull;\n    try {\n        switch (args.to) {\n            case 2:\n            case \"string\":\n                return (0, toString_1.$toString)(obj, args.input, options);\n            case 8:\n            case \"boolean\":\n            case \"bool\":\n                return (0, toBool_1.$toBool)(obj, args.input, options);\n            case 9:\n            case \"date\":\n                return (0, toDate_1.$toDate)(obj, args.input, options);\n            case 1:\n            case 19:\n            case \"double\":\n            case \"decimal\":\n            case \"number\":\n                return (0, toDouble_1.$toDouble)(obj, args.input, options);\n            case 16:\n            case \"int\":\n                return (0, toInt_1.$toInt)(obj, args.input, options);\n            case 18:\n            case \"long\":\n                return (0, toLong_1.$toLong)(obj, args.input, options);\n        }\n    }\n    catch (e) {\n        /*nothing to do*/\n    }\n    if (args.onError !== undefined)\n        return args.onError;\n    throw new _internal_1.TypeConvertError(`could not convert to type ${args.to}.`);\n};\nexports.$convert = $convert;\n\n\n/***/ }),\n\n/***/ 1146:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(4910), exports);\n__exportStar(__webpack_require__(3429), exports);\n__exportStar(__webpack_require__(4586), exports);\n__exportStar(__webpack_require__(7309), exports);\n__exportStar(__webpack_require__(9239), exports);\n__exportStar(__webpack_require__(1753), exports);\n__exportStar(__webpack_require__(3706), exports);\n__exportStar(__webpack_require__(6488), exports);\n__exportStar(__webpack_require__(6617), exports);\n__exportStar(__webpack_require__(4446), exports);\n\n\n/***/ }),\n\n/***/ 3429:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$isNumber = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Checks if the specified expression resolves to a numeric value\n *\n * @param obj\n * @param expr\n */\nconst $isNumber = (obj, expr, options) => {\n    const n = (0, core_1.computeValue)(obj, expr, null, options);\n    return (0, util_1.isNumber)(n);\n};\nexports.$isNumber = $isNumber;\n\n\n/***/ }),\n\n/***/ 4586:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toBool = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Converts a value to a boolean.\n *\n * @param obj\n * @param expr\n */\nconst $toBool = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(val))\n        return null;\n    if ((0, util_1.isString)(val))\n        return true;\n    return Boolean(val);\n};\nexports.$toBool = $toBool;\n\n\n/***/ }),\n\n/***/ 7309:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toDate = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(1288);\n/**\n * Converts a value to a date. If the value cannot be converted to a date, $toDate errors. If the value is null or missing, $toDate returns null.\n *\n * @param obj\n * @param expr\n */\nconst $toDate = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if (val instanceof Date)\n        return val;\n    if ((0, util_1.isNil)(val))\n        return null;\n    const d = new Date(val);\n    const n = d.getTime();\n    if (!isNaN(n))\n        return d;\n    throw new _internal_1.TypeConvertError(`cannot convert '${val}' to date`);\n};\nexports.$toDate = $toDate;\n\n\n/***/ }),\n\n/***/ 9239:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toDecimal = void 0;\nconst toDouble_1 = __webpack_require__(1753);\n/**\n * Converts a value to a decimal. If the value cannot be converted to a decimal, $toDecimal errors.\n * If the value is null or missing, $toDecimal returns null.\n * This is just an alias for `$toDouble` in this library.\n */\nexports.$toDecimal = toDouble_1.$toDouble;\n\n\n/***/ }),\n\n/***/ 1753:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toDouble = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(1288);\n/**\n * Converts a value to a double. If the value cannot be converted to an double, $toDouble errors. If the value is null or missing, $toDouble returns null.\n *\n * @param obj\n * @param expr\n */\nconst $toDouble = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(val))\n        return null;\n    if (val instanceof Date)\n        return val.getTime();\n    if (val === true)\n        return 1;\n    if (val === false)\n        return 0;\n    const n = Number(val);\n    if ((0, util_1.isNumber)(n))\n        return n;\n    throw new _internal_1.TypeConvertError(`cannot convert '${val}' to double/decimal`);\n};\nexports.$toDouble = $toDouble;\n\n\n/***/ }),\n\n/***/ 3706:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toInt = void 0;\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(1288);\n/**\n * Converts a value to an integer. If the value cannot be converted to an integer, $toInt errors. If the value is null or missing, $toInt returns null.\n * @param obj\n * @param expr\n */\nconst $toInt = (obj, expr, options) => {\n    return (0, _internal_1.toInteger)(obj, expr, options, util_1.MAX_INT, util_1.MIN_INT, \"int\");\n};\nexports.$toInt = $toInt;\n\n\n/***/ }),\n\n/***/ 6488:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toLong = void 0;\nconst util_1 = __webpack_require__(7216);\nconst _internal_1 = __webpack_require__(1288);\n/**\n * Converts a value to a long. If the value cannot be converted to a long, $toLong errors. If the value is null or missing, $toLong returns null.\n * @param obj\n * @param expr\n */\nconst $toLong = (obj, expr, options) => {\n    return (0, _internal_1.toInteger)(obj, expr, options, util_1.MAX_LONG, util_1.MIN_LONG, \"long\");\n};\nexports.$toLong = $toLong;\n\n\n/***/ }),\n\n/***/ 6617:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$toString = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst dateToString_1 = __webpack_require__(1300);\nconst $toString = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    if ((0, util_1.isNil)(val))\n        return null;\n    if (val instanceof Date) {\n        const dateExpr = {\n            date: expr,\n            format: \"%Y-%m-%dT%H:%M:%S.%LZ\"\n        };\n        return (0, dateToString_1.$dateToString)(obj, dateExpr, options);\n    }\n    else {\n        return val.toString();\n    }\n};\nexports.$toString = $toString;\n\n\n/***/ }),\n\n/***/ 4446:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Type Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#type-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$type = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst $type = (obj, expr, options) => {\n    const val = (0, core_1.computeValue)(obj, expr, null, options);\n    const typename = (0, util_1.getType)(val);\n    const nativeType = typename.toLowerCase();\n    switch (nativeType) {\n        case \"boolean\":\n            return \"bool\";\n        case \"number\":\n            if (val.toString().indexOf(\".\") >= 0)\n                return \"double\";\n            return val >= util_1.MIN_INT && val <= util_1.MAX_INT ? \"int\" : \"long\";\n        case \"regexp\":\n            return \"regex\";\n        default:\n            return nativeType;\n    }\n};\nexports.$type = $type;\n\n\n/***/ }),\n\n/***/ 4354:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(9442), exports);\n\n\n/***/ }),\n\n/***/ 9442:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n/**\n * Variable Expression Operators: https://docs.mongodb.com/manual/reference/operator/aggregation/#variable-expression-operators\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$let = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Defines variables for use within the scope of a sub-expression and returns the result of the sub-expression.\n *\n * @param obj The target object for this expression\n * @param expr The right-hand side of the operator\n * @param options Options to use for this operattion\n * @returns {*}\n */\nconst $let = (obj, expr, options) => {\n    // resolve vars\n    const variables = {};\n    for (const [key, val] of Object.entries(expr.vars)) {\n        variables[key] = (0, core_1.computeValue)(obj, val, null, options);\n    }\n    return (0, core_1.computeValue)(obj, expr.in, null, core_1.ComputeOptions.init(options, obj, { variables }));\n};\nexports.$let = $let;\n\n\n/***/ }),\n\n/***/ 2899:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.isUnbounded = void 0;\n/** Checks whether the specified window is unbounded. */\nconst isUnbounded = (window) => {\n    const boundary = (window === null || window === void 0 ? void 0 : window.documents) || (window === null || window === void 0 ? void 0 : window.range);\n    return (!boundary || (boundary[0] === \"unbounded\" && boundary[1] === \"unbounded\"));\n};\nexports.isUnbounded = isUnbounded;\n\n\n/***/ }),\n\n/***/ 1692:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$addFields = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Adds new fields to documents.\n * Outputs documents that contain all existing fields from the input documents and newly added fields.\n *\n * @param {Iterator} collection\n * @param {Object} expr\n * @param {Options} options\n */\nconst $addFields = (collection, expr, options) => {\n    const newFields = Object.keys(expr);\n    if (newFields.length === 0)\n        return collection;\n    return collection.map(((obj) => {\n        const newObj = Object.assign({}, obj);\n        for (const field of newFields) {\n            const newValue = (0, core_1.computeValue)(obj, expr[field], null, options);\n            if (newValue !== undefined) {\n                (0, util_1.setValue)(newObj, field, newValue);\n            }\n            else {\n                (0, util_1.removeValue)(newObj, field);\n            }\n        }\n        return newObj;\n    }));\n};\nexports.$addFields = $addFields;\n\n\n/***/ }),\n\n/***/ 2985:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bucket = void 0;\nconst core_1 = __webpack_require__(9587);\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Categorizes incoming documents into groups, called buckets, based on a specified expression and bucket boundaries.\n * https://docs.mongodb.com/manual/reference/operator/aggregation/bucket/\n *\n * @param {*} collection\n * @param {*} expr\n * @param {Options} opt Pipeline options\n */\nconst $bucket = (collection, expr, options) => {\n    const boundaries = [...expr.boundaries];\n    const defaultKey = expr.default;\n    const lower = boundaries[0]; // inclusive\n    const upper = boundaries[boundaries.length - 1]; // exclusive\n    const outputExpr = expr.output || { count: { $sum: 1 } };\n    (0, util_1.assert)(expr.boundaries.length > 2, \"$bucket 'boundaries' expression must have at least 3 elements\");\n    const boundType = (0, util_1.getType)(lower);\n    for (let i = 0, len = boundaries.length - 1; i < len; i++) {\n        (0, util_1.assert)(boundType === (0, util_1.getType)(boundaries[i + 1]), \"$bucket 'boundaries' must all be of the same type\");\n        (0, util_1.assert)((0, util_1.compare)(boundaries[i], boundaries[i + 1]) < 0, \"$bucket 'boundaries' must be sorted in ascending order\");\n    }\n    !(0, util_1.isNil)(defaultKey) &&\n        (0, util_1.getType)(expr.default) === (0, util_1.getType)(lower) &&\n        (0, util_1.assert)((0, util_1.compare)(expr.default, upper) >= 0 || (0, util_1.compare)(expr.default, lower) < 0, \"$bucket 'default' expression must be out of boundaries range\");\n    const grouped = {};\n    for (const k of boundaries) {\n        grouped[k] = [];\n    }\n    // add default key if provided\n    if (!(0, util_1.isNil)(defaultKey))\n        grouped[defaultKey] = [];\n    let iterator;\n    return (0, lazy_1.Lazy)(() => {\n        if (!iterator) {\n            collection.each(((obj) => {\n                const key = (0, core_1.computeValue)(obj, expr.groupBy, null, options);\n                if ((0, util_1.isNil)(key) || (0, util_1.compare)(key, lower) < 0 || (0, util_1.compare)(key, upper) >= 0) {\n                    (0, util_1.assert)(!(0, util_1.isNil)(defaultKey), \"$bucket require a default for out of range values\");\n                    grouped[defaultKey].push(obj);\n                }\n                else {\n                    (0, util_1.assert)((0, util_1.compare)(key, lower) >= 0 && (0, util_1.compare)(key, upper) < 0, \"$bucket 'groupBy' expression must resolve to a value in range of boundaries\");\n                    const index = findInsertIndex(boundaries, key);\n                    const boundKey = boundaries[Math.max(0, index - 1)];\n                    grouped[boundKey].push(obj);\n                }\n            }));\n            // upper bound is exclusive so we remove it\n            boundaries.pop();\n            if (!(0, util_1.isNil)(defaultKey))\n                boundaries.push(defaultKey);\n            iterator = (0, lazy_1.Lazy)(boundaries).map(((key) => {\n                const acc = (0, core_1.computeValue)(grouped[key], outputExpr, null, options);\n                return (0, util_1.into)(acc, { _id: key });\n            }));\n        }\n        return iterator.next();\n    });\n};\nexports.$bucket = $bucket;\n/**\n * Find the insert index for the given key in a sorted array.\n *\n * @param {*} sorted The sorted array to search\n * @param {*} item The search key\n */\nfunction findInsertIndex(sorted, item) {\n    // uses binary search\n    let lo = 0;\n    let hi = sorted.length - 1;\n    while (lo <= hi) {\n        const mid = Math.round(lo + (hi - lo) / 2);\n        if ((0, util_1.compare)(item, sorted[mid]) < 0) {\n            hi = mid - 1;\n        }\n        else if ((0, util_1.compare)(item, sorted[mid]) > 0) {\n            lo = mid + 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return lo;\n}\n\n\n/***/ }),\n\n/***/ 8683:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bucketAuto = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Categorizes incoming documents into a specific number of groups, called buckets,\n * based on a specified expression. Bucket boundaries are automatically determined\n * in an attempt to evenly distribute the documents into the specified number of buckets.\n * https://docs.mongodb.com/manual/reference/operator/aggregation/bucketAuto/\n *\n * @param {*} collection\n * @param {*} expr\n * @param {*} options\n */\nconst $bucketAuto = (collection, expr, options) => {\n    const outputExpr = expr.output || { count: { $sum: 1 } };\n    const groupByExpr = expr.groupBy;\n    const bucketCount = expr.buckets;\n    (0, util_1.assert)(bucketCount > 0, `The $bucketAuto 'buckets' field must be greater than 0, but found: ${bucketCount}`);\n    const ID_KEY = \"_id\";\n    return collection.transform((coll) => {\n        const approxBucketSize = Math.max(1, Math.round(coll.length / bucketCount));\n        const computeValueOptimized = (0, util_1.memoize)(core_1.computeValue, options === null || options === void 0 ? void 0 : options.hashFunction);\n        const grouped = new Map();\n        const remaining = [];\n        const sorted = (0, util_1.sortBy)(coll, o => {\n            const key = computeValueOptimized(o, groupByExpr, null, options);\n            if ((0, util_1.isNil)(key)) {\n                remaining.push(o);\n            }\n            else {\n                if (!grouped.has(key))\n                    grouped.set(key, []);\n                grouped.get(key).push(o);\n            }\n            return key;\n        });\n        const result = [];\n        let index = 0; // counter for sorted collection\n        for (let i = 0, len = sorted.length; i < bucketCount && index < len; i++) {\n            const boundaries = {};\n            const bucketItems = [];\n            for (let j = 0; j < approxBucketSize && index < len; j++) {\n                let key = computeValueOptimized(sorted[index], groupByExpr, null, options);\n                if ((0, util_1.isNil)(key))\n                    key = null;\n                // populate current bucket with all values for current key\n                (0, util_1.into)(bucketItems, (0, util_1.isNil)(key) ? remaining : grouped.get(key));\n                // increase sort index by number of items added\n                index += (0, util_1.isNil)(key) ? remaining.length : grouped.get(key).length;\n                // set the min key boundary if not already present\n                if (!(0, util_1.has)(boundaries, \"min\"))\n                    boundaries.min = key;\n                if (result.length > 0) {\n                    const lastBucket = result[result.length - 1];\n                    lastBucket[ID_KEY].max = boundaries.min;\n                }\n            }\n            // if is last bucket add remaining items\n            if (i == bucketCount - 1) {\n                (0, util_1.into)(bucketItems, sorted.slice(index));\n            }\n            const values = (0, core_1.computeValue)(bucketItems, outputExpr, null, options);\n            result.push((0, util_1.into)(values, {\n                _id: boundaries\n            }));\n        }\n        if (result.length > 0) {\n            result[result.length - 1][ID_KEY].max =\n                computeValueOptimized(sorted[sorted.length - 1], groupByExpr, null, options);\n        }\n        return result;\n    });\n};\nexports.$bucketAuto = $bucketAuto;\n\n\n/***/ }),\n\n/***/ 8980:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$count = void 0;\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Returns a document that contains a count of the number of documents input to the stage.\n *\n * @param {Array} collection\n * @param {String} expr\n * @param {Options} options\n * @return {Object}\n */\nconst $count = (collection, expr, _) => {\n    (0, util_1.assert)((0, util_1.isString)(expr) &&\n        expr.trim() !== \"\" &&\n        expr.indexOf(\".\") === -1 &&\n        expr.trim()[0] !== \"$\", \"Invalid expression value for $count\");\n    return (0, lazy_1.Lazy)([\n        {\n            [expr]: collection.size()\n        }\n    ]);\n};\nexports.$count = $count;\n\n\n/***/ }),\n\n/***/ 10:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$facet = void 0;\nconst aggregator_1 = __webpack_require__(7268);\nconst core_1 = __webpack_require__(9587);\n/**\n * Processes multiple aggregation pipelines within a single stage on the same set of input documents.\n * Enables the creation of multi-faceted aggregations capable of characterizing data across multiple dimensions, or facets, in a single stage.\n */\nconst $facet = (collection, expr, options) => {\n    return collection.transform(((array) => {\n        const o = {};\n        for (const [k, pipeline] of Object.entries(expr)) {\n            o[k] = new aggregator_1.Aggregator(pipeline, Object.assign(Object.assign({}, options), { processingMode: core_1.ProcessingMode.CLONE_INPUT })).run(array);\n        }\n        return [o];\n    }));\n};\nexports.$facet = $facet;\n\n\n/***/ }),\n\n/***/ 3090:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$fill = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst ifNull_1 = __webpack_require__(419);\nconst linearFill_1 = __webpack_require__(5120);\nconst locf_1 = __webpack_require__(8242);\nconst addFields_1 = __webpack_require__(1692);\nconst setWindowFields_1 = __webpack_require__(8515);\nconst FILL_METHODS = {\n    locf: \"$locf\",\n    linear: \"$linearFill\"\n};\n/**\n * Populates null and missing field values within documents.\n *\n * @param {Iterator} collection\n * @param {Object} expr\n * @param {Options} options\n */\nconst $fill = (collection, expr, options) => {\n    var _a, _b;\n    (0, util_1.assert)(!expr.sortBy || (0, util_1.isObject)(expr.sortBy), \"sortBy must be an object.\");\n    (0, util_1.assert)(!!expr.sortBy || Object.values(expr.output).every(m => (0, util_1.has)(m, \"value\")), \"sortBy required if any output field specifies a 'method'.\");\n    (0, util_1.assert)(!(expr.partitionBy && expr.partitionByFields), \"specify either partitionBy or partitionByFields.\");\n    (0, util_1.assert)(!expr.partitionByFields ||\n        ((_a = expr === null || expr === void 0 ? void 0 : expr.partitionByFields) === null || _a === void 0 ? void 0 : _a.every(s => s[0] !== \"$\")), \"fields in partitionByFields cannot begin with '$'.\");\n    options = (0, core_1.initOptions)(options);\n    options.context.addExpressionOps({ $ifNull: ifNull_1.$ifNull });\n    options.context.addWindowOps({ $locf: locf_1.$locf, $linearFill: linearFill_1.$linearFill });\n    const partitionExpr = expr.partitionBy || ((_b = expr === null || expr === void 0 ? void 0 : expr.partitionByFields) === null || _b === void 0 ? void 0 : _b.map(s => `$${s}`));\n    // collect and remove all output fields using 'value' instead of 'method'.\n    // if there are any fields remaining, process collection using $setWindowFields.\n    // if the collected output fields is non-empty, use $addFields to add them to their respective partitions.\n    const valueExpr = {};\n    const methodExpr = {};\n    for (const [k, m] of Object.entries(expr.output)) {\n        if ((0, util_1.has)(m, \"value\")) {\n            // translate to expression for $addFields\n            valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m[\"value\"]] };\n        }\n        else {\n            // translate to output expression for $setWindowFields.\n            const fillOp = FILL_METHODS[m[\"method\"]];\n            (0, util_1.assert)(!!fillOp, `invalid fill method '${m[\"method\"]}'.`);\n            methodExpr[k] = { [fillOp]: \"$\" + k };\n        }\n    }\n    // perform filling with $setWindowFields\n    if (Object.keys(methodExpr).length > 0) {\n        collection = (0, setWindowFields_1.$setWindowFields)(collection, {\n            sortBy: expr.sortBy || {},\n            partitionBy: partitionExpr,\n            output: methodExpr\n        }, options);\n    }\n    // fill with values\n    if (Object.keys(valueExpr).length > 0) {\n        collection = (0, addFields_1.$addFields)(collection, valueExpr, options);\n    }\n    return collection;\n};\nexports.$fill = $fill;\n\n\n/***/ }),\n\n/***/ 2683:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$group = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n// lookup key for grouping\nconst ID_KEY = \"_id\";\n/**\n * Groups documents together for the purpose of calculating aggregate values based on a collection of documents.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {Array}\n */\nconst $group = (collection, expr, options) => {\n    (0, util_1.assert)((0, util_1.has)(expr, ID_KEY), \"a group specification must include an _id\");\n    const idExpr = expr[ID_KEY];\n    const copts = core_1.ComputeOptions.init(options);\n    return collection.transform(((coll) => {\n        const partitions = (0, util_1.groupBy)(coll, obj => (0, core_1.computeValue)(obj, idExpr, null, options), options.hashFunction);\n        // remove the group key\n        expr = Object.assign({}, expr);\n        delete expr[ID_KEY];\n        let i = -1;\n        const partitionKeys = Array.from(partitions.keys());\n        const size = partitions.size;\n        return () => {\n            if (++i === size)\n                return { done: true };\n            const groupId = partitionKeys[i];\n            const obj = {};\n            // exclude undefined key value\n            if (groupId !== undefined) {\n                obj[ID_KEY] = groupId;\n            }\n            // compute remaining keys in expression\n            for (const [key, val] of Object.entries(expr)) {\n                obj[key] = (0, core_1.computeValue)(partitions.get(groupId), val, key, copts.update(null, { groupId }));\n            }\n            return { value: obj, done: false };\n        };\n    }));\n};\nexports.$group = $group;\n\n\n/***/ }),\n\n/***/ 6582:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\n/**\n * Pipeline Aggregation Stages. https://docs.mongodb.com/manual/reference/operator/aggregation-\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(1692), exports);\n__exportStar(__webpack_require__(2985), exports);\n__exportStar(__webpack_require__(8683), exports);\n__exportStar(__webpack_require__(8980), exports);\n__exportStar(__webpack_require__(10), exports);\n__exportStar(__webpack_require__(3090), exports);\n__exportStar(__webpack_require__(2683), exports);\n__exportStar(__webpack_require__(9749), exports);\n__exportStar(__webpack_require__(954), exports);\n__exportStar(__webpack_require__(9157), exports);\n__exportStar(__webpack_require__(159), exports);\n__exportStar(__webpack_require__(6212), exports);\n__exportStar(__webpack_require__(7911), exports);\n__exportStar(__webpack_require__(6402), exports);\n__exportStar(__webpack_require__(6366), exports);\n__exportStar(__webpack_require__(8755), exports);\n__exportStar(__webpack_require__(8027), exports);\n__exportStar(__webpack_require__(4707), exports);\n__exportStar(__webpack_require__(8515), exports);\n__exportStar(__webpack_require__(8377), exports);\n__exportStar(__webpack_require__(5396), exports);\n__exportStar(__webpack_require__(2311), exports);\n__exportStar(__webpack_require__(1655), exports);\n__exportStar(__webpack_require__(3871), exports);\n__exportStar(__webpack_require__(9789), exports);\n\n\n/***/ }),\n\n/***/ 9749:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$limit = void 0;\n/**\n * Restricts the number of documents in an aggregation pipeline.\n *\n * @param collection\n * @param value\n * @param options\n * @returns {Object|*}\n */\nconst $limit = (collection, expr, options) => {\n    return collection.take(expr);\n};\nexports.$limit = $limit;\n\n\n/***/ }),\n\n/***/ 954:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lookup = void 0;\nconst util_1 = __webpack_require__(7216);\n/**\n * Performs a left outer join to another collection in the same database to filter in documents from the “joined” collection for processing.\n *\n * @param collection\n * @param expr\n * @param opt\n */\nconst $lookup = (collection, expr, options) => {\n    const joinColl = (0, util_1.isString)(expr.from)\n        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr.from)\n        : expr.from;\n    (0, util_1.assert)(joinColl instanceof Array, `'from' field must resolve to an array`);\n    const hash = {};\n    for (const obj of joinColl) {\n        const k = (0, util_1.hashCode)((0, util_1.resolve)(obj, expr.foreignField), options === null || options === void 0 ? void 0 : options.hashFunction);\n        hash[k] = hash[k] || [];\n        hash[k].push(obj);\n    }\n    return collection.map((obj) => {\n        const k = (0, util_1.hashCode)((0, util_1.resolve)(obj, expr.localField), options === null || options === void 0 ? void 0 : options.hashFunction);\n        const newObj = (0, util_1.into)({}, obj);\n        newObj[expr.as] = hash[k] || [];\n        return newObj;\n    });\n};\nexports.$lookup = $lookup;\n\n\n/***/ }),\n\n/***/ 9157:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$match = void 0;\nconst query_1 = __webpack_require__(809);\n/**\n * Filters the document stream, and only allows matching documents to pass into the next pipeline stage.\n * $match uses standard MongoDB queries.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {Array|*}\n */\nconst $match = (collection, expr, options) => {\n    const q = new query_1.Query(expr, options);\n    return collection.filter((o) => q.test(o));\n};\nexports.$match = $match;\n\n\n/***/ }),\n\n/***/ 159:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$merge = void 0;\nconst aggregator_1 = __webpack_require__(7268);\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\nconst expression_1 = __webpack_require__(8985);\n/**\n * Writes the resulting documents of the aggregation pipeline to a collection.\n *\n * The stage can incorporate (insert new documents, merge documents, replace documents,\n * keep existing documents, fail the operation, process documents with a custom update pipeline)\n * the results into an output collection. To use the $merge stage, it must be the last stage in the pipeline.\n *\n * Note: Object are deep cloned for outputing regardless of the ProcessingMode.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {*}\n */\nconst $merge = (collection, expr, options) => {\n    const output = (0, util_1.isString)(expr.into)\n        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr.into)\n        : expr.into;\n    (0, util_1.assert)(output instanceof Array, `$merge: option 'into' must resolve to an array`);\n    const onField = expr.on || options.idKey;\n    const getHash = (o) => {\n        const val = (0, util_1.isString)(onField)\n            ? (0, util_1.resolve)(o, onField)\n            : onField.map(s => (0, util_1.resolve)(o, s));\n        return (0, util_1.hashCode)(val, options.hashFunction);\n    };\n    const hash = {};\n    // we assuming the lookup expressions are unique\n    for (let i = 0; i < output.length; i++) {\n        const obj = output[i];\n        const k = getHash(obj);\n        (0, util_1.assert)(!hash[k], \"$merge: 'into' collection must have unique entries for the 'on' field.\");\n        hash[k] = [obj, i];\n    }\n    const copts = core_1.ComputeOptions.init(options);\n    return collection.map((o) => {\n        const k = getHash(o);\n        if (hash[k]) {\n            const [target, i] = hash[k];\n            // compute variables\n            const variables = (0, core_1.computeValue)(target, expr.let || { new: \"$$ROOT\" }, null, \n            // 'root' is the item from the iteration.\n            copts.update(o));\n            if ((0, util_1.isArray)(expr.whenMatched)) {\n                const aggregator = new aggregator_1.Aggregator(expr.whenMatched, Object.assign(Object.assign({}, options), { variables }));\n                output[i] = aggregator.run([target])[0];\n            }\n            else {\n                switch (expr.whenMatched) {\n                    case \"replace\":\n                        output[i] = o;\n                        break;\n                    case \"fail\":\n                        throw new Error(\"$merge: failed due to matching as specified by 'whenMatched' option.\");\n                    case \"keepExisting\":\n                        break;\n                    case \"merge\":\n                    default:\n                        output[i] = (0, expression_1.$mergeObjects)(target, [target, o], \n                        // 'root' is the item from the iteration.\n                        copts.update(o, { variables }));\n                        break;\n                }\n            }\n        }\n        else {\n            switch (expr.whenNotMatched) {\n                case \"discard\":\n                    break;\n                case \"fail\":\n                    throw new Error(\"$merge: failed due to matching as specified by 'whenMatched' option.\");\n                case \"insert\":\n                default:\n                    output.push(o);\n                    break;\n            }\n        }\n        return o; // passthrough\n    });\n};\nexports.$merge = $merge;\n\n\n/***/ }),\n\n/***/ 6212:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$out = void 0;\nconst util_1 = __webpack_require__(7216);\n/**\n * Takes the documents returned by the aggregation pipeline and writes them to a specified collection.\n *\n * Unlike the $out operator in MongoDB, this operator can appear in any position in the pipeline and is\n * useful for collecting intermediate results of an aggregation operation.\n *\n * Note: Object are deep cloned for outputing regardless of the ProcessingMode.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {*}\n */\nconst $out = (collection, expr, options) => {\n    const outputColl = (0, util_1.isString)(expr)\n        ? options === null || options === void 0 ? void 0 : options.collectionResolver(expr)\n        : expr;\n    (0, util_1.assert)(outputColl instanceof Array, `expression must resolve to an array`);\n    return collection.map((o) => {\n        outputColl.push((0, util_1.cloneDeep)(o));\n        return o; // passthrough\n    });\n};\nexports.$out = $out;\n\n\n/***/ }),\n\n/***/ 7911:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$project = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Reshapes a document stream.\n * $project can rename, add, or remove fields as well as create computed values and sub-documents.\n *\n * @param collection\n * @param expr\n * @param opt\n * @returns {Array}\n */\nconst $project = (collection, expr, options) => {\n    if ((0, util_1.isEmpty)(expr))\n        return collection;\n    // result collection\n    let expressionKeys = Object.keys(expr);\n    let idOnlyExcluded = false;\n    // validate inclusion and exclusion\n    validateExpression(expr, options);\n    const ID_KEY = options.idKey;\n    if ((0, util_1.inArray)(expressionKeys, ID_KEY)) {\n        const id = expr[ID_KEY];\n        if (id === 0 || id === false) {\n            expressionKeys = expressionKeys.filter(util_1.notInArray.bind(null, [ID_KEY]));\n            idOnlyExcluded = expressionKeys.length == 0;\n        }\n    }\n    else {\n        // if not specified the add the ID field\n        expressionKeys.push(ID_KEY);\n    }\n    const copts = core_1.ComputeOptions.init(options);\n    return collection.map(((obj) => processObject(obj, expr, copts.update(obj), expressionKeys, idOnlyExcluded)));\n};\nexports.$project = $project;\n/**\n * Process the expression value for $project operators\n *\n * @param {Object} obj The object to use as options\n * @param {Object} expr The experssion object of $project operator\n * @param {Array} expressionKeys The key in the 'expr' object\n * @param {Boolean} idOnlyExcluded Boolean value indicating whether only the ID key is excluded\n */\nfunction processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {\n    let newObj = {};\n    let foundSlice = false;\n    let foundExclusion = false;\n    const dropKeys = [];\n    if (idOnlyExcluded) {\n        dropKeys.push(options.idKey);\n    }\n    for (const key of expressionKeys) {\n        // final computed value of the key\n        let value = undefined;\n        // expression to associate with key\n        const subExpr = expr[key];\n        if (key !== options.idKey && (0, util_1.inArray)([0, false], subExpr)) {\n            foundExclusion = true;\n        }\n        if (key === options.idKey && (0, util_1.isEmpty)(subExpr)) {\n            // tiny optimization here to skip over id\n            value = obj[key];\n        }\n        else if ((0, util_1.isString)(subExpr)) {\n            value = (0, core_1.computeValue)(obj, subExpr, key, options);\n        }\n        else if ((0, util_1.inArray)([1, true], subExpr)) {\n            // For direct projections, we use the resolved object value\n        }\n        else if (subExpr instanceof Array) {\n            value = subExpr.map(v => {\n                const r = (0, core_1.computeValue)(obj, v, null, options);\n                if ((0, util_1.isNil)(r))\n                    return null;\n                return r;\n            });\n        }\n        else if ((0, util_1.isObject)(subExpr)) {\n            const subExprObj = subExpr;\n            const subExprKeys = Object.keys(subExpr);\n            const operator = subExprKeys.length == 1 ? subExprKeys[0] : \"\";\n            // first try a projection operator\n            const call = (0, core_1.getOperator)(core_1.OperatorType.PROJECTION, operator, options);\n            if (call) {\n                // apply the projection operator on the operator expression for the key\n                if (operator === \"$slice\") {\n                    // $slice is handled differently for aggregation and projection operations\n                    if ((0, util_1.ensureArray)(subExprObj[operator]).every(util_1.isNumber)) {\n                        // $slice for projection operation\n                        value = call(obj, subExprObj[operator], key, options);\n                        foundSlice = true;\n                    }\n                    else {\n                        // $slice for aggregation operation\n                        value = (0, core_1.computeValue)(obj, subExprObj, key, options);\n                    }\n                }\n                else {\n                    value = call(obj, subExprObj[operator], key, options);\n                }\n            }\n            else if ((0, util_1.isOperator)(operator)) {\n                // compute if operator key\n                value = (0, core_1.computeValue)(obj, subExprObj[operator], operator, options);\n            }\n            else if ((0, util_1.has)(obj, key)) {\n                // compute the value for the sub expression for the key\n                validateExpression(subExprObj, options);\n                let target = obj[key];\n                if (target instanceof Array) {\n                    value = target.map((o) => processObject(o, subExprObj, options, subExprKeys, false));\n                }\n                else {\n                    target = (0, util_1.isObject)(target) ? target : obj;\n                    value = processObject(target, subExprObj, options, subExprKeys, false);\n                }\n            }\n            else {\n                // compute the value for the sub expression for the key\n                value = (0, core_1.computeValue)(obj, subExpr, null, options);\n            }\n        }\n        else {\n            dropKeys.push(key);\n            continue;\n        }\n        // get value with object graph\n        const objPathGraph = (0, util_1.resolveGraph)(obj, key, {\n            preserveMissing: true\n        });\n        // add the value at the path\n        if (objPathGraph !== undefined) {\n            (0, util_1.merge)(newObj, objPathGraph, {\n                flatten: true\n            });\n        }\n        // if computed add/or remove accordingly\n        if ((0, util_1.notInArray)([0, 1, false, true], subExpr)) {\n            if (value === undefined) {\n                (0, util_1.removeValue)(newObj, key, { descendArray: true });\n            }\n            else {\n                (0, util_1.setValue)(newObj, key, value);\n            }\n        }\n    }\n    // filter out all missing values preserved to support correct merging\n    (0, util_1.filterMissing)(newObj);\n    // For the following cases we include all keys on the object that were not explicitly excluded.\n    //\n    // 1. projection included $slice operator\n    // 2. some fields were explicitly excluded\n    // 3. only the id field was excluded\n    if (foundSlice || foundExclusion || idOnlyExcluded) {\n        newObj = (0, util_1.into)({}, obj, newObj);\n        if (dropKeys.length > 0) {\n            for (const k of dropKeys) {\n                (0, util_1.removeValue)(newObj, k, { descendArray: true });\n            }\n        }\n    }\n    return newObj;\n}\n/**\n * Validate inclusion and exclusion values in expression\n *\n * @param {Object} expr The expression given for the projection\n */\nfunction validateExpression(expr, options) {\n    const check = [false, false];\n    for (const [k, v] of Object.entries(expr)) {\n        if (k === (options === null || options === void 0 ? void 0 : options.idKey))\n            return;\n        if (v === 0 || v === false) {\n            check[0] = true;\n        }\n        else if (v === 1 || v === true) {\n            check[1] = true;\n        }\n        (0, util_1.assert)(!(check[0] && check[1]), \"Projection cannot have a mix of inclusion and exclusion.\");\n    }\n}\n\n\n/***/ }),\n\n/***/ 6402:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$redact = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Restricts the contents of the documents based on information stored in the documents themselves.\n *\n * https://docs.mongodb.com/manual/reference/operator/aggregation/redact/\n */\nconst $redact = (collection, expr, options) => {\n    const copts = core_1.ComputeOptions.init(options);\n    return collection.map(((obj) => (0, core_1.redact)(obj, expr, copts.update(obj))));\n};\nexports.$redact = $redact;\n\n\n/***/ }),\n\n/***/ 6366:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$replaceRoot = void 0;\nconst core_1 = __webpack_require__(9587);\nconst util_1 = __webpack_require__(7216);\n/**\n * Replaces a document with the specified embedded document or new one.\n * The replacement document can be any valid expression that resolves to a document.\n *\n * https://docs.mongodb.com/manual/reference/operator/aggregation/replaceRoot/\n *\n * @param  {Iterator} collection\n * @param  {Object} expr\n * @param  {Object} options\n * @return {*}\n */\nconst $replaceRoot = (collection, expr, options) => {\n    return collection.map(obj => {\n        obj = (0, core_1.computeValue)(obj, expr.newRoot, null, options);\n        (0, util_1.assert)((0, util_1.isObject)(obj), \"$replaceRoot expression must return an object\");\n        return obj;\n    });\n};\nexports.$replaceRoot = $replaceRoot;\n\n\n/***/ }),\n\n/***/ 8755:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$replaceWith = void 0;\nconst replaceRoot_1 = __webpack_require__(6366);\n/**\n * Alias for $replaceRoot\n */\nexports.$replaceWith = replaceRoot_1.$replaceRoot;\n\n\n/***/ }),\n\n/***/ 8027:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// $sample operator -  https://docs.mongodb.com/manual/reference/operator/aggregation/sample/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sample = void 0;\n/**\n * Randomly selects the specified number of documents from its input. The given iterator must have finite values\n *\n * @param  {Iterator} collection\n * @param  {Object} expr\n * @param  {Options} _options\n * @return {*}\n */\nconst $sample = (collection, expr, _options) => {\n    return collection.transform(((xs) => {\n        const len = xs.length;\n        let i = -1;\n        return () => {\n            if (++i === expr.size)\n                return { done: true };\n            const n = Math.floor(Math.random() * len);\n            return { value: xs[n], done: false };\n        };\n    }));\n};\nexports.$sample = $sample;\n\n\n/***/ }),\n\n/***/ 4707:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$set = void 0;\nconst addFields_1 = __webpack_require__(1692);\n/**\n * Alias for $addFields.\n */\nexports.$set = addFields_1.$addFields;\n\n\n/***/ }),\n\n/***/ 8515:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// $setWindowFields -  https://docs.mongodb.com/manual/reference/operator/aggregation/setWindowFields/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$setWindowFields = void 0;\nconst core_1 = __webpack_require__(9587);\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\nconst expression_1 = __webpack_require__(8985);\nconst dateAdd_1 = __webpack_require__(9784);\nconst _internal_1 = __webpack_require__(2899);\nconst addFields_1 = __webpack_require__(1692);\nconst group_1 = __webpack_require__(2683);\nconst sort_1 = __webpack_require__(5396);\n// Operators that require 'sortBy' option.\nconst SORT_REQUIRED_OPS = new Set([\n    \"$denseRank\",\n    \"$documentNumber\",\n    \"$first\",\n    \"$last\",\n    \"$linearFill\",\n    \"$rank\",\n    \"$shift\"\n]);\n// Operators that require unbounded 'window' option.\nconst WINDOW_UNBOUNDED_OPS = new Set([\n    \"$denseRank\",\n    \"$expMovingAvg\",\n    \"$linearFill\",\n    \"$locf\",\n    \"$rank\",\n    \"$shift\"\n]);\n/**\n * Randomly selects the specified number of documents from its input. The given iterator must have finite values\n *\n * @param  {Iterator} collection\n * @param  {Object} expr\n * @param  {Options} options\n * @return {*}\n */\nconst $setWindowFields = (collection, expr, options) => {\n    options = (0, core_1.initOptions)(options);\n    options.context.addExpressionOps({ $function: expression_1.$function });\n    // validate inputs early since this can be an expensive operation.\n    for (const outputExpr of Object.values(expr.output)) {\n        const keys = Object.keys(outputExpr);\n        const op = keys.find(util_1.isOperator);\n        (0, util_1.assert)(!!(0, core_1.getOperator)(core_1.OperatorType.WINDOW, op, options) ||\n            !!(0, core_1.getOperator)(core_1.OperatorType.ACCUMULATOR, op, options), `'${op}' is not a valid window operator`);\n        (0, util_1.assert)(keys.length > 0 &&\n            keys.length <= 2 &&\n            (keys.length == 1 || keys.includes(\"window\")), \"'output' option should have a single window operator.\");\n        if (outputExpr === null || outputExpr === void 0 ? void 0 : outputExpr.window) {\n            const { documents, range } = outputExpr.window;\n            (0, util_1.assert)((!!documents && !range) ||\n                (!documents && !!range) ||\n                (!documents && !range), \"'window' option supports only one of 'documents' or 'range'.\");\n        }\n    }\n    // we sort first if required\n    if (expr.sortBy) {\n        collection = (0, sort_1.$sort)(collection, expr.sortBy, options);\n    }\n    // then partition collection\n    collection = (0, group_1.$group)(collection, {\n        _id: expr.partitionBy,\n        items: { $push: \"$$CURRENT\" }\n    }, options);\n    // transform values\n    return collection.transform(((partitions) => {\n        // let iteratorIndex = 0;\n        const iterators = [];\n        const outputConfig = [];\n        for (const [field, outputExpr] of Object.entries(expr.output)) {\n            const op = Object.keys(outputExpr).find(util_1.isOperator);\n            const config = {\n                operatorName: op,\n                func: {\n                    left: (0, core_1.getOperator)(core_1.OperatorType.ACCUMULATOR, op, options),\n                    right: (0, core_1.getOperator)(core_1.OperatorType.WINDOW, op, options)\n                },\n                args: outputExpr[op],\n                field: field,\n                window: outputExpr.window\n            };\n            // sortBy option required for specific operators or bounded window.\n            (0, util_1.assert)(!!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window), `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : \"bounded window operation\"} requires a sortBy.`);\n            // window must be unbounded for specific operators.\n            (0, util_1.assert)(!config.window || !WINDOW_UNBOUNDED_OPS.has(op), `${op} does not accept a 'window' field.`);\n            outputConfig.push(config);\n        }\n        // each parition maintains its own closure to process the documents in the window.\n        partitions.forEach(((group) => {\n            // get the items to process\n            const items = group.items;\n            // create an iterator per group.\n            // we need the index of each document so we track it using a special field.\n            let iterator = (0, lazy_1.Lazy)(items);\n            // results map\n            const windowResultMap = {};\n            for (const config of outputConfig) {\n                const { func, args, field, window } = config;\n                const makeResultFunc = (getItemsFn) => {\n                    // closure for object index within the partition\n                    let index = -1;\n                    return (obj) => {\n                        ++index;\n                        // process accumulator function\n                        if (func.left) {\n                            return func.left(getItemsFn(obj, index), args, options);\n                        }\n                        else if (func.right) {\n                            // OR process 'window' function\n                            return func.right(obj, getItemsFn(obj, index), {\n                                parentExpr: expr,\n                                inputExpr: args,\n                                documentNumber: index + 1,\n                                field\n                            }, \n                            // must use raw options only since it operates over a collection.\n                            options);\n                        }\n                    };\n                };\n                if (window) {\n                    const { documents, range, unit } = window;\n                    // TODO: fix the meaning of numeric values in range.\n                    //  See definition: https://www.mongodb.com/docs/manual/reference/operator/aggregation/setWindowFields/#std-label-setWindowFields-range\n                    //  - A number to add to the value of the sortBy field for the current document.\n                    //  - A document is in the window if the sortBy field value is inclusively within the lower and upper boundaries.\n                    // TODO: Need to reconcile the two above statments from the doc to implement 'range' option correctly.\n                    const boundary = documents || range;\n                    if (!(0, _internal_1.isUnbounded)(window)) {\n                        const [begin, end] = boundary;\n                        const toBeginIndex = (currentIndex) => {\n                            if (begin == \"current\")\n                                return currentIndex;\n                            if (begin == \"unbounded\")\n                                return 0;\n                            return Math.max(begin + currentIndex, 0);\n                        };\n                        const toEndIndex = (currentIndex) => {\n                            if (end == \"current\")\n                                return currentIndex + 1;\n                            if (end == \"unbounded\")\n                                return items.length;\n                            return end + currentIndex + 1;\n                        };\n                        const getItems = (current, index) => {\n                            // handle string boundaries or documents\n                            if (!!documents || boundary.every(util_1.isString)) {\n                                return items.slice(toBeginIndex(index), toEndIndex(index));\n                            }\n                            // handle range with numeric boundary values\n                            const sortKey = Object.keys(expr.sortBy)[0];\n                            let lower;\n                            let upper;\n                            if (unit) {\n                                // we are dealing with datetimes\n                                const getTime = (amount) => {\n                                    return (0, dateAdd_1.$dateAdd)(current, {\n                                        startDate: new Date(current[sortKey]),\n                                        unit,\n                                        amount\n                                    }, options).getTime();\n                                };\n                                lower = (0, util_1.isNumber)(begin) ? getTime(begin) : -Infinity;\n                                upper = (0, util_1.isNumber)(end) ? getTime(end) : Infinity;\n                            }\n                            else {\n                                const currentValue = current[sortKey];\n                                lower = (0, util_1.isNumber)(begin) ? currentValue + begin : -Infinity;\n                                upper = (0, util_1.isNumber)(end) ? currentValue + end : Infinity;\n                            }\n                            let array = items;\n                            if (begin == \"current\")\n                                array = items.slice(index);\n                            if (end == \"current\")\n                                array = items.slice(0, index + 1);\n                            // look within the boundary and filter down\n                            return array.filter((o) => {\n                                const value = o[sortKey];\n                                const n = +value;\n                                return n >= lower && n <= upper;\n                            });\n                        };\n                        windowResultMap[field] = makeResultFunc(getItems);\n                    }\n                }\n                // default action is to utilize the entire set of items\n                if (!windowResultMap[field]) {\n                    windowResultMap[field] = makeResultFunc(_ => items);\n                }\n                // invoke add fields to get the desired behaviour using a custom function.\n                iterator = (0, addFields_1.$addFields)(iterator, {\n                    [field]: {\n                        $function: {\n                            body: (obj) => windowResultMap[field](obj),\n                            args: [\"$$CURRENT\"]\n                        }\n                    }\n                }, options);\n            }\n            // add to iterator list\n            iterators.push(iterator);\n        }));\n        return (0, lazy_1.compose)(...iterators);\n    }));\n};\nexports.$setWindowFields = $setWindowFields;\n\n\n/***/ }),\n\n/***/ 8377:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$skip = void 0;\n/**\n * Skips over a specified number of documents from the pipeline and returns the rest.\n *\n * @param collection An iterator\n * @param expr\n * @param  {Options} options\n * @returns {*}\n */\nconst $skip = (collection, expr, options) => {\n    return collection.drop(expr);\n};\nexports.$skip = $skip;\n\n\n/***/ }),\n\n/***/ 5396:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sort = void 0;\nconst util_1 = __webpack_require__(7216);\n/**\n * Takes all input documents and returns them in a stream of sorted documents.\n *\n * @param collection\n * @param sortKeys\n * @param  {Object} options\n * @returns {*}\n */\nconst $sort = (collection, sortKeys, options) => {\n    if ((0, util_1.isEmpty)(sortKeys) || !(0, util_1.isObject)(sortKeys))\n        return collection;\n    let cmp = util_1.compare;\n    // check for collation spec on the options\n    const collationSpec = options.collation;\n    // use collation comparator if provided\n    if ((0, util_1.isObject)(collationSpec) && (0, util_1.isString)(collationSpec.locale)) {\n        cmp = collationComparator(collationSpec);\n    }\n    return collection.transform((coll) => {\n        const modifiers = Object.keys(sortKeys);\n        for (const key of modifiers.reverse()) {\n            const groups = (0, util_1.groupBy)(coll, (obj) => (0, util_1.resolve)(obj, key), options.hashFunction);\n            const sortedKeys = Array.from(groups.keys()).sort(cmp);\n            if (sortKeys[key] === -1)\n                sortedKeys.reverse();\n            // reuse collection so the data is available for the next iteration of the sort modifiers.\n            coll = [];\n            sortedKeys.reduce((acc, key) => (0, util_1.into)(acc, groups.get(key)), coll);\n        }\n        return coll;\n    });\n};\nexports.$sort = $sort;\n// MongoDB collation strength to JS localeCompare sensitivity mapping.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\nconst COLLATION_STRENGTH = {\n    // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.\n    1: \"base\",\n    //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.\n    // Examples: a ≠ b, a ≠ á, a = A.\n    2: \"accent\",\n    // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.\n    // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A\n    3: \"variant\"\n    // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.\n};\n/**\n * Creates a comparator function for the given collation spec. See https://docs.mongodb.com/manual/reference/collation/\n *\n * @param spec {Object} The MongoDB collation spec.\n * {\n *   locale: string,\n *   caseLevel: boolean,\n *   caseFirst: string,\n *   strength: int,\n *   numericOrdering: boolean,\n *   alternate: string,\n *   maxVariable: string, // unsupported\n *   backwards: boolean // unsupported\n * }\n */\nfunction collationComparator(spec) {\n    const localeOpt = {\n        sensitivity: COLLATION_STRENGTH[spec.strength || 3],\n        caseFirst: spec.caseFirst === \"off\" ? \"false\" : spec.caseFirst || \"false\",\n        numeric: spec.numericOrdering || false,\n        ignorePunctuation: spec.alternate === \"shifted\"\n    };\n    // when caseLevel is true for strength  1:base and 2:accent, bump sensitivity to the nearest that supports case comparison\n    if ((spec.caseLevel || false) === true) {\n        if (localeOpt.sensitivity === \"base\")\n            localeOpt.sensitivity = \"case\";\n        if (localeOpt.sensitivity === \"accent\")\n            localeOpt.sensitivity = \"variant\";\n    }\n    const collator = new Intl.Collator(spec.locale, localeOpt);\n    return (a, b) => {\n        // non strings\n        if (!(0, util_1.isString)(a) || !(0, util_1.isString)(b))\n            return (0, util_1.compare)(a, b);\n        // only for strings\n        const i = collator.compare(a, b);\n        if (i < 0)\n            return -1;\n        if (i > 0)\n            return 1;\n        return 0;\n    };\n}\n\n\n/***/ }),\n\n/***/ 2311:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$sortByCount = void 0;\nconst group_1 = __webpack_require__(2683);\nconst sort_1 = __webpack_require__(5396);\n/**\n * Groups incoming documents based on the value of a specified expression,\n * then computes the count of documents in each distinct group.\n *\n * https://docs.mongodb.com/manual/reference/operator/aggregation/sortByCount/\n *\n * @param  {Array} collection\n * @param  {Object} expr\n * @param  {Object} options\n * @return {*}\n */\nconst $sortByCount = (collection, expr, options) => {\n    const newExpr = { count: { $sum: 1 } };\n    newExpr[\"_id\"] = expr;\n    return (0, sort_1.$sort)((0, group_1.$group)(collection, newExpr, options), { count: -1 }, options);\n};\nexports.$sortByCount = $sortByCount;\n\n\n/***/ }),\n\n/***/ 1655:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$unionWith = void 0;\nconst aggregator_1 = __webpack_require__(7268);\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Performs a union of two collections.\n *\n * @param collection\n * @param expr\n * @param opt\n */\nconst $unionWith = (collection, expr, options) => {\n    const array = (0, util_1.isString)(expr.coll)\n        ? options.collectionResolver(expr.coll)\n        : expr.coll;\n    const iterators = [collection];\n    iterators.push(expr.pipeline\n        ? new aggregator_1.Aggregator(expr.pipeline, options).stream(array)\n        : (0, lazy_1.Lazy)(array));\n    return (0, lazy_1.compose)(...iterators);\n};\nexports.$unionWith = $unionWith;\n\n\n/***/ }),\n\n/***/ 3871:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$unset = void 0;\nconst util_1 = __webpack_require__(7216);\nconst project_1 = __webpack_require__(7911);\n/**\n * Removes/excludes fields from documents.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {Iterator}\n */\nconst $unset = (collection, expr, options) => {\n    expr = (0, util_1.ensureArray)(expr);\n    const doc = {};\n    for (const k of expr)\n        doc[k] = 0;\n    return (0, project_1.$project)(collection, doc, options);\n};\nexports.$unset = $unset;\n\n\n/***/ }),\n\n/***/ 9789:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$unwind = void 0;\nconst lazy_1 = __webpack_require__(9176);\nconst util_1 = __webpack_require__(7216);\n/**\n * Takes an array of documents and returns them as a stream of documents.\n *\n * @param collection\n * @param expr\n * @param options\n * @returns {Array}\n */\nconst $unwind = (collection, expr, _options) => {\n    if ((0, util_1.isString)(expr))\n        expr = { path: expr };\n    const path = expr.path;\n    const field = path.substring(1);\n    const includeArrayIndex = (expr === null || expr === void 0 ? void 0 : expr.includeArrayIndex) || false;\n    const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;\n    const format = (o, i) => {\n        if (includeArrayIndex !== false)\n            o[includeArrayIndex] = i;\n        return o;\n    };\n    let value;\n    return (0, lazy_1.Lazy)(() => {\n        for (;;) {\n            // take from lazy sequence if available\n            if (value instanceof lazy_1.Iterator) {\n                const tmp = value.next();\n                if (!tmp.done)\n                    return tmp;\n            }\n            // fetch next object\n            const wrapper = collection.next();\n            if (wrapper.done)\n                return wrapper;\n            // unwrap value\n            const obj = wrapper.value;\n            // get the value of the field to unwind\n            value = (0, util_1.resolve)(obj, field);\n            // throw error if value is not an array???\n            if (value instanceof Array) {\n                if (value.length === 0 && preserveNullAndEmptyArrays === true) {\n                    value = null; // reset unwind value\n                    (0, util_1.removeValue)(obj, field);\n                    return { value: format(obj, null), done: false };\n                }\n                else {\n                    // construct a lazy sequence for elements per value\n                    value = (0, lazy_1.Lazy)(value).map(((item, i) => {\n                        const newObj = (0, util_1.resolveGraph)(obj, field, {\n                            preserveKeys: true\n                        });\n                        (0, util_1.setValue)(newObj, field, item);\n                        return format(newObj, i);\n                    }));\n                }\n            }\n            else if (!(0, util_1.isEmpty)(value) || preserveNullAndEmptyArrays === true) {\n                return { value: format(obj, null), done: false };\n            }\n        }\n    });\n};\nexports.$unwind = $unwind;\n\n\n/***/ }),\n\n/***/ 2781:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// $elemMatch operator. https://docs.mongodb.com/manual/reference/operator/projection/elemMatch/#proj._S_elemMatch\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$elemMatch = void 0;\nconst query_1 = __webpack_require__(809);\nconst util_1 = __webpack_require__(7216);\n/**\n * Projects only the first element from an array that matches the specified $elemMatch condition.\n *\n * @param obj\n * @param field\n * @param expr\n * @returns {*}\n */\nconst $elemMatch = (obj, expr, field, options) => {\n    const arr = (0, util_1.resolve)(obj, field);\n    const query = new query_1.Query(expr, options);\n    (0, util_1.assert)(arr instanceof Array, \"$elemMatch: argument must resolve to array\");\n    const result = [];\n    for (let i = 0; i < arr.length; i++) {\n        if (query.test(arr[i])) {\n            // MongoDB projects only the first nested document when using this operator.\n            // For some use cases this can lead to complicated queries to selectively project nested documents.\n            // When strict mode is disabled, we return all matching nested documents.\n            if (options.useStrictMode)\n                return [arr[i]];\n            result.push(arr[i]);\n        }\n    }\n    return result.length > 0 ? result : undefined;\n};\nexports.$elemMatch = $elemMatch;\n\n\n/***/ }),\n\n/***/ 3791:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\n// Projection Operators. https://docs.mongodb.com/manual/reference/operator/projection/\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(2781), exports);\n__exportStar(__webpack_require__(8083), exports);\n\n\n/***/ }),\n\n/***/ 8083:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// $slice operator. https://docs.mongodb.com/manual/reference/operator/projection/slice/#proj._S_slice\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$slice = void 0;\nconst util_1 = __webpack_require__(7216);\nconst slice_1 = __webpack_require__(5000);\n/**\n * Limits the number of elements projected from an array. Supports skip and limit slices.\n *\n * @param obj\n * @param field\n * @param expr\n */\nconst $slice = (obj, expr, field, options) => {\n    const xs = (0, util_1.resolve)(obj, field);\n    const exprAsArray = expr;\n    if (!(0, util_1.isArray)(xs))\n        return xs;\n    return (0, slice_1.$slice)(obj, expr instanceof Array ? [xs, ...exprAsArray] : [xs, expr], options);\n};\nexports.$slice = $slice;\n\n\n/***/ }),\n\n/***/ 1274:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$all = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches arrays that contain all elements specified in the query.\n */\nexports.$all = (0, _predicates_1.createQueryOperator)(_predicates_1.$all);\n\n\n/***/ }),\n\n/***/ 6242:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$elemMatch = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Selects documents if element in the array field matches all the specified $elemMatch conditions.\n */\nexports.$elemMatch = (0, _predicates_1.createQueryOperator)(_predicates_1.$elemMatch);\n\n\n/***/ }),\n\n/***/ 7562:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(1274), exports);\n__exportStar(__webpack_require__(6242), exports);\n__exportStar(__webpack_require__(6534), exports);\n\n\n/***/ }),\n\n/***/ 6534:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Array Operators: https://docs.mongodb.com/manual/reference/operator/query-array/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$size = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Selects documents if the array field is a specified size.\n */\nexports.$size = (0, _predicates_1.createQueryOperator)(_predicates_1.$size);\n\n\n/***/ }),\n\n/***/ 2579:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.createBitwiseOperator = void 0;\nconst _predicates_1 = __webpack_require__(4414);\nconst createBitwiseOperator = (predicate) => {\n    return (0, _predicates_1.createQueryOperator)((value, mask, options) => {\n        let b = 0;\n        if (mask instanceof Array) {\n            for (const n of mask)\n                b = b | (1 << n);\n        }\n        else {\n            b = mask;\n        }\n        return predicate(value & b, b);\n    });\n};\nexports.createBitwiseOperator = createBitwiseOperator;\n\n\n/***/ }),\n\n/***/ 8706:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bitsAllClear = void 0;\nconst _internal_1 = __webpack_require__(2579);\n/**\n * Matches numeric or binary values in which a set of bit positions all have a value of 0.\n */\nexports.$bitsAllClear = (0, _internal_1.createBitwiseOperator)((result, _) => result == 0);\n\n\n/***/ }),\n\n/***/ 7089:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bitsAllSet = void 0;\nconst _internal_1 = __webpack_require__(2579);\n/**\n * Matches numeric or binary values in which a set of bit positions all have a value of 1.\n */\nexports.$bitsAllSet = (0, _internal_1.createBitwiseOperator)((result, mask) => result == mask);\n\n\n/***/ }),\n\n/***/ 8390:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bitsAnyClear = void 0;\nconst _internal_1 = __webpack_require__(2579);\n/**\n * Matches numeric or binary values in which any bit from a set of bit positions has a value of 0.\n */\nexports.$bitsAnyClear = (0, _internal_1.createBitwiseOperator)((result, mask) => result < mask);\n\n\n/***/ }),\n\n/***/ 6308:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Bitwise Operators: https://docs.mongodb.com/manual/reference/operator/query-bitwise/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bitsAnySet = void 0;\nconst _internal_1 = __webpack_require__(2579);\n/**\n * Matches numeric or binary values in which any bit from a set of bit positions has a value of 1.\n */\nexports.$bitsAnySet = (0, _internal_1.createBitwiseOperator)((result, _) => result > 0);\n\n\n/***/ }),\n\n/***/ 4167:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$bitsAnySet = exports.$bitsAnyClear = exports.$bitsAllSet = exports.$bitsAllClear = void 0;\nvar bitsAllClear_1 = __webpack_require__(8706);\nObject.defineProperty(exports, \"$bitsAllClear\", ({ enumerable: true, get: function () { return bitsAllClear_1.$bitsAllClear; } }));\nvar bitsAllSet_1 = __webpack_require__(7089);\nObject.defineProperty(exports, \"$bitsAllSet\", ({ enumerable: true, get: function () { return bitsAllSet_1.$bitsAllSet; } }));\nvar bitsAnyClear_1 = __webpack_require__(8390);\nObject.defineProperty(exports, \"$bitsAnyClear\", ({ enumerable: true, get: function () { return bitsAnyClear_1.$bitsAnyClear; } }));\nvar bitsAnySet_1 = __webpack_require__(6308);\nObject.defineProperty(exports, \"$bitsAnySet\", ({ enumerable: true, get: function () { return bitsAnySet_1.$bitsAnySet; } }));\n\n\n/***/ }),\n\n/***/ 102:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$eq = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are equal to a specified value.\n */\nexports.$eq = (0, _predicates_1.createQueryOperator)(_predicates_1.$eq);\n\n\n/***/ }),\n\n/***/ 3916:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$gt = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are greater than a specified value.\n */\nexports.$gt = (0, _predicates_1.createQueryOperator)(_predicates_1.$gt);\n\n\n/***/ }),\n\n/***/ 4017:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$gte = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * \tMatches values that are greater than or equal to a specified value.\n */\nexports.$gte = (0, _predicates_1.createQueryOperator)(_predicates_1.$gte);\n\n\n/***/ }),\n\n/***/ 220:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$in = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches any of the values that exist in an array specified in the query.\n */\nexports.$in = (0, _predicates_1.createQueryOperator)(_predicates_1.$in);\n\n\n/***/ }),\n\n/***/ 5630:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$nin = exports.$ne = exports.$lte = exports.$lt = exports.$in = exports.$gte = exports.$gt = exports.$eq = void 0;\nvar eq_1 = __webpack_require__(102);\nObject.defineProperty(exports, \"$eq\", ({ enumerable: true, get: function () { return eq_1.$eq; } }));\nvar gt_1 = __webpack_require__(3916);\nObject.defineProperty(exports, \"$gt\", ({ enumerable: true, get: function () { return gt_1.$gt; } }));\nvar gte_1 = __webpack_require__(4017);\nObject.defineProperty(exports, \"$gte\", ({ enumerable: true, get: function () { return gte_1.$gte; } }));\nvar in_1 = __webpack_require__(220);\nObject.defineProperty(exports, \"$in\", ({ enumerable: true, get: function () { return in_1.$in; } }));\nvar lt_1 = __webpack_require__(6391);\nObject.defineProperty(exports, \"$lt\", ({ enumerable: true, get: function () { return lt_1.$lt; } }));\nvar lte_1 = __webpack_require__(2126);\nObject.defineProperty(exports, \"$lte\", ({ enumerable: true, get: function () { return lte_1.$lte; } }));\nvar ne_1 = __webpack_require__(8481);\nObject.defineProperty(exports, \"$ne\", ({ enumerable: true, get: function () { return ne_1.$ne; } }));\nvar nin_1 = __webpack_require__(8336);\nObject.defineProperty(exports, \"$nin\", ({ enumerable: true, get: function () { return nin_1.$nin; } }));\n\n\n/***/ }),\n\n/***/ 6391:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lt = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are less than the value specified in the query.\n */\nexports.$lt = (0, _predicates_1.createQueryOperator)(_predicates_1.$lt);\n\n\n/***/ }),\n\n/***/ 2126:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$lte = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that are less than or equal to the value specified in the query.\n */\nexports.$lte = (0, _predicates_1.createQueryOperator)(_predicates_1.$lte);\n\n\n/***/ }),\n\n/***/ 8481:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$ne = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches all values that are not equal to the value specified in the query.\n */\nexports.$ne = (0, _predicates_1.createQueryOperator)(_predicates_1.$ne);\n\n\n/***/ }),\n\n/***/ 8336:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Comparison Operators: https://docs.mongodb.com/manual/reference/operator/query-comparison/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$nin = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches values that do not exist in an array specified to the query.\n */\nexports.$nin = (0, _predicates_1.createQueryOperator)(_predicates_1.$nin);\n\n\n/***/ }),\n\n/***/ 7448:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Element Operators: https://docs.mongodb.com/manual/reference/operator/query-element/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$exists = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Matches documents that have the specified field.\n */\nexports.$exists = (0, _predicates_1.createQueryOperator)(_predicates_1.$exists);\n\n\n/***/ }),\n\n/***/ 3318:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(7448), exports);\n__exportStar(__webpack_require__(8437), exports);\n\n\n/***/ }),\n\n/***/ 8437:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Element Operators: https://docs.mongodb.com/manual/reference/operator/query-element/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$type = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Selects documents if a field is of the specified type.\n */\nexports.$type = (0, _predicates_1.createQueryOperator)(_predicates_1.$type);\n\n\n/***/ }),\n\n/***/ 5468:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$expr = void 0;\nconst core_1 = __webpack_require__(9587);\n/**\n * Allows the use of aggregation expressions within the query language.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nfunction $expr(_, rhs, options) {\n    return obj => (0, core_1.computeValue)(obj, rhs, null, options);\n}\nexports.$expr = $expr;\n\n\n/***/ }),\n\n/***/ 6738:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(5468), exports);\n__exportStar(__webpack_require__(1777), exports);\n__exportStar(__webpack_require__(2841), exports);\n__exportStar(__webpack_require__(5787), exports);\n__exportStar(__webpack_require__(3953), exports);\n\n\n/***/ }),\n\n/***/ 1777:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$jsonSchema = void 0;\n/**\n * Validate documents against the given JSON Schema.\n *\n * @param selector\n * @param schema\n * @returns {Function}\n */\nfunction $jsonSchema(_, schema, options) {\n    if (!(options === null || options === void 0 ? void 0 : options.jsonSchemaValidator)) {\n        throw new Error(\"Missing option 'jsonSchemaValidator'. Configure to use '$jsonSchema' operator.\");\n    }\n    const validate = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator(schema);\n    return (obj) => validate(obj);\n}\nexports.$jsonSchema = $jsonSchema;\n\n\n/***/ }),\n\n/***/ 2841:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$mod = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Performs a modulo operation on the value of a field and selects documents with a specified result.\n */\nexports.$mod = (0, _predicates_1.createQueryOperator)(_predicates_1.$mod);\n\n\n/***/ }),\n\n/***/ 5787:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$regex = void 0;\nconst _predicates_1 = __webpack_require__(4414);\n/**\n * Selects documents where values match a specified regular expression.\n */\nexports.$regex = (0, _predicates_1.createQueryOperator)(_predicates_1.$regex);\n\n\n/***/ }),\n\n/***/ 3953:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Evaluation Operators: https://docs.mongodb.com/manual/reference/operator/query-evaluation/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$where = void 0;\nconst util_1 = __webpack_require__(7216);\n/* eslint-disable */\n/**\n * Matches documents that satisfy a JavaScript expression.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nfunction $where(_, rhs, options) {\n    (0, util_1.assert)(options.scriptEnabled, \"$where operator requires 'scriptEnabled' option to be true\");\n    const f = rhs;\n    (0, util_1.assert)((0, util_1.isFunction)(f), \"$where only accepts a Function object\");\n    return (obj) => (0, util_1.truthy)(f.call(obj), options === null || options === void 0 ? void 0 : options.useStrictMode);\n}\nexports.$where = $where;\n\n\n/***/ }),\n\n/***/ 5444:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(7562), exports);\n__exportStar(__webpack_require__(4167), exports);\n__exportStar(__webpack_require__(5630), exports);\n__exportStar(__webpack_require__(3318), exports);\n__exportStar(__webpack_require__(6738), exports);\n__exportStar(__webpack_require__(1504), exports);\n\n\n/***/ }),\n\n/***/ 476:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$and = void 0;\nconst query_1 = __webpack_require__(809);\nconst util_1 = __webpack_require__(7216);\n/**\n * Joins query clauses with a logical AND returns all documents that match the conditions of both clauses.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nconst $and = (_, rhs, options) => {\n    (0, util_1.assert)((0, util_1.isArray)(rhs), \"Invalid expression: $and expects value to be an Array.\");\n    const queries = rhs.map(expr => new query_1.Query(expr, options));\n    return (obj) => queries.every(q => q.test(obj));\n};\nexports.$and = $and;\n\n\n/***/ }),\n\n/***/ 1504:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(476), exports);\n__exportStar(__webpack_require__(43), exports);\n__exportStar(__webpack_require__(8663), exports);\n__exportStar(__webpack_require__(7653), exports);\n\n\n/***/ }),\n\n/***/ 43:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$nor = void 0;\nconst util_1 = __webpack_require__(7216);\nconst or_1 = __webpack_require__(7653);\n/**\n * Joins query clauses with a logical NOR returns all documents that fail to match both clauses.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nconst $nor = (_, rhs, options) => {\n    (0, util_1.assert)((0, util_1.isArray)(rhs), \"Invalid expression. $nor expects value to be an array.\");\n    const f = (0, or_1.$or)(\"$or\", rhs, options);\n    return (obj) => !f(obj);\n};\nexports.$nor = $nor;\n\n\n/***/ }),\n\n/***/ 8663:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$not = void 0;\nconst query_1 = __webpack_require__(809);\nconst util_1 = __webpack_require__(7216);\n/**\n * Inverts the effect of a query expression and returns documents that do not match the query expression.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nconst $not = (selector, rhs, options) => {\n    const criteria = {};\n    criteria[selector] = (0, util_1.normalize)(rhs);\n    const query = new query_1.Query(criteria, options);\n    return (obj) => !query.test(obj);\n};\nexports.$not = $not;\n\n\n/***/ }),\n\n/***/ 7653:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n// Query Logical Operators: https://docs.mongodb.com/manual/reference/operator/query-logical/\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$or = void 0;\nconst query_1 = __webpack_require__(809);\nconst util_1 = __webpack_require__(7216);\n/**\n * Joins query clauses with a logical OR returns all documents that match the conditions of either clause.\n *\n * @param selector\n * @param rhs\n * @returns {Function}\n */\nconst $or = (_, rhs, options) => {\n    (0, util_1.assert)((0, util_1.isArray)(rhs), \"Invalid expression. $or expects value to be an Array\");\n    const queries = rhs.map(expr => new query_1.Query(expr, options));\n    return (obj) => queries.some(q => q.test(obj));\n};\nexports.$or = $or;\n\n\n/***/ }),\n\n/***/ 3480:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.rank = exports.withMemo = exports.MILLIS_PER_UNIT = void 0;\nconst util_1 = __webpack_require__(7216);\nconst accumulator_1 = __webpack_require__(3424);\nconst _internal_1 = __webpack_require__(7974);\nconst _internal_2 = __webpack_require__(2899);\n// millis map to diffirent time units\nexports.MILLIS_PER_UNIT = {\n    week: _internal_1.MILLIS_PER_DAY * 7,\n    day: _internal_1.MILLIS_PER_DAY,\n    hour: _internal_1.MILLIS_PER_DAY / 24,\n    minute: 60000,\n    second: 1000,\n    millisecond: 1\n};\n// internal cache to store precomputed series once to avoid O(N^2) calls to over the collection\nconst memo = new WeakMap();\n/**\n * Caches all computed values in a window sequence for reuse.\n * This is only useful for operations with unbounded documents.\n */\nfunction withMemo(collection, expr, cacheFn, fn) {\n    // no caching done for bounded inputs\n    if (!(0, _internal_2.isUnbounded)(expr.parentExpr.output[expr.field].window)) {\n        return fn(cacheFn());\n    }\n    // first time using collection\n    if (!memo.has(collection)) {\n        memo.set(collection, { [expr.field]: cacheFn() });\n    }\n    const data = memo.get(collection);\n    // subsequent computations over the same collection.\n    if (data[expr.field] === undefined) {\n        data[expr.field] = cacheFn();\n    }\n    let failed = false;\n    try {\n        return fn(data[expr.field]);\n    }\n    catch (e) {\n        failed = true;\n    }\n    finally {\n        // cleanup on failure or last element in collection.\n        if (failed || expr.documentNumber === collection.length) {\n            delete data[expr.field];\n            if (Object.keys(data).length === 0)\n                memo.delete(collection);\n        }\n    }\n}\nexports.withMemo = withMemo;\n/** Returns the position of a document in the $setWindowFields stage partition. */\nfunction rank(_, collection, expr, options, dense) {\n    return withMemo(collection, expr, () => {\n        const sortKey = \"$\" + Object.keys(expr.parentExpr.sortBy)[0];\n        const values = (0, accumulator_1.$push)(collection, sortKey, options);\n        const groups = (0, util_1.groupBy)(values, ((_, n) => values[n]), options.hashFunction);\n        return { values, groups };\n    }, input => {\n        const { values, groups: partitions } = input;\n        // same number of paritions as length means all sort keys are unique\n        if (partitions.size == collection.length) {\n            return expr.documentNumber;\n        }\n        const current = values[expr.documentNumber - 1];\n        let i = 0;\n        let offset = 0;\n        // partition keys are already dense so just return the value on match\n        for (const key of partitions.keys()) {\n            if ((0, util_1.isEqual)(current, key)) {\n                return dense ? i + 1 : offset + 1;\n            }\n            i++;\n            offset += partitions.get(key).length;\n        }\n        // should be unreachable\n        throw new Error(\"rank: invalid return value. please submit a bug report.\");\n    });\n}\nexports.rank = rank;\n\n\n/***/ }),\n\n/***/ 5120:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$linearFill = void 0;\nconst util_1 = __webpack_require__(7216);\nconst accumulator_1 = __webpack_require__(3424);\nconst _internal_1 = __webpack_require__(3480);\n/**\n * Given two points (x1, y1) and (x2, y2) and a value 'x' that lies between those two points,\n * solve for 'y' with: y = y1 + (x - x1) * ((y2 - y1)/(x2 - x1)).\n * @see https://en.wikipedia.org/wiki/Linear_interpolation\n */\nconst interpolate = (x1, y1, x2, y2, x) => y1 + (x - x1) * ((y2 - y1) / (x2 - x1));\n/**\n * Fills null and missing fields in a window using linear interpolation based on surrounding field values.\n */\nfunction $linearFill(_, collection, expr, options) {\n    return (0, _internal_1.withMemo)(collection, expr, (() => {\n        const sortKey = \"$\" + Object.keys(expr.parentExpr.sortBy)[0];\n        const points = (0, accumulator_1.$push)(collection, [sortKey, expr.inputExpr], options).filter((([x, _]) => (0, util_1.isNumber)(+x)));\n        if (points.length !== collection.length)\n            return null;\n        let lindex = -1;\n        let rindex = 0;\n        while (rindex < points.length) {\n            // use sliding window over missing values and fill as we go.\n            // determine nearest left value index\n            while (lindex + 1 < points.length && (0, util_1.isNumber)(points[lindex + 1][1])) {\n                lindex++;\n                rindex = lindex;\n            }\n            // determine nearest right value index.\n            while (rindex + 1 < points.length && !(0, util_1.isNumber)(points[rindex + 1][1])) {\n                rindex++;\n            }\n            // we reached the end of our array. nothing more to do.\n            if (rindex + 1 >= points.length)\n                break;\n            // otherwise, we found a number so move rindex pointer to it.\n            rindex++;\n            // now fill everything between lindex and rindex by their proportions to the difference.\n            while (lindex + 1 < rindex) {\n                points[lindex + 1][1] = interpolate(points[lindex][0], points[lindex][1], points[rindex][0], points[rindex][1], points[lindex + 1][0]);\n                lindex++;\n            }\n            // move lindex to right\n            lindex = rindex;\n        }\n        return points.map(([_, y]) => y);\n    }), (values) => values[expr.documentNumber - 1]);\n}\nexports.$linearFill = $linearFill;\n\n\n/***/ }),\n\n/***/ 8242:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.$locf = void 0;\nconst util_1 = __webpack_require__(7216);\nconst push_1 = __webpack_require__(7835);\nconst _internal_1 = __webpack_require__(3480);\n/**\n * Last observation carried forward. Sets values for null and missing fields in a window to the last non-null value for the field.\n */\nfunction $locf(_, collection, expr, options) {\n    return (0, _internal_1.withMemo)(collection, expr, () => {\n        const values = (0, push_1.$push)(collection, expr.inputExpr, options);\n        for (let i = 1; i < values.length; i++) {\n            if ((0, util_1.isNil)(values[i]))\n                values[i] = values[i - 1];\n        }\n        return values;\n    }, (series) => series[expr.documentNumber - 1]);\n}\nexports.$locf = $locf;\n\n\n/***/ }),\n\n/***/ 809:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Query = void 0;\nconst core_1 = __webpack_require__(9587);\nconst cursor_1 = __webpack_require__(3645);\nconst util_1 = __webpack_require__(7216);\n/**\n * An object used to filter input documents\n *\n * @param {Object} condition The condition for constructing predicates\n * @param {Options} options Options for use by operators\n * @constructor\n */\nclass Query {\n    constructor(condition, options) {\n        this.condition = condition;\n        this.options = (0, core_1.initOptions)(options);\n        this.compiled = [];\n        this.compile();\n    }\n    compile() {\n        (0, util_1.assert)((0, util_1.isObject)(this.condition), \"query criteria must be an object\");\n        const whereOperator = {};\n        for (const [field, expr] of Object.entries(this.condition)) {\n            if (\"$where\" === field) {\n                Object.assign(whereOperator, { field: field, expr: expr });\n            }\n            else if ((0, util_1.inArray)([\"$and\", \"$or\", \"$nor\", \"$expr\", \"$jsonSchema\"], field)) {\n                this.processOperator(field, field, expr);\n            }\n            else {\n                // normalize expression\n                (0, util_1.assert)(!(0, util_1.isOperator)(field), `unknown top level operator: ${field}`);\n                for (const [operator, val] of Object.entries((0, util_1.normalize)(expr))) {\n                    this.processOperator(field, operator, val);\n                }\n            }\n            if (whereOperator.field) {\n                this.processOperator(whereOperator.field, whereOperator.field, whereOperator.expr);\n            }\n        }\n    }\n    processOperator(field, operator, value) {\n        const call = (0, core_1.getOperator)(core_1.OperatorType.QUERY, operator, this.options);\n        if (!call) {\n            throw new Error(`unknown operator ${operator}`);\n        }\n        const fn = call(field, value, this.options);\n        this.compiled.push(fn);\n    }\n    /**\n     * Checks if the object passes the query criteria. Returns true if so, false otherwise.\n     *\n     * @param obj The object to test\n     * @returns {boolean} True or false\n     */\n    test(obj) {\n        for (let i = 0, len = this.compiled.length; i < len; i++) {\n            if (!this.compiled[i](obj)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Returns a cursor to select matching documents from the input source.\n     *\n     * @param source A source providing a sequence of documents\n     * @param projection An optional projection criteria\n     * @returns {Cursor} A Cursor for iterating over the results\n     */\n    find(collection, projection) {\n        return new cursor_1.Cursor(collection, ((x) => this.test(x)), projection || {}, this.options);\n    }\n    /**\n     * Remove matched documents from the collection returning the remainder\n     *\n     * @param collection An array of documents\n     * @returns {Array} A new array with matching elements removed\n     */\n    remove(collection) {\n        return collection.reduce((acc, obj) => {\n            if (!this.test(obj))\n                acc.push(obj);\n            return acc;\n        }, []);\n    }\n}\nexports.Query = Query;\n\n\n/***/ }),\n\n/***/ 7216:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n/**\n * Utility constants and functions\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.normalize = exports.isOperator = exports.removeValue = exports.setValue = exports.walk = exports.filterMissing = exports.resolveGraph = exports.resolve = exports.memoize = exports.into = exports.groupBy = exports.sortBy = exports.hashCode = exports.stringify = exports.unique = exports.isEqual = exports.flatten = exports.intersection = exports.merge = exports.has = exports.ensureArray = exports.isMissing = exports.isEmpty = exports.truthy = exports.notInArray = exports.inArray = exports.isNil = exports.isFunction = exports.isRegExp = exports.isDate = exports.isObjectLike = exports.isObject = exports.isArray = exports.isNotNaN = exports.isNumber = exports.isString = exports.isBoolean = exports.getType = exports.cloneDeep = exports.assert = exports.compare = exports.MIN_LONG = exports.MAX_LONG = exports.MIN_INT = exports.MAX_INT = void 0;\nexports.MAX_INT = 2147483647;\nexports.MIN_INT = -2147483648;\nexports.MAX_LONG = Number.MAX_SAFE_INTEGER;\nexports.MIN_LONG = Number.MIN_SAFE_INTEGER;\n// special value to identify missing items. treated differently from undefined\nconst MISSING = Symbol(\"missing\");\nconst OBJECT_PROTOTYPE = Object.getPrototypeOf({});\nconst OBJECT_TAG = \"[object Object]\";\nconst OBJECT_TYPE_RE = /^\\[object ([a-zA-Z0-9]+)\\]$/;\n/**\n * Uses the simple hash method as described in Effective Java.\n * @see https://stackoverflow.com/a/113600/1370481\n * @param value The value to hash\n * @returns {number}\n */\nconst DEFAULT_HASH_FUNCTION = (value) => {\n    const s = stringify(value);\n    let hash = 0;\n    let i = s.length;\n    while (i)\n        hash = ((hash << 5) - hash) ^ s.charCodeAt(--i);\n    return hash >>> 0;\n};\n// no array, object, or function types\nconst JS_SIMPLE_TYPES = new Set([\n    \"null\",\n    \"undefined\",\n    \"boolean\",\n    \"number\",\n    \"string\",\n    \"date\",\n    \"regexp\"\n]);\n/** MongoDB sort comparison order. https://www.mongodb.com/docs/manual/reference/bson-type-comparison-order */\nconst SORT_ORDER_BY_TYPE = {\n    null: 0,\n    undefined: 0,\n    number: 1,\n    string: 2,\n    object: 3,\n    array: 4,\n    boolean: 5,\n    date: 6,\n    regexp: 7,\n    function: 8\n};\n/**\n * Compare function which adheres to MongoDB comparison order.\n *\n * @param a The first value\n * @param b The second value\n * @returns {Number}\n */\nconst compare = (a, b) => {\n    if (a === MISSING)\n        a = undefined;\n    if (b === MISSING)\n        b = undefined;\n    const [u, v] = [a, b].map(n => SORT_ORDER_BY_TYPE[(0, exports.getType)(n).toLowerCase()]);\n    if (u !== v)\n        return u - v;\n    // number | string | date\n    if (u === 1 || u === 2 || u === 6) {\n        if (a < b)\n            return -1;\n        if (a > b)\n            return 1;\n        return 0;\n    }\n    // check for equivalence equality\n    if (isEqual(a, b))\n        return 0;\n    if (a < b)\n        return -1;\n    if (a > b)\n        return 1;\n    // if we get here we are comparing a type that does not make sense.\n    return 0;\n};\nexports.compare = compare;\nfunction assert(condition, message) {\n    if (!condition)\n        throw new Error(message);\n}\nexports.assert = assert;\n/**\n * Deep clone an object. Value types and immutable objects are returned as is.\n */\nconst cloneDeep = (obj) => {\n    const m = new Map();\n    const add = (v) => {\n        if (m.has(v))\n            throw new Error(\"cycle detected during clone operation.\");\n        m.set(v, true);\n    };\n    const clone = (val) => {\n        if (val instanceof Date)\n            return new Date(val);\n        if ((0, exports.isArray)(val)) {\n            add(val);\n            const res = new Array(val.length);\n            const len = val.length;\n            for (let i = 0; i < len; i++)\n                res[i] = clone(val[i]);\n            return res;\n        }\n        if ((0, exports.isObject)(val)) {\n            add(val);\n            const res = {};\n            for (const k in val)\n                res[k] = clone(val[k]);\n            return res;\n        }\n        return val;\n    };\n    return clone(obj);\n};\nexports.cloneDeep = cloneDeep;\n/**\n * Returns the name of type as specified in the tag returned by a call to Object.prototype.toString\n * @param v A value\n */\nconst getType = (v) => OBJECT_TYPE_RE.exec(Object.prototype.toString.call(v))[1];\nexports.getType = getType;\nconst isBoolean = (v) => typeof v === \"boolean\";\nexports.isBoolean = isBoolean;\nconst isString = (v) => typeof v === \"string\";\nexports.isString = isString;\nconst isNumber = (v) => !isNaN(v) && typeof v === \"number\";\nexports.isNumber = isNumber;\nconst isNotNaN = (v) => !(isNaN(v) && typeof v === \"number\");\nexports.isNotNaN = isNotNaN;\nexports.isArray = Array.isArray;\nconst isObject = (v) => {\n    if (!v)\n        return false;\n    const proto = Object.getPrototypeOf(v);\n    return ((proto === OBJECT_PROTOTYPE || proto === null) &&\n        OBJECT_TAG === Object.prototype.toString.call(v));\n};\nexports.isObject = isObject;\n//  objects, arrays, functions, date, custom object\nconst isObjectLike = (v) => v === Object(v);\nexports.isObjectLike = isObjectLike;\nconst isDate = (v) => v instanceof Date;\nexports.isDate = isDate;\nconst isRegExp = (v) => v instanceof RegExp;\nexports.isRegExp = isRegExp;\nconst isFunction = (v) => typeof v === \"function\";\nexports.isFunction = isFunction;\nconst isNil = (v) => v === null || v === undefined;\nexports.isNil = isNil;\nconst inArray = (arr, item) => arr.includes(item);\nexports.inArray = inArray;\nconst notInArray = (arr, item) => !(0, exports.inArray)(arr, item);\nexports.notInArray = notInArray;\nconst truthy = (arg, strict = true) => !!arg || (strict && arg === \"\");\nexports.truthy = truthy;\nconst isEmpty = (x) => (0, exports.isNil)(x) ||\n    ((0, exports.isString)(x) && !x) ||\n    (x instanceof Array && x.length === 0) ||\n    ((0, exports.isObject)(x) && Object.keys(x).length === 0);\nexports.isEmpty = isEmpty;\nconst isMissing = (v) => v === MISSING;\nexports.isMissing = isMissing;\n/** ensure a value is an array or wrapped within one. */\nconst ensureArray = (x) => x instanceof Array ? x : [x];\nexports.ensureArray = ensureArray;\nconst has = (obj, prop) => !!obj && Object.prototype.hasOwnProperty.call(obj, prop);\nexports.has = has;\nconst mergeable = (left, right) => ((0, exports.isObject)(left) && (0, exports.isObject)(right)) || ((0, exports.isArray)(left) && (0, exports.isArray)(right));\n/**\n * Deep merge objects or arrays.\n * When the inputs have unmergeable types, the  right hand value is returned.\n * If inputs are arrays and options.flatten is set, elements in the same position are merged together. Remaining elements are appended to the target object.\n * If options.flatten is false, the right hand value is just appended to the left-hand value.\n * @param target {Object|Array} the target to merge into\n * @param obj {Object|Array} the source object\n */\nfunction merge(target, obj, options) {\n    // default options\n    options = options || { flatten: false };\n    // take care of missing inputs\n    if ((0, exports.isMissing)(target) || (0, exports.isNil)(target))\n        return obj;\n    if ((0, exports.isMissing)(obj) || (0, exports.isNil)(obj))\n        return target;\n    // fail only on initial input.\n    if (!mergeable(target, obj)) {\n        if (options.skipValidation)\n            return obj || target;\n        throw Error(\"mismatched types. must both be array or object\");\n    }\n    // skip validation after initial input.\n    options.skipValidation = true;\n    if ((0, exports.isArray)(target)) {\n        const result = target;\n        const input = obj;\n        if (options.flatten) {\n            let i = 0;\n            let j = 0;\n            while (i < result.length && j < input.length) {\n                result[i] = merge(result[i++], input[j++], options);\n            }\n            while (j < input.length) {\n                result.push(obj[j++]);\n            }\n        }\n        else {\n            into(result, input);\n        }\n    }\n    else {\n        for (const k in obj) {\n            target[k] = merge(target[k], obj[k], options);\n        }\n    }\n    return target;\n}\nexports.merge = merge;\nfunction buildHashIndex(arr, hashFunction = DEFAULT_HASH_FUNCTION) {\n    const map = new Map();\n    arr.forEach((o, i) => {\n        const h = hashCode(o, hashFunction);\n        if (map.has(h)) {\n            if (!map.get(h).some(j => isEqual(arr[j], o))) {\n                map.get(h).push(i);\n            }\n        }\n        else {\n            map.set(h, [i]);\n        }\n    });\n    return map;\n}\n/**\n * Returns the intersection of multiple arrays.\n *\n * @param  {Array} input An array of arrays from which to find intersection.\n * @param  {Function} hashFunction Custom function to hash values, default the hashCode method\n * @return {Array} Array of intersecting values.\n */\nfunction intersection(input, hashFunction = DEFAULT_HASH_FUNCTION) {\n    // if any array is empty, there is no intersection\n    if (input.some(arr => arr.length == 0))\n        return [];\n    if (input.length === 1)\n        return Array.from(input);\n    // sort input arrays by to get smallest array\n    // const sorted = sortBy(input, (a: RawArray) => a.length) as RawArray[];\n    const sortedIndex = sortBy(input.map((a, i) => [i, a.length]), (a) => a[1]);\n    // get the smallest\n    const smallest = input[sortedIndex[0][0]];\n    // get hash index of smallest array\n    const map = buildHashIndex(smallest, hashFunction);\n    // hashIndex for remaining arrays.\n    const rmap = new Map();\n    // final intersection results and index of first occurrence.\n    const results = new Array();\n    map.forEach((v, k) => {\n        const lhs = v.map(j => smallest[j]);\n        const res = lhs.map(_ => 0);\n        // used to track first occurence of value in order of the original input array.\n        const stable = lhs.map(_ => [sortedIndex[0][0], 0]);\n        let found = false;\n        for (let i = 1; i < input.length; i++) {\n            const [currIndex, _] = sortedIndex[i];\n            const arr = input[currIndex];\n            if (!rmap.has(i))\n                rmap.set(i, buildHashIndex(arr));\n            // we found a match. let's confirm.\n            if (rmap.get(i).has(k)) {\n                const rhs = rmap\n                    .get(i)\n                    .get(k)\n                    .map(j => arr[j]);\n                // confirm the intersection with an equivalence check.\n                found = lhs\n                    .map((s, n) => rhs.some((t, m) => {\n                    // we expect only one to match here since these are just collisions.\n                    const p = res[n];\n                    if (isEqual(s, t)) {\n                        res[n]++;\n                        // track position of value ordering for stability.\n                        if (currIndex < stable[n][0]) {\n                            stable[n] = [currIndex, rmap.get(i).get(k)[m]];\n                        }\n                    }\n                    return p < res[n];\n                }))\n                    .some(Boolean);\n            }\n            // found nothing, so exclude value. this was just a hash collision.\n            if (!found)\n                return;\n        }\n        // extract value into result if we found an intersection.\n        // we find an intersection if the frequency counter matches the count of the remaining arrays.\n        if (found) {\n            into(results, res\n                .map((n, i) => {\n                return n === input.length - 1 ? [lhs[i], stable[i]] : MISSING;\n            })\n                .filter(n => n !== MISSING));\n        }\n    });\n    return results\n        .sort((a, b) => {\n        const [_i, [u, m]] = a;\n        const [_j, [v, n]] = b;\n        const r = (0, exports.compare)(u, v);\n        if (r !== 0)\n            return r;\n        return (0, exports.compare)(m, n);\n    })\n        .map(v => v[0]);\n}\nexports.intersection = intersection;\n/**\n * Flatten the array\n *\n * @param {Array} xs The array to flatten\n * @param {Number} depth The number of nested lists to iterate\n */\nfunction flatten(xs, depth = 0) {\n    const arr = new Array();\n    function flatten2(ys, n) {\n        for (let i = 0, len = ys.length; i < len; i++) {\n            if ((0, exports.isArray)(ys[i]) && (n > 0 || n < 0)) {\n                flatten2(ys[i], Math.max(-1, n - 1));\n            }\n            else {\n                arr.push(ys[i]);\n            }\n        }\n    }\n    flatten2(xs, depth);\n    return arr;\n}\nexports.flatten = flatten;\n/**\n * Determine whether two values are the same or strictly equivalent\n *\n * @param  {*}  a The first value\n * @param  {*}  b The second value\n * @return {Boolean}   Result of comparison\n */\nfunction isEqual(a, b) {\n    const lhs = [a];\n    const rhs = [b];\n    while (lhs.length > 0) {\n        a = lhs.pop();\n        b = rhs.pop();\n        // strictly equal must be equal.\n        if (a === b)\n            continue;\n        // unequal types and functions cannot be equal.\n        const nativeType = (0, exports.getType)(a).toLowerCase();\n        if (nativeType !== (0, exports.getType)(b).toLowerCase() || nativeType === \"function\") {\n            return false;\n        }\n        // leverage toString for Date and RegExp types\n        if (nativeType === \"array\") {\n            const xs = a;\n            const ys = b;\n            if (xs.length !== ys.length)\n                return false;\n            if (xs.length === ys.length && xs.length === 0)\n                continue;\n            into(lhs, xs);\n            into(rhs, ys);\n        }\n        else if (nativeType === \"object\") {\n            // deep compare objects\n            const aKeys = Object.keys(a);\n            const bKeys = Object.keys(b);\n            // check length of keys early\n            if (aKeys.length !== bKeys.length)\n                return false;\n            // compare keys\n            for (let i = 0, len = aKeys.length; i < len; i++) {\n                const k = aKeys[i];\n                // not found\n                if (!(0, exports.has)(b, k))\n                    return false;\n                // key found\n                lhs.push(a[k]);\n                rhs.push(b[k]);\n            }\n        }\n        else {\n            // compare encoded values\n            if (stringify(a) !== stringify(b))\n                return false;\n        }\n    }\n    return lhs.length === 0;\n}\nexports.isEqual = isEqual;\n/**\n * Return a new unique version of the collection\n * @param  {Array} input The input collection\n * @return {Array}\n */\nfunction unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {\n    const result = input.map(_ => MISSING);\n    buildHashIndex(input, hashFunction).forEach((v, _) => {\n        v.forEach(i => (result[i] = input[i]));\n    });\n    return result.filter(v => v !== MISSING);\n}\nexports.unique = unique;\n/**\n * Encode value to string using a simple non-colliding stable scheme.\n *\n * @param value\n * @returns {*}\n */\nfunction stringify(value) {\n    const type = (0, exports.getType)(value).toLowerCase();\n    switch (type) {\n        case \"boolean\":\n        case \"number\":\n        case \"regexp\":\n            return value.toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"date\":\n            return value.toISOString();\n        case \"null\":\n        case \"undefined\":\n            return type;\n        case \"array\":\n            return \"[\" + value.map(stringify).join(\",\") + \"]\";\n        default:\n            break;\n    }\n    // default case\n    const prefix = type === \"object\" ? \"\" : `${(0, exports.getType)(value)}`;\n    const objKeys = Object.keys(value);\n    objKeys.sort();\n    return (`${prefix}{` +\n        objKeys\n            .map(k => `${stringify(k)}:${stringify(value[k])}`)\n            .join(\",\") +\n        \"}\");\n}\nexports.stringify = stringify;\n/**\n * Generate hash code\n * This selected function is the result of benchmarking various hash functions.\n * This version performs well and can hash 10^6 documents in ~3s with on average 100 collisions.\n *\n * @param value\n * @returns {number|null}\n */\nfunction hashCode(value, hashFunction) {\n    hashFunction = hashFunction || DEFAULT_HASH_FUNCTION;\n    if ((0, exports.isNil)(value))\n        return null;\n    return hashFunction(value).toString();\n}\nexports.hashCode = hashCode;\n/**\n * Returns a (stably) sorted copy of list, ranked in ascending order by the results of running each value through iteratee\n *\n * This implementation treats null/undefined sort keys as less than every other type\n *\n * @param {Array}   collection\n * @param {Function} keyFn The sort key function used to resolve sort keys\n * @param {Function} comparator The comparator function to use for comparing keys. Defaults to standard comparison via `compare(...)`\n * @return {Array} Returns a new sorted array by the given key and comparator function\n */\nfunction sortBy(collection, keyFn, comparator = exports.compare) {\n    if ((0, exports.isEmpty)(collection))\n        return collection;\n    const sorted = new Array();\n    const result = new Array();\n    for (let i = 0; i < collection.length; i++) {\n        const obj = collection[i];\n        const key = keyFn(obj, i);\n        if ((0, exports.isNil)(key)) {\n            result.push(obj);\n        }\n        else {\n            sorted.push([key, obj]);\n        }\n    }\n    // use native array sorting but enforce stableness\n    sorted.sort((a, b) => comparator(a[0], b[0]));\n    return into(result, sorted.map((o) => o[1]));\n}\nexports.sortBy = sortBy;\n/**\n * Groups the collection into sets by the returned key\n *\n * @param collection\n * @param keyFn {Function} to compute the group key of an item in the collection\n * @returns {GroupByOutput}\n */\nfunction groupBy(collection, keyFn, hashFunction = DEFAULT_HASH_FUNCTION) {\n    if (collection.length < 1)\n        return new Map();\n    // map of hash to collided values\n    const lookup = new Map();\n    // map of raw key values to objects.\n    const result = new Map();\n    for (let i = 0; i < collection.length; i++) {\n        const obj = collection[i];\n        const key = keyFn(obj, i);\n        const hash = hashCode(key, hashFunction);\n        if (hash === null) {\n            if (result.has(null)) {\n                result.get(null).push(obj);\n            }\n            else {\n                result.set(null, [obj]);\n            }\n        }\n        else {\n            // find if we can match a hash for which the value is equivalent.\n            // this is used to deal with collisions.\n            const existingKey = lookup.has(hash)\n                ? lookup.get(hash).find(k => isEqual(k, key))\n                : null;\n            // collision detected or first time seeing key\n            if ((0, exports.isNil)(existingKey)) {\n                // collision detected or first entry so we create a new group.\n                result.set(key, [obj]);\n                // upload the lookup with the collided key\n                if (lookup.has(hash)) {\n                    lookup.get(hash).push(key);\n                }\n                else {\n                    lookup.set(hash, [key]);\n                }\n            }\n            else {\n                // key exists\n                result.get(existingKey).push(obj);\n            }\n        }\n    }\n    return result;\n}\nexports.groupBy = groupBy;\n// max elements to push.\n// See argument limit https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply\nconst MAX_ARRAY_PUSH = 50000;\n/**\n * Merge elements into the dest\n *\n * @param {*} target The target object\n * @param {*} rest The array of elements to merge into dest\n */\nfunction into(target, ...rest) {\n    if (target instanceof Array) {\n        return rest.reduce(((acc, arr) => {\n            // push arrary in batches to handle large inputs\n            let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);\n            let begin = 0;\n            while (i-- > 0) {\n                Array.prototype.push.apply(acc, arr.slice(begin, begin + MAX_ARRAY_PUSH));\n                begin += MAX_ARRAY_PUSH;\n            }\n            return acc;\n        }), target);\n    }\n    else {\n        // merge objects. same behaviour as Object.assign\n        return rest.filter(exports.isObjectLike).reduce((acc, item) => {\n            Object.assign(acc, item);\n            return acc;\n        }, target);\n    }\n}\nexports.into = into;\n/**\n * This is a generic memoization function\n *\n * This implementation uses a cache independent of the function being memoized\n * to allow old values to be garbage collected when the memoized function goes out of scope.\n *\n * @param {*} fn The function object to memoize\n */\nfunction memoize(fn, hashFunction = DEFAULT_HASH_FUNCTION) {\n    return ((memo) => {\n        return (...args) => {\n            const key = hashCode(args, hashFunction) || \"\";\n            if (!(0, exports.has)(memo, key)) {\n                memo[key] = fn.apply(this, args);\n            }\n            return memo[key];\n        };\n    })({\n    /* storage */\n    });\n}\nexports.memoize = memoize;\n// mingo internal\n/**\n * Retrieve the value of a given key on an object\n * @param obj\n * @param key\n * @returns {*}\n * @private\n */\nfunction getValue(obj, key) {\n    return (0, exports.isObjectLike)(obj) ? obj[key] : undefined;\n}\n/**\n * Unwrap a single element array to specified depth\n * @param {Array} arr\n * @param {Number} depth\n */\nfunction unwrap(arr, depth) {\n    if (depth < 1)\n        return arr;\n    while (depth-- && arr.length === 1)\n        arr = arr[0];\n    return arr;\n}\n/**\n * Resolve the value of the field (dot separated) on the given object\n * @param obj {Object} the object context\n * @param selector {String} dot separated path to field\n * @returns {*}\n */\nfunction resolve(obj, selector, options) {\n    let depth = 0;\n    function resolve2(o, path) {\n        let value = o;\n        for (let i = 0; i < path.length; i++) {\n            const field = path[i];\n            const isText = /^\\d+$/.exec(field) === null;\n            // using instanceof to aid typescript compiler\n            if (isText && value instanceof Array) {\n                // On the first iteration, we check if we received a stop flag.\n                // If so, we stop to prevent iterating over a nested array value\n                // on consecutive object keys in the selector.\n                if (i === 0 && depth > 0)\n                    break;\n                depth += 1;\n                // only look at the rest of the path\n                const subpath = path.slice(i);\n                value = value.reduce((acc, item) => {\n                    const v = resolve2(item, subpath);\n                    if (v !== undefined)\n                        acc.push(v);\n                    return acc;\n                }, []);\n                break;\n            }\n            else {\n                value = getValue(value, field);\n            }\n            if (value === undefined)\n                break;\n        }\n        return value;\n    }\n    const result = JS_SIMPLE_TYPES.has((0, exports.getType)(obj).toLowerCase())\n        ? obj\n        : resolve2(obj, selector.split(\".\"));\n    return result instanceof Array && (options === null || options === void 0 ? void 0 : options.unwrapArray)\n        ? unwrap(result, depth)\n        : result;\n}\nexports.resolve = resolve;\n/**\n * Returns the full object to the resolved value given by the selector.\n * This function excludes empty values as they aren't practically useful.\n *\n * @param obj {Object} the object context\n * @param selector {String} dot separated path to field\n */\nfunction resolveGraph(obj, selector, options) {\n    const names = selector.split(\".\");\n    const key = names[0];\n    // get the next part of the selector\n    const next = names.slice(1).join(\".\");\n    const isIndex = /^\\d+$/.exec(key) !== null;\n    const hasNext = names.length > 1;\n    let result;\n    let value;\n    if (obj instanceof Array) {\n        if (isIndex) {\n            result = getValue(obj, Number(key));\n            if (hasNext) {\n                result = resolveGraph(result, next, options);\n            }\n            result = [result];\n        }\n        else {\n            result = [];\n            for (const item of obj) {\n                value = resolveGraph(item, selector, options);\n                if (options === null || options === void 0 ? void 0 : options.preserveMissing) {\n                    if (value === undefined) {\n                        value = MISSING;\n                    }\n                    result.push(value);\n                }\n                else if (value !== undefined) {\n                    result.push(value);\n                }\n            }\n        }\n    }\n    else {\n        value = getValue(obj, key);\n        if (hasNext) {\n            value = resolveGraph(value, next, options);\n        }\n        if (value === undefined)\n            return undefined;\n        result = (options === null || options === void 0 ? void 0 : options.preserveKeys) ? Object.assign({}, obj) : {};\n        result[key] = value;\n    }\n    return result;\n}\nexports.resolveGraph = resolveGraph;\n/**\n * Filter out all MISSING values from the object in-place\n *\n * @param obj The object to filter\n */\nfunction filterMissing(obj) {\n    if (obj instanceof Array) {\n        for (let i = obj.length - 1; i >= 0; i--) {\n            if (obj[i] === MISSING) {\n                obj.splice(i, 1);\n            }\n            else {\n                filterMissing(obj[i]);\n            }\n        }\n    }\n    else if ((0, exports.isObject)(obj)) {\n        for (const k in obj) {\n            if ((0, exports.has)(obj, k)) {\n                filterMissing(obj[k]);\n            }\n        }\n    }\n}\nexports.filterMissing = filterMissing;\nconst NUMBER_RE = /^\\d+$/;\n/**\n * Walk the object graph and execute the given transform function\n *\n * @param  {Object|Array} obj   The object to traverse.\n * @param  {String} selector    The selector to navigate.\n * @param  {Callback} fn Callback to execute for value at the end the traversal.\n * @param  {WalkOptions} Options to use for the function.\n * @return {*}\n */\nfunction walk(obj, selector, fn, options) {\n    const names = selector.split(\".\");\n    const key = names[0];\n    const next = names.slice(1).join(\".\");\n    if (names.length === 1) {\n        if ((0, exports.isObject)(obj) || ((0, exports.isArray)(obj) && NUMBER_RE.test(key))) {\n            fn(obj, key);\n        }\n    }\n    else {\n        // force the rest of the graph while traversing\n        if ((options === null || options === void 0 ? void 0 : options.buildGraph) && (0, exports.isNil)(obj[key])) {\n            obj[key] = {};\n        }\n        // get the next item\n        const item = obj[key];\n        // nothing more to do\n        if (!item)\n            return;\n        // we peek to see if next key is an array index.\n        const isNextArrayIndex = !!(names.length > 1 && NUMBER_RE.test(names[1]));\n        // if we have an array value but the next key is not an index and the 'descendArray' option is set,\n        // we walk each item in the array separately. This allows for handling traversing keys for objects\n        // nested within an array.\n        //\n        // Eg: Given { array: [ {k:1}, {k:2}, {k:3} ] }\n        //  - individual objecs can be traversed with \"array.k\"\n        //  - a specific object can be traversed with \"array.1\"\n        if (item instanceof Array && (options === null || options === void 0 ? void 0 : options.descendArray) && !isNextArrayIndex) {\n            item.forEach(((e) => walk(e, next, fn, options)));\n        }\n        else {\n            walk(item, next, fn, options);\n        }\n    }\n}\nexports.walk = walk;\n/**\n * Set the value of the given object field\n *\n * @param obj {Object|Array} the object context\n * @param selector {String} path to field\n * @param value {*} the value to set\n */\nfunction setValue(obj, selector, value) {\n    walk(obj, selector, ((item, key) => {\n        item[key] = value;\n    }), { buildGraph: true });\n}\nexports.setValue = setValue;\n/**\n * Removes an element from the container.\n * If the selector resolves to an array and the leaf is a non-numeric key,\n * the remove operation will be performed on objects of the array.\n *\n * @param obj {ArrayOrObject} object or array\n * @param selector {String} dot separated path to element to remove\n */\nfunction removeValue(obj, selector, options) {\n    walk(obj, selector, ((item, key) => {\n        if (item instanceof Array) {\n            if (/^\\d+$/.test(key)) {\n                item.splice(parseInt(key), 1);\n            }\n            else if (options && options.descendArray) {\n                for (const elem of item) {\n                    if ((0, exports.isObject)(elem)) {\n                        delete elem[key];\n                    }\n                }\n            }\n        }\n        else if ((0, exports.isObject)(item)) {\n            delete item[key];\n        }\n    }), options);\n}\nexports.removeValue = removeValue;\nconst OPERATOR_NAME_PATTERN = /^\\$[a-zA-Z0-9_]+$/;\n/**\n * Check whether the given name passes for an operator. We assume AnyVal field name starting with '$' is an operator.\n * This is cheap and safe to do since keys beginning with '$' should be reserved for internal use.\n * @param {String} name\n */\nfunction isOperator(name) {\n    return OPERATOR_NAME_PATTERN.test(name);\n}\nexports.isOperator = isOperator;\n/**\n * Simplify expression for easy evaluation with query operators map\n * @param expr\n * @returns {*}\n */\nfunction normalize(expr) {\n    // normalized primitives\n    if (JS_SIMPLE_TYPES.has((0, exports.getType)(expr).toLowerCase())) {\n        return (0, exports.isRegExp)(expr) ? { $regex: expr } : { $eq: expr };\n    }\n    // normalize object expression. using ObjectLike handles custom types\n    if ((0, exports.isObjectLike)(expr)) {\n        const exprObj = expr;\n        // no valid query operator found, so we do simple comparison\n        if (!Object.keys(exprObj).some(isOperator)) {\n            return { $eq: expr };\n        }\n        // ensure valid regex\n        if ((0, exports.has)(expr, \"$regex\")) {\n            return {\n                $regex: new RegExp(exprObj[\"$regex\"], exprObj[\"$options\"])\n            };\n        }\n    }\n    return expr;\n}\nexports.normalize = normalize;\n\n\n/***/ }),\n\n/***/ 3689:\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   decode: () => (/* binding */ decode),\n/* harmony export */   \"default\": () => (__WEBPACK_DEFAULT_EXPORT__),\n/* harmony export */   encode: () => (/* binding */ encode),\n/* harmony export */   toASCII: () => (/* binding */ toASCII),\n/* harmony export */   toUnicode: () => (/* binding */ toUnicode),\n/* harmony export */   ucs2decode: () => (/* binding */ ucs2decode),\n/* harmony export */   ucs2encode: () => (/* binding */ ucs2encode)\n/* harmony export */ });\n\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7F]/; // Note: U+007F DEL is excluded too.\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, callback) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = callback(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {String} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(domain, callback) {\n\tconst parts = domain.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tdomain = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tdomain = domain.replace(regexSeparators, '\\x2E');\n\tconst labels = domain.split('.');\n\tconst encoded = map(labels, callback).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = codePoints => String.fromCodePoint(...codePoints);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint >= 0x30 && codePoint < 0x3A) {\n\t\treturn 26 + (codePoint - 0x30);\n\t}\n\tif (codePoint >= 0x41 && codePoint < 0x5B) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint >= 0x61 && codePoint < 0x7B) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tconst oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\t\t\tif (digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tconst inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tconst basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue === n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.1.0',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\n\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (punycode);\n\n\n/***/ }),\n\n/***/ 9413:\n/***/ ((module) => {\n\nmodule.exports=/[\\0-\\x1F\\x7F-\\x9F]/\n\n/***/ }),\n\n/***/ 2326:\n/***/ ((module) => {\n\nmodule.exports=/[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/\n\n/***/ }),\n\n/***/ 3189:\n/***/ ((module) => {\n\nmodule.exports=/[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4E\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDF55-\\uDF59]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9]|\\uD805[\\uDC4B-\\uDC4F\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8]|\\uD809[\\uDC70-\\uDC74]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDE97-\\uDE9A]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD83A[\\uDD5E\\uDD5F]/\n\n/***/ }),\n\n/***/ 5045:\n/***/ ((module) => {\n\nmodule.exports=/[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/\n\n/***/ }),\n\n/***/ 4205:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\n\nexports.Any = __webpack_require__(9369);\nexports.Cc = __webpack_require__(9413);\nexports.Cf = __webpack_require__(2326);\nexports.P = __webpack_require__(3189);\nexports.Z = __webpack_require__(5045);\n\n\n/***/ }),\n\n/***/ 9369:\n/***/ ((module) => {\n\nmodule.exports=/[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/\n\n/***/ }),\n\n/***/ 1201:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst State = __webpack_require__(5213);\n\n/**\n * @namespace History\n * @property {Array}    history   Array of passages and previous state.\n * @property {number}   position  Current position in the array.\n */\n\nclass History {\n  static history = [];\n  static position = 0;\n  /**\n   * Add a passage name to the history array.\n   * @function add\n   * @param {string} name - Name of the passage to add.\n   */\n  static add (name) {\n    // Append to the end\n    this.history.push({\n      passageName: name,\n      state: Object.assign({}, State.store)\n    });\n\n    // Reset the position to entry at the end.\n    this.position = this.history.length - 1;\n  }\n\n  /**\n   * Step back one index in the history array.\n   * @function undo\n   * @returns {string | null} Name of now current passage; null if undo not possible.\n   */\n  static undo () {\n    let result = null;\n\n    if (this.position >= 1 && this.history.length >= 1) {\n      // Decrease position\n      this.position -= 1;\n      // Find state.\n      const state = this.history[this.position].state;\n      // Have State update itself.\n      State.updateState(state);\n      // Return current passage name\n      result = this.history[this.position].passageName;\n    }\n\n    return result;\n  }\n\n  /**\n   * Step forward in history array, if possible.\n   * @function Redo\n   * @returns {string | null} Name of now current passage; null if redo not possible.\n   */\n  static redo () {\n    let result = null;\n\n    if (this.position >= 0 && this.position < this.history.length - 1) {\n      // Increase position\n      this.position += 1;\n      // Find state.\n      const state = this.history[this.position].state;\n      // Have State update itself.\n      State.updateState(state);\n      // Return current passage name\n      result = this.history[this.position].passageName;\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns true if the named passage exists within the history array.\n   * @function hasVisited\n   * @param {string | Array} passageName - Name(s) of passage to check.\n   * @returns {boolean} True if passage(s) in history; false otherwise.\n   */\n  static hasVisited (passageName = null) {\n    let result = false;\n\n    if (Array.isArray(passageName)) {\n      result = passageName.every((passageName) => {\n        return this.history.some(entry => {\n          return entry.passageName === passageName;\n        });\n      });\n    } else {\n      result = this.history.some((p) => {\n        return p.passageName === passageName;\n      });\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns number of visits for a single passage.\n   * @function visited\n   * @param   {string} passageName  Passage name to check.\n   * @returns {number}              Number of visits to passage.\n   */\n  static visited (passageName) {\n    let searchResults = [];\n    searchResults = this.history.filter(entry => entry.passageName === passageName);\n    return searchResults.length;\n  }\n\n  /**\n   * Resets History values to defaults.\n   * @function reset\n   */\n  static reset () {\n    this.history = [];\n    this.position = 0;\n  }\n}\n\nmodule.exports = History;\n\n\n/***/ }),\n\n/***/ 9456:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst md = __webpack_require__(9980)({\n  html: true, // Enable HTML tags in source\n  xhtmlOut: true, // Use '/' to close single tags (<br />).\n  breaks: true // Convert \\n into <br />\n});\n\nclass Markdown {\n  static parse (text) {\n    const rules = [\n      // [[rename|destination][onclick]]\n      [/\\[\\[(.*?)\\|(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p2}\">${p1}</tw-link>`],\n      // [[rename|destination]]\n      // [/\\[\\[(.*?)\\|(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$2\">$1</tw-link>'],\n      // [[rename->dest][onclick]]\n      [/\\[\\[(.*?)->(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p2}\">${p1}</tw-link>`],\n      // [[rename->dest]]\n      // [/\\[\\[(.*?)->(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$2\">$1</tw-link>'],\n      // [[dest<-rename][onclick]]\n      [/\\[\\[(.*?)<-(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p1}\">${p2}</tw-link>`],\n      // [[dest<-rename]]\n      // [/\\[\\[(.*?)<-(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$1\">$2</tw-link>'],\n      // [[destination][onclick]]\n      [/\\[\\[(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2 = '') => `<tw-link role=\"link\" onclick=\"${p2.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p1}\">${p1}</tw-link>`]\n      // [[destination]]\n      // [/\\[\\[(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$1\">$1</tw-link>']\n    ];\n\n    rules.forEach(([rule, template]) => {\n      text = text.replaceAll(rule, template);\n    });\n\n    return text;\n  }\n\n  static convert (text) {\n    return md.render(text);\n  }\n\n  static unescape (text) {\n    const unescapeSequences = [\n      ['&amp;', '&'],\n      ['&lt;', '<'],\n      ['&gt;', '>'],\n      ['&quot;', '\"'],\n      ['&#x27;', \"'\"],\n      ['&#x60;', '`']\n    ];\n\n    unescapeSequences.forEach(([rule, template]) => {\n      text = text.replaceAll(rule, template);\n    });\n\n    return text;\n  }\n}\n\nmodule.exports = Markdown;\n\n\n/***/ }),\n\n/***/ 1067:\n/***/ ((module) => {\n\n/**\n * An object representing a passage. The current passage will be `window.passage`.\n * @class Passage\n */\n\nclass Passage {\n  constructor (name = 'Default', tags = [], source = '') {\n    /**\n     * @property {string} name - The name of passage\n     * @type {string}\n     */\n\n    this.name = name;\n\n    /**\n     * @property {Array} tags - The tags of the passage.\n     * @type {Array}\n     */\n\n    this.tags = tags;\n\n    /**\n     * @property {string} source - The passage source code.\n     * @type {string}\n     */\n\n    this.source = source;\n  }\n}\n\nmodule.exports = Passage;\n\n\n/***/ }),\n\n/***/ 1675:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(9755);\n\nclass Screen {\n  /**\n   * Trigger screen-lock event.\n   * @function lock\n   */\n  static lock () {\n    // Append an element filling screen with CSS loading spinner.\n    $(document.body).append('<tw-screenlock><div class=\"loading\"></div></tw-screenlock>');\n  }\n\n  /**\n   * Trigger screen-unlock event.\n   * @function unlock\n   */\n  static unlock () {\n    // Remove tw-screenlock element, if there is one.\n    $('tw-screenlock').remove();\n  }\n}\n\nmodule.exports = Screen;\n\n\n/***/ }),\n\n/***/ 5827:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst ejs = __webpack_require__(7083);\nconst History = __webpack_require__(1201);\nconst Screen = __webpack_require__(1675);\nconst Utilities = __webpack_require__(5543);\n\n/**\n * @external Story\n * @see {@link Story}\n */\n\nclass Script {\n  /**\n   * Render JavaScript within a templated sandbox and return possible output.\n   * Will throw error if code does.\n   * @function run\n   * @param {string} script - Code to run.\n   * @param {Story} story - Current story object.\n   * @returns {string} Any output, if produced.\n   */\n  static run (script, story) {\n    let result = '';\n\n    try {\n      // Send in pseudo-global properties.\n      result = ejs.render(script,\n        {\n          s: story.store,\n          Storage: story.storage,\n          Storylets: story.storylets,\n          History: {\n            hasVisited: History.hasVisited.bind(History),\n            visited: History.visited.bind(History),\n            length: History.history.length\n          },\n          Screen: {\n            lock: Screen.lock.bind(),\n            unlock: Screen.unlock.bind()\n          },\n          Sidebar: {\n            hide: story.sidebar.hide.bind(),\n            show: story.sidebar.show.bind()\n          },\n          Utils: {\n            delay: Utilities.delay.bind(),\n            either: Utilities.either.bind(),\n            applyExternalStyles: Utilities.applyExternalStyles.bind(),\n            randomInt: Utilities.randomInt.bind()\n          }\n        },\n        {\n          outputFunctionName: 'print'\n        }\n      );\n    } catch (e) {\n      // Throw error if rendering fails.\n      throw new Error(`Error compiling template code: ${e}`);\n    }\n\n    return result;\n  }\n}\n\nmodule.exports = Script;\n\n\n/***/ }),\n\n/***/ 2879:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(9755);\nconst State = __webpack_require__(5213);\n\nclass Sidebar {\n  constructor () {\n    /**\n     * Reference to undo icon.\n     * @property {Element} undoIcon - Undo element.\n     * @type {Element}\n     */\n    this.undoIcon = $('tw-icon[title=\"Undo\"]');\n\n    /**\n     * Reference to redo icon.\n     * @property {Element} redoIcon - Redo element.\n     * @type {Element}\n     */\n    this.redoIcon = $('tw-icon[title=\"Redo\"]');\n\n    // Listen for user click interactions.\n    this.undoIcon.on('click', () => {\n      // If undo is ever used, redo becomes available.\n      this.showRedo();\n      // Emit 'undo'\n      State.events.emit('undo');\n    });\n\n    // Listen for user click interactions.\n    this.redoIcon.on('click', () => {\n      State.events.emit('redo');\n    });\n\n    // Start with undo hidden.\n    this.hideUndo();\n\n    // Start with redo hidden.\n    this.hideRedo();\n  }\n\n  /**\n   * Show undo icon.\n   * @function showUndo\n   */\n  showUndo () {\n    this.undoIcon.css('visibility', 'visible');\n  }\n\n  /**\n   * Hide undo icon.\n   * @function hideUndo\n   */\n  hideUndo () {\n    this.undoIcon.css('visibility', 'hidden');\n  }\n\n  /**\n   * Show redo icon.\n   * @function showRedo\n   */\n  showRedo () {\n    this.redoIcon.css('visibility', 'visible');\n  }\n\n  /**\n   * Hide redo icon.\n   * @function hideRedo\n   */\n  hideRedo () {\n    this.redoIcon.css('visibility', 'hidden');\n  }\n\n  /**\n   * Trigger undo event.\n   * @function undo\n   */\n  undo () {\n    State.events.emit('undo');\n  }\n\n  /**\n   * Trigger redo event.\n   * @function redo\n   */\n  redo () {\n    State.events.emit('redo');\n  }\n\n  /**\n   * Shows sidebar.\n   * @function show\n   */\n  show () {\n    // Show tw-sidebar.\n    $('tw-sidebar').css('visibility', 'visible');\n  }\n\n  /**\n   * Hides sidebar.\n   * @function hide\n   */\n  hide () {\n    // Hide tw-sidebar.\n    $('tw-sidebar').css('visibility', 'hidden');\n  }\n}\n\nmodule.exports = Sidebar;\n\n\n/***/ }),\n\n/***/ 5213:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst EventEmitter = __webpack_require__(7187);\n\nconst handler = {\n  get: (target, property) => {\n    return target[property];\n  },\n  set: (target, property, value) => {\n    // Make change.\n    target[property] = value;\n    // Emit change.\n    State.events.emit('change', property, value);\n    // Return true.\n    return true;\n  },\n  ownKeys (target) {\n    return Object.keys(target);\n  },\n  has (target, prop) {\n    return prop in target;\n  },\n  deleteProperty (target, prop) {\n    // Set default.\n    let result = false;\n\n    // Test for inclusion as property.\n    if (prop in target) {\n      // Emit deletion event.\n      State.events.emit('deletion', prop);\n      // Delete via Reflection.\n      result = Reflect.deleteProperty(target, prop);\n    }\n\n    // Return default or reflection result.\n    return result;\n  }\n};\n\n/**\n * @class State\n */\nclass State {\n  static events = new EventEmitter();\n  static store = new Proxy({}, handler);\n  /**\n   * Update current state properties to previous state values.\n   * @param {object} state - Object containing state properties.\n   */\n  static updateState (state) {\n    for (const property in state) {\n      this.store[property] = state[property];\n    }\n  }\n\n  /**\n   * Resets State properties to default values.\n   */\n  static reset () {\n    this.events = new EventEmitter();\n    this.store = new Proxy({}, handler);\n  }\n}\n\nmodule.exports = State;\n\n\n/***/ }),\n\n/***/ 6505:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst History = __webpack_require__(1201);\nconst State = __webpack_require__(5213);\n\nclass Storage {\n  /**\n   * Remove save by name from the localStorage.\n   * @function removeSave\n   * @param {string} save Name of save string.\n   * @returns {boolean} True if remove was successful.\n   */\n  static removeSave (save = 'default') {\n    let result = false;\n\n    if (Storage.available()) {\n      window.localStorage.removeItem(`${save}.snowman.history`);\n      result = true;\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns if save string exists in localStorage\n   * @function doesSaveExist\n   * @param {string} save Name of save string\n   * @returns {boolean} True if save string exists\n   */\n  static doesSaveExist (save = 'default') {\n    let history = null;\n\n    if (Storage.available()) {\n      history = window.localStorage.getItem(`${save}.snowman.history`);\n    }\n\n    return (history !== null);\n  }\n\n  /**\n   * Save history using optional string prefix\n   * @function createSave\n   * @param {string} save Optional name of save string\n   * @returns {boolean} Returns true if save was successful\n   */\n  static createSave (save = 'default') {\n    let result = false;\n\n    if (Storage.available()) {\n      window.localStorage.setItem(`${save}.snowman.history`, JSON.stringify(History.history));\n      result = true;\n    }\n\n    return result;\n  }\n\n  /**\n   * Attempts to restore the history and store based on optional save name\n   * @function restoreSave\n   * @param {string} save Optional name of save string\n   * @returns {boolean} Returns true if restore was successful\n   */\n  static restoreSave (save = 'default') {\n    let history = null;\n    let result = false;\n\n    if (Storage.available()) {\n      history = window.localStorage.getItem(`${save}.snowman.history`);\n      result = true;\n    }\n\n    if (history !== null) {\n      // Restore history\n      History.history = JSON.parse(history);\n      // Find current state.\n      const state = History.history[History.position].state;\n      // Have State update itself.\n      State.updateState(state);\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns if localStorage is available or not in browser context.\n   * @function available\n   * @returns {boolean} Returns true if localStorage can be used.\n   */\n  static available () {\n    // Set default value to false.\n    let result = false;\n\n    try {\n      window.localStorage.setItem('testKey', 'test');\n      window.localStorage.removeItem('testKey');\n      result = true;\n    } catch (e) {\n      // If an error was thrown, we do nothing.\n      // The method will return false if it did not work.\n    }\n\n    // Return result\n    return result;\n  }\n\n  /**\n   * Clears localStorage, if available.\n   * @function removeAll\n   * @returns {boolean} Returns true if removal was possible.\n   */\n  static removeAll () {\n    // Set default value to false.\n    let result = false;\n    // Is localStorage available?\n    if (Storage.available()) {\n      // Clear the localStorage\n      window.localStorage.clear();\n      // Record result\n      result = true;\n    }\n    // Return result\n    return result;\n  }\n}\n\nmodule.exports = Storage;\n\n\n/***/ }),\n\n/***/ 3213:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n/**\n * @external Element\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Element}\n */\nconst $ = __webpack_require__(9755);\nconst Passage = __webpack_require__(1067);\nconst Markdown = __webpack_require__(9456);\nconst State = __webpack_require__(5213);\nconst History = __webpack_require__(1201);\nconst Storylets = __webpack_require__(2444);\nconst Script = __webpack_require__(5827);\nconst Sidebar = __webpack_require__(2879);\nconst Screen = __webpack_require__(1675);\nconst Storage = __webpack_require__(6505);\n\n/**\n * An object representing the entire story. After the document has completed\n * loading, an instance of this class will be available at `window.Story`.\n * @class Story\n */\nclass Story {\n  constructor () {\n    /**\n     * @property {string} name - The name of the story.\n     * @type {string}\n     * @readonly\n     */\n    this.name = $('tw-storydata').attr('name');\n\n    /**\n     * An array of all passages.\n     * @property {Array} passages - Passages array.\n     * @type {Array}\n     */\n    this.passages = [];\n\n    // For each child element of the `<tw-storydata>` element,\n    //  create a new Passage object based on its attributes.\n    $('tw-storydata').children('tw-passagedata').each((index, element) => {\n      // Convert Element into jQuery Element.\n      const elementReference = $(element);\n      // Access any potential tags.\n      let tags = elementReference.attr('tags');\n\n      // Does the 'tags' attribute exist?\n      if (tags !== '' && tags !== undefined) {\n        // Attempt to split by space.\n        tags = tags.split(' ');\n      } else {\n        // It did not exist, so we create it as an empty array.\n        tags = [];\n      }\n\n      // Push the new passage.\n      this.passages.push(new Passage(\n        elementReference.attr('name'),\n        tags,\n        Markdown.unescape(elementReference.html())\n      ));\n    });\n\n    /**\n     * Passage element.\n     * @property {Element} passageElement Passage element.\n     * @type {Element}\n     */\n    this.passageElement = $('tw-passage');\n\n    /**\n     * Sidebar.\n     * @property {Element} sidebar Sidebar instance.\n     * @type {Element}\n     */\n    this.sidebar = new Sidebar();\n\n    // Reset History.\n    History.reset();\n\n    /**\n     * History reference.\n     * @property {History} history Reference to History.\n     * @type {History}\n     */\n    this.history = History;\n\n    /**\n     * Screen reference.\n     * @property {Screen} screen Reference to Screen.\n     * @type {Screen}\n     */\n    this.screen = Screen;\n\n    /**\n     * Storage reference.\n     * @property {Storage} screen Reference to Storage.\n     * @type {Storage}\n     */\n    this.storage = Storage;\n\n    // Reset State.\n    State.reset();\n\n    /**\n     * State.events reference.\n     * @property {EventEmitter} events Reference to State.events.\n     * @type {EventEmitter}\n     */\n    this.events = State.events;\n\n    /**\n     * State.store reference.\n     * @property {Proxy} store Reference to State.store.\n     * @type {Proxy}\n     */\n    this.store = State.store;\n\n    // Listen for redo events.\n    State.events.on('redo', () => {\n      // Attempt to redo history.\n      const passageName = History.redo();\n      // If redo failed, name will be null.\n      if (passageName !== null) {\n        // Check if at end of collection.\n        if (History.position === History.history.length - 1) {\n          // Hide redo.\n          this.sidebar.hideRedo();\n          // Show undo.\n          this.sidebar.showUndo();\n        }\n        // Not null, show previous passage.\n        this.show(passageName);\n      }\n    });\n\n    // Listen for undo events.\n    State.events.on('undo', () => {\n      // Show redo if undo is clicked.\n      this.sidebar.showRedo();\n      // Attempt to undo history.\n      const passageName = History.undo();\n      // If undo failed, name will be null.\n      if (passageName !== null) {\n        // Check if at beginning of collection.\n        if (History.position === 0) {\n          // Hide undo\n          this.sidebar.hideUndo();\n        }\n        // Not null, show previous passage.\n        this.show(passageName);\n      }\n    });\n\n    /**\n     * The current passage.\n     * @property {Passage|null} currentPassage Currently showing passage, if any.\n     * @type {Passage|null}\n     */\n    this.currentPassage = null;\n\n    /**\n     * Reference to internal Storylets object.\n     *\n     * Starts as null. During Story.start(), a new object is\n     * created based on initial passages.\n     * @property {Storylets} storylets Internal reference to Storylets\n     * @type {Storylets|null}\n     */\n    this.storylets = null;\n  }\n\n  /**\n   * Begins playing this story based on data from tw-storydata.\n   * 1. Apply all user styles\n   * 2. Run all user scripts\n   * 3. Find starting passage\n   * 4. Add to starting passage to History.history\n   * 5. Show starting passage\n   * 6. Trigger 'start' event\n   * @function start\n   */\n  start () {\n    // Find all passages with the tag 'storylet'.\n    const passageList = this.getPassagesByTag('storylet');\n    // Generate initial Storylets collection.\n    this.storylets = new Storylets(passageList);\n\n    // For each Twine style, add them to the body as extra style elements.\n    $('*[type=\"text/twine-css\"]').each((index, element) => {\n      // Convert from Element into jQuery Element.\n      const twineStyleElement = $(element);\n      // Append a new `<style>` with text from old.\n      $(document.body).append(`<style>${twineStyleElement.text()}</style>`);\n    });\n\n    /**\n     * Note: Browsers prevent error catching from scripts\n     *  added after the initial loading.\n     *\n     * window.onerror will have error, but it cannot\n     *  be caught.\n     */\n    $('*[type=\"text/twine-javascript\"]').each((index, element) => {\n      // Convert Element into jQuery Element.\n      const twineScriptElement = $(element);\n      // Create a new `<script>`.\n      const newScriptElement = $('<script>');\n      // Set the text of new from old.\n      newScriptElement.text(twineScriptElement.text());\n      // Append the new `<script>` with text to document body.\n      $(document.body).append(newScriptElement);\n    });\n\n    // Get the startnode value (which is a number).\n    const startingPassageID = parseInt($('tw-storydata').attr('startnode'));\n    // Use the PID to find the name of the starting passage based on elements.\n    const startPassage = $(`[pid=\"${startingPassageID}\"]`).attr('name');\n    // Search for the starting passage.\n    const passage = this.getPassageByName(startPassage);\n\n    // Does the starting passage exist?\n    if (passage === null) {\n      // It does not exist.\n      // Throw an error.\n      throw new Error('Starting passage does not exist!');\n    }\n\n    // Add to the history.\n    History.add(passage.name);\n\n    // Set the global passage to the one about to be shown.\n    this.currentPassage = passage;\n\n    // Overwrite current tags\n    this.passageElement.attr('tags', passage.tags);\n\n    // Get passage source.\n    const passageSource = this.include(passage.name);\n\n    // Overwrite the parsed with the rendered.\n    this.passageElement.html(passageSource);\n\n    // Listen for any reader clicking on `<tw-link>`.\n    $('tw-link[data-passage]').on('click', (event) => {\n      // Convert Element into jQuery Element.\n      const jEl = $(event.target);\n      // Retrieve data-passage value.\n      const passageName = jEl.attr('data-passage');\n      // Add to the history.\n      History.add(passageName);\n      // Hide the redo icon.\n      this.sidebar.hideRedo();\n      // Show the undo icon.\n      this.sidebar.showUndo();\n      // Show the passage by name.\n      this.show(passageName);\n    });\n\n    /**\n     * Triggered when the story starts.\n     * @event State#start\n     * @type {string}\n     */\n    State.events.emit('start', passage.name);\n  }\n\n  /**\n   * Returns an array of none, one, or many passages matching a specific tag.\n   * @function getPassagesByTag\n   * @param {string} tag - Tag to search for.\n   * @returns {Array} Array containing none, one, or many passage objects.\n   */\n  getPassagesByTag (tag) {\n    // Search internal passages\n    return this.passages.filter((p) => {\n      return p.tags.includes(tag);\n    });\n  }\n\n  /**\n   * Returns a Passage object by name from internal collection. If none exists, returns null.\n   * The Twine editor prevents multiple passages from having the same name, so\n   * this always returns the first search result.\n   * @function getPassageByName\n   * @param {string} name - name of the passage\n   * @returns {Passage|null} Passage object or null\n   */\n  getPassageByName (name) {\n    // Create default value\n    let passage = null;\n\n    // Search for any passages with the name\n    const result = this.passages.filter((p) => p.name === name);\n\n    // Were any found?\n    if (result.length !== 0) {\n      // Grab the first result.\n      passage = result[0];\n    }\n\n    // Return either null or first result found.\n    return passage;\n  }\n\n  /**\n   * Replaces current passage shown to reader with rendered source of named passage.\n   * If the named passage does not exist, an error is thrown.\n   * @function show\n   * @param {string} name name of the passage.\n   */\n  show (name) {\n    // Look for passage by name.\n    const passage = this.getPassageByName(name);\n\n    // passage will be null if it was not found.\n    if (passage === null) {\n      // Passage was not found.\n      // Throw error.\n      throw new Error(`There is no passage with the name ${name}`);\n    }\n\n    // Set currentPassage to the one about to be shown.\n    this.currentPassage = passage;\n\n    // Overwrite current tags.\n    this.passageElement.attr('tags', passage.tags);\n\n    // Get passage source by name.\n    const passageSource = this.include(passage.name);\n\n    // Overwrite any existing HTML.\n    this.passageElement.html(passageSource);\n\n    // Listen for any reader clicking on `<tw-link>`.\n    $('tw-link[data-passage]').on('click', (event) => {\n      // Convert Element into jQuery Element.\n      const jEl = $(event.target);\n      // Retrieve data-passage value.\n      const passageName = jEl.attr('data-passage');\n      // Add to the history.\n      History.add(passageName);\n      // Hide the redo icon.\n      this.sidebar.hideRedo();\n      // Show the undo icon.\n      this.sidebar.showUndo();\n      // Show the passage by name.\n      this.show(passageName);\n    });\n\n    /**\n     * Triggered when a passage is shown.\n     * @event State#show\n     * @type {string}\n     */\n    State.events.emit('show', passage.name);\n  }\n\n  /**\n   * Returns the rendered source of a passage by name.\n   * @function include\n   * @param {string} name - name of the passage.\n   * @returns {string} Rendered passage source.\n   */\n  include (name) {\n    // Search for passage by name.\n    const passage = this.getPassageByName(name);\n\n    // Does this passage exist?\n    if (passage === null) {\n      // It does not exist.\n      // Throw error.\n      throw new Error('There is no passage with name ' + name);\n    }\n\n    // Get passage source.\n    let passageSource = passage.source;\n\n    // Run any script.\n    passageSource = Script.run(passageSource, this);\n\n    // Parse any Markdown.\n    passageSource = Markdown.parse(passageSource);\n\n    // Run the Markdown conversion.\n    passageSource = Markdown.convert(passageSource);\n\n    // Return the passage source.\n    return passageSource;\n  }\n\n  /**\n   * Render a passage to any/all element(s) matching query selector\n   * @function renderPassageToSelector\n   * @param {object} passageName - The passage to render\n   * @param {string} selector - jQuery selector\n   */\n  renderPassageToSelector (passageName, selector) {\n    // Get passage source\n    const passageSource = this.include(passageName);\n\n    // Replace the HTML of the selector (if valid).\n    $(selector).html(passageSource);\n  }\n\n  /**\n   * Add a new passage to the story.\n   * @function addPassage\n   * @param {string} name name\n   * @param {Array} tags tags\n   * @param {string} source source\n   */\n  addPassage (name = '', tags = [], source = '') {\n    // Look for name.\n    const nameSearch = this.getPassageByName(name);\n\n    // Confirm name does not already exist.\n    if (nameSearch !== null) {\n      throw new Error('Cannot add two passages with the same name!');\n    }\n\n    // Confirm tags is an array.\n    if (!Array.isArray(tags)) {\n      // Ignore and set to empty array.\n      tags = [];\n    }\n\n    // Confirm if source is string.\n    if (Object.prototype.toString.call(source) !== '[object String]') {\n      // Ignore and set to empty string.\n      source = '';\n    }\n\n    // Add to the existing passages.\n    this.passages.push(new Passage(\n      name,\n      tags,\n      Markdown.unescape(source)\n    ));\n  }\n\n  /**\n   * Remove a passage from the story internal collection.\n   * Removing a passage and then attempting to visit the passage will\n   * throw an error.\n   *\n   * Note: Does not affect HTML elements.\n   * @function removePassage\n   * @param {string} name name\n   */\n  removePassage (name = '') {\n    this.passages = this.passages.filter(passage => {\n      return passage.name !== name;\n    });\n  }\n\n  /**\n   * Go to an existing passage in the story. Unlike `Story.show()`, this will add to the history.\n   *\n   * Throws error if passage does not exist.\n   * @function goto\n   * @param {string} name name of passage\n   */\n  goto (name = '') {\n    // Look for passage.\n    const passage = this.getPassageByName(name);\n\n    // Does passage exist?\n    if (passage === null) {\n      // Throw error.\n      throw new Error(`There is no passage with the name ${name}`);\n    }\n\n    // Add to the history.\n    History.add(name);\n\n    // Hide the redo icon.\n    this.sidebar.hideRedo();\n\n    // Show the passage by name.\n    this.show(name);\n  }\n}\n\nmodule.exports = Story;\n\n\n/***/ }),\n\n/***/ 2444:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst { Query } = __webpack_require__(6090);\nconst State = __webpack_require__(5213);\n\n/**\n * An object containing none, one, or multiple passages based\n * on their use of the 'storylet' passage tag and `<requirements>` element.\n * @class Storylets\n */\nclass Storylets {\n  constructor (storyPassages = []) {\n    // Internal array of passages.\n    this.passages = [];\n\n    // Is storyPassages an array?\n    if (!Array.isArray(storyPassages)) {\n      // If not, make it an empty array.\n      storyPassages = [];\n    }\n\n    // For each, look for the <requirements> element in their source.\n    for (const passageEntry of storyPassages) {\n      // Double-check each object has a 'source' property.\n      if (Object.prototype.hasOwnProperty.call(passageEntry, 'source')) {\n        // Find the element and replace it with an empty string.\n        const searchedSource = passageEntry.source.replace(/<requirements>([^>]*?)<\\/requirements>/gmi, (match, captured) => {\n          // Set a default object if JSON parsing fails.\n          let passageRequirements = {};\n\n          // Attempt JSON parsing, which can throw error on failure.\n          try {\n            // Try to parse string into object\n            passageRequirements = JSON.parse(captured);\n          } catch (e) {\n            // Ignore the error\n          }\n\n          // Set default priority for all cards.\n          let passagePriority = 0;\n\n          // Look for priority property.\n          // First, are there any keys?\n          if (Object.keys(passageRequirements).length > 0) {\n            // Second, does the 'priority' property exist?\n            if (Object.prototype.hasOwnProperty.call(passageRequirements, 'priority')) {\n              // Update priority.\n              passagePriority = passageRequirements.priority;\n              // Remove priority.\n              delete passageRequirements.priority;\n            }\n          }\n\n          // Add the passage to the internal array.\n          this.passages.push(\n            {\n              passage: passageEntry,\n              requirements: passageRequirements,\n              priority: passagePriority\n            }\n          );\n\n          // Return empty string, removing it from the passage source.\n          return '';\n        });\n\n        // Overwrite previous source with removed <requirements> element.\n        passageEntry.source = searchedSource;\n      }\n    }\n  }\n\n  /**\n   * For each passage in the internal collection,\n   * test their requirements against State.store.\n   *\n   * Returns highest priority passages first.\n   * @function getAvailablePassages\n   * @param {number} limit Number of passages to return\n   * @returns {Array} Array of none, one, or many available passages.\n   */\n  getAvailablePassages (limit = 0) {\n    // Create results array.\n    let results = [];\n\n    // Force argument into number.\n    limit = parseInt(limit);\n\n    // For each passage, test its requirements against State.store.\n    this.passages.forEach(entry => {\n      // Pull the requirements.\n      const requirements = entry.requirements;\n      // Create a query based on requirements.\n      const query = new Query(requirements);\n      // Test against State.store AND make sure there are search properties.\n      // As requirements can be an empty object, we need to protect against it.\n      if (query.test(State.store) && Object.keys(requirements).length > 0) {\n        // Add the element to the results.\n        results.push(entry);\n      }\n    });\n\n    // Sort results by priority.\n    results.sort((a, b) => b.priority - a.priority);\n\n    // Slice the results based on limit argument.\n    if (limit !== 0) {\n      results = results.slice(0, limit);\n    }\n\n    // Return either all or sliced results.\n    return results;\n  }\n\n  /**\n   * Add a passage to the Storylets collection.\n   * @function addPassage\n   * @param {string} newName Name of existing passage to add.\n   * @param {object} newRequirements Requirements of passage.\n   * @param {number} newPriority Priority of passage compared to other available.\n   */\n  addPassage (newName = '', newRequirements = {}, newPriority = 0) {\n    // Check if passage exists in Story.\n    const newPassage = window.Story.getPassageByName(newName);\n\n    // If the passage was not found, throw an error.\n    if (newPassage == null) {\n      throw new Error('Passage must exist in Story to be added to Storylets collection');\n    }\n\n    // Test if passage exists in Storylets collection.\n    if (this.includes(newName)) {\n      throw new Error('Cannot add same passage twice to Storylets collection.');\n    }\n\n    // Verify newRequirements is an object.\n    if (!(newRequirements && typeof newRequirements === 'object' && newRequirements.constructor === Object)) {\n      // Ignore and set to empty object.\n      newRequirements = {};\n    }\n\n    // Force parse newPriority into a number.\n    newPriority = parseInt(newPriority);\n\n    // Add the new, existing passage along with its requirements and priority.\n    this.passages.push(\n      {\n        passage: newPassage,\n        requirements: newRequirements,\n        priority: newPriority\n      }\n    );\n  }\n\n  /**\n   * Returns if Storylets collection already contains passage name or not.\n   *\n   * As passage names are unique to a story, the Storylets collection\n   * cannot hold two entries with the same name.\n   * @function includes\n   * @param {string} name Name of passage to search.\n   * @returns {boolean} True if passage is in collection.\n   */\n  includes (name = '') {\n    // Filter for passage name.\n    const passageList = this.passages.filter((entry) => {\n      return entry.passage.name === name;\n    });\n\n    // Return if passage was found.\n    return (passageList.length > 0);\n  }\n\n  /**\n   * Remove a passage from the collection by name.\n   * @function removePassage\n   * @param {string} name Name of existing passage to remove.\n   */\n  removePassage (name = '') {\n    this.passages = this.passages.filter((entry) => {\n      return entry.passage.name !== name;\n    });\n  }\n}\n\nmodule.exports = Storylets;\n\n\n/***/ }),\n\n/***/ 5543:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(9755);\n\nclass Utilities {\n  /**\n   * Accepts a function, wait, and optional set of arguments.\n   * After the wait, the function will run with the passed arguments.\n   * @function delay\n   * @param {Function}    func    Function to run.\n   * @param {number}      wait    Number of milliseconds to wait.\n   * @param {any}         [args]  Optional arguments to pass to the function.\n   * @returns {number}            Identification of timer returned from setTimeout().\n   */\n  static delay (func, wait, ...args) {\n    const boundFunction = func.bind(func);\n    return setTimeout(boundFunction, wait, ...args);\n  }\n\n  /**\n   * Accepts mixed input of arrays or comma-separated list of values and returns a random entry.\n   * Will return null when given no arguments.\n   *\n   * Examples:\n   * - either(1,2,3);\n   * - either(1,[2],[4,5]);\n   * @function either\n   * @param   {object|Array} args Array or comma-separated list.\n   * @returns {object|null}       Random entry or null.\n   */\n  static either (...args) {\n    let tempArray = [];\n    let result = null;\n\n    // For every entry...\n    for (const entry of args) {\n      // If it is not an array...\n      if (!(entry instanceof Array)) {\n        // push the entry into the temporary array.\n        tempArray.push(entry);\n      } else {\n        // Spread out any subentries and add them to temporary array.\n        tempArray = [...tempArray, ...entry];\n      }\n    }\n\n    // Check if any entries were added.\n    if (tempArray.length > 0) {\n      // If they were, grab one of them.\n      result = tempArray[Math.floor(Math.random() * tempArray.length)];\n    }\n\n    // Return either null (no entries) or random entry.\n    return result;\n  }\n\n  /**\n   * Applies external CSS files.\n   * @function applyExternalStyles\n   * @param {Array} files Array of one or more external files to load.\n   */\n  static applyExternalStyles (files) {\n    if (Array.isArray(files)) {\n      files.forEach(location => {\n        $('<link/>', {\n          rel: 'stylesheet',\n          type: 'text/css',\n          href: location\n        }).appendTo('head');\n      });\n    } else {\n      throw new Error('Method only accepts an array!');\n    }\n  }\n\n  /**\n   * Return random integer within range.\n   * @function randomInt\n   * @param   {number}  min   Start of range (default 0).\n   * @param   {number}  max   End of range (default 0).\n   * @returns {number}        Number in range.\n   */\n  static randomInt (min = 0, max = 0) {\n    // Round up to min.\n    min = Math.ceil(min);\n    // Round down to max.\n    max = Math.floor(max);\n\n    // Is min greater than max?\n    if (min > max) {\n      max = min;\n      min = 0;\n    }\n\n    return Math.floor(Math.random() * (max - min)) + min;\n  }\n}\n\nmodule.exports = Utilities;\n\n\n/***/ }),\n\n/***/ 7790:\n/***/ (() => {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ 5272:\n/***/ (() => {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ 3558:\n/***/ ((module) => {\n\n\"use strict\";\nmodule.exports = {\"i8\":\"3.1.9\"};\n\n/***/ }),\n\n/***/ 9323:\n/***/ ((module) => {\n\n\"use strict\";\nmodule.exports = JSON.parse('{\"Aacute\":\"Á\",\"aacute\":\"á\",\"Abreve\":\"Ă\",\"abreve\":\"ă\",\"ac\":\"∾\",\"acd\":\"∿\",\"acE\":\"∾̳\",\"Acirc\":\"Â\",\"acirc\":\"â\",\"acute\":\"´\",\"Acy\":\"А\",\"acy\":\"а\",\"AElig\":\"Æ\",\"aelig\":\"æ\",\"af\":\"⁡\",\"Afr\":\"𝔄\",\"afr\":\"𝔞\",\"Agrave\":\"À\",\"agrave\":\"à\",\"alefsym\":\"ℵ\",\"aleph\":\"ℵ\",\"Alpha\":\"Α\",\"alpha\":\"α\",\"Amacr\":\"Ā\",\"amacr\":\"ā\",\"amalg\":\"⨿\",\"amp\":\"&\",\"AMP\":\"&\",\"andand\":\"⩕\",\"And\":\"⩓\",\"and\":\"∧\",\"andd\":\"⩜\",\"andslope\":\"⩘\",\"andv\":\"⩚\",\"ang\":\"∠\",\"ange\":\"⦤\",\"angle\":\"∠\",\"angmsdaa\":\"⦨\",\"angmsdab\":\"⦩\",\"angmsdac\":\"⦪\",\"angmsdad\":\"⦫\",\"angmsdae\":\"⦬\",\"angmsdaf\":\"⦭\",\"angmsdag\":\"⦮\",\"angmsdah\":\"⦯\",\"angmsd\":\"∡\",\"angrt\":\"∟\",\"angrtvb\":\"⊾\",\"angrtvbd\":\"⦝\",\"angsph\":\"∢\",\"angst\":\"Å\",\"angzarr\":\"⍼\",\"Aogon\":\"Ą\",\"aogon\":\"ą\",\"Aopf\":\"𝔸\",\"aopf\":\"𝕒\",\"apacir\":\"⩯\",\"ap\":\"≈\",\"apE\":\"⩰\",\"ape\":\"≊\",\"apid\":\"≋\",\"apos\":\"\\'\",\"ApplyFunction\":\"⁡\",\"approx\":\"≈\",\"approxeq\":\"≊\",\"Aring\":\"Å\",\"aring\":\"å\",\"Ascr\":\"𝒜\",\"ascr\":\"𝒶\",\"Assign\":\"≔\",\"ast\":\"*\",\"asymp\":\"≈\",\"asympeq\":\"≍\",\"Atilde\":\"Ã\",\"atilde\":\"ã\",\"Auml\":\"Ä\",\"auml\":\"ä\",\"awconint\":\"∳\",\"awint\":\"⨑\",\"backcong\":\"≌\",\"backepsilon\":\"϶\",\"backprime\":\"‵\",\"backsim\":\"∽\",\"backsimeq\":\"⋍\",\"Backslash\":\"∖\",\"Barv\":\"⫧\",\"barvee\":\"⊽\",\"barwed\":\"⌅\",\"Barwed\":\"⌆\",\"barwedge\":\"⌅\",\"bbrk\":\"⎵\",\"bbrktbrk\":\"⎶\",\"bcong\":\"≌\",\"Bcy\":\"Б\",\"bcy\":\"б\",\"bdquo\":\"„\",\"becaus\":\"∵\",\"because\":\"∵\",\"Because\":\"∵\",\"bemptyv\":\"⦰\",\"bepsi\":\"϶\",\"bernou\":\"ℬ\",\"Bernoullis\":\"ℬ\",\"Beta\":\"Β\",\"beta\":\"β\",\"beth\":\"ℶ\",\"between\":\"≬\",\"Bfr\":\"𝔅\",\"bfr\":\"𝔟\",\"bigcap\":\"⋂\",\"bigcirc\":\"◯\",\"bigcup\":\"⋃\",\"bigodot\":\"⨀\",\"bigoplus\":\"⨁\",\"bigotimes\":\"⨂\",\"bigsqcup\":\"⨆\",\"bigstar\":\"★\",\"bigtriangledown\":\"▽\",\"bigtriangleup\":\"△\",\"biguplus\":\"⨄\",\"bigvee\":\"⋁\",\"bigwedge\":\"⋀\",\"bkarow\":\"⤍\",\"blacklozenge\":\"⧫\",\"blacksquare\":\"▪\",\"blacktriangle\":\"▴\",\"blacktriangledown\":\"▾\",\"blacktriangleleft\":\"◂\",\"blacktriangleright\":\"▸\",\"blank\":\"␣\",\"blk12\":\"▒\",\"blk14\":\"░\",\"blk34\":\"▓\",\"block\":\"█\",\"bne\":\"=⃥\",\"bnequiv\":\"≡⃥\",\"bNot\":\"⫭\",\"bnot\":\"⌐\",\"Bopf\":\"𝔹\",\"bopf\":\"𝕓\",\"bot\":\"⊥\",\"bottom\":\"⊥\",\"bowtie\":\"⋈\",\"boxbox\":\"⧉\",\"boxdl\":\"┐\",\"boxdL\":\"╕\",\"boxDl\":\"╖\",\"boxDL\":\"╗\",\"boxdr\":\"┌\",\"boxdR\":\"╒\",\"boxDr\":\"╓\",\"boxDR\":\"╔\",\"boxh\":\"─\",\"boxH\":\"═\",\"boxhd\":\"┬\",\"boxHd\":\"╤\",\"boxhD\":\"╥\",\"boxHD\":\"╦\",\"boxhu\":\"┴\",\"boxHu\":\"╧\",\"boxhU\":\"╨\",\"boxHU\":\"╩\",\"boxminus\":\"⊟\",\"boxplus\":\"⊞\",\"boxtimes\":\"⊠\",\"boxul\":\"┘\",\"boxuL\":\"╛\",\"boxUl\":\"╜\",\"boxUL\":\"╝\",\"boxur\":\"└\",\"boxuR\":\"╘\",\"boxUr\":\"╙\",\"boxUR\":\"╚\",\"boxv\":\"│\",\"boxV\":\"║\",\"boxvh\":\"┼\",\"boxvH\":\"╪\",\"boxVh\":\"╫\",\"boxVH\":\"╬\",\"boxvl\":\"┤\",\"boxvL\":\"╡\",\"boxVl\":\"╢\",\"boxVL\":\"╣\",\"boxvr\":\"├\",\"boxvR\":\"╞\",\"boxVr\":\"╟\",\"boxVR\":\"╠\",\"bprime\":\"‵\",\"breve\":\"˘\",\"Breve\":\"˘\",\"brvbar\":\"¦\",\"bscr\":\"𝒷\",\"Bscr\":\"ℬ\",\"bsemi\":\"⁏\",\"bsim\":\"∽\",\"bsime\":\"⋍\",\"bsolb\":\"⧅\",\"bsol\":\"\\\\\\\\\",\"bsolhsub\":\"⟈\",\"bull\":\"•\",\"bullet\":\"•\",\"bump\":\"≎\",\"bumpE\":\"⪮\",\"bumpe\":\"≏\",\"Bumpeq\":\"≎\",\"bumpeq\":\"≏\",\"Cacute\":\"Ć\",\"cacute\":\"ć\",\"capand\":\"⩄\",\"capbrcup\":\"⩉\",\"capcap\":\"⩋\",\"cap\":\"∩\",\"Cap\":\"⋒\",\"capcup\":\"⩇\",\"capdot\":\"⩀\",\"CapitalDifferentialD\":\"ⅅ\",\"caps\":\"∩︀\",\"caret\":\"⁁\",\"caron\":\"ˇ\",\"Cayleys\":\"ℭ\",\"ccaps\":\"⩍\",\"Ccaron\":\"Č\",\"ccaron\":\"č\",\"Ccedil\":\"Ç\",\"ccedil\":\"ç\",\"Ccirc\":\"Ĉ\",\"ccirc\":\"ĉ\",\"Cconint\":\"∰\",\"ccups\":\"⩌\",\"ccupssm\":\"⩐\",\"Cdot\":\"Ċ\",\"cdot\":\"ċ\",\"cedil\":\"¸\",\"Cedilla\":\"¸\",\"cemptyv\":\"⦲\",\"cent\":\"¢\",\"centerdot\":\"·\",\"CenterDot\":\"·\",\"cfr\":\"𝔠\",\"Cfr\":\"ℭ\",\"CHcy\":\"Ч\",\"chcy\":\"ч\",\"check\":\"✓\",\"checkmark\":\"✓\",\"Chi\":\"Χ\",\"chi\":\"χ\",\"circ\":\"ˆ\",\"circeq\":\"≗\",\"circlearrowleft\":\"↺\",\"circlearrowright\":\"↻\",\"circledast\":\"⊛\",\"circledcirc\":\"⊚\",\"circleddash\":\"⊝\",\"CircleDot\":\"⊙\",\"circledR\":\"®\",\"circledS\":\"Ⓢ\",\"CircleMinus\":\"⊖\",\"CirclePlus\":\"⊕\",\"CircleTimes\":\"⊗\",\"cir\":\"○\",\"cirE\":\"⧃\",\"cire\":\"≗\",\"cirfnint\":\"⨐\",\"cirmid\":\"⫯\",\"cirscir\":\"⧂\",\"ClockwiseContourIntegral\":\"∲\",\"CloseCurlyDoubleQuote\":\"”\",\"CloseCurlyQuote\":\"’\",\"clubs\":\"♣\",\"clubsuit\":\"♣\",\"colon\":\":\",\"Colon\":\"∷\",\"Colone\":\"⩴\",\"colone\":\"≔\",\"coloneq\":\"≔\",\"comma\":\",\",\"commat\":\"@\",\"comp\":\"∁\",\"compfn\":\"∘\",\"complement\":\"∁\",\"complexes\":\"ℂ\",\"cong\":\"≅\",\"congdot\":\"⩭\",\"Congruent\":\"≡\",\"conint\":\"∮\",\"Conint\":\"∯\",\"ContourIntegral\":\"∮\",\"copf\":\"𝕔\",\"Copf\":\"ℂ\",\"coprod\":\"∐\",\"Coproduct\":\"∐\",\"copy\":\"©\",\"COPY\":\"©\",\"copysr\":\"℗\",\"CounterClockwiseContourIntegral\":\"∳\",\"crarr\":\"↵\",\"cross\":\"✗\",\"Cross\":\"⨯\",\"Cscr\":\"𝒞\",\"cscr\":\"𝒸\",\"csub\":\"⫏\",\"csube\":\"⫑\",\"csup\":\"⫐\",\"csupe\":\"⫒\",\"ctdot\":\"⋯\",\"cudarrl\":\"⤸\",\"cudarrr\":\"⤵\",\"cuepr\":\"⋞\",\"cuesc\":\"⋟\",\"cularr\":\"↶\",\"cularrp\":\"⤽\",\"cupbrcap\":\"⩈\",\"cupcap\":\"⩆\",\"CupCap\":\"≍\",\"cup\":\"∪\",\"Cup\":\"⋓\",\"cupcup\":\"⩊\",\"cupdot\":\"⊍\",\"cupor\":\"⩅\",\"cups\":\"∪︀\",\"curarr\":\"↷\",\"curarrm\":\"⤼\",\"curlyeqprec\":\"⋞\",\"curlyeqsucc\":\"⋟\",\"curlyvee\":\"⋎\",\"curlywedge\":\"⋏\",\"curren\":\"¤\",\"curvearrowleft\":\"↶\",\"curvearrowright\":\"↷\",\"cuvee\":\"⋎\",\"cuwed\":\"⋏\",\"cwconint\":\"∲\",\"cwint\":\"∱\",\"cylcty\":\"⌭\",\"dagger\":\"†\",\"Dagger\":\"‡\",\"daleth\":\"ℸ\",\"darr\":\"↓\",\"Darr\":\"↡\",\"dArr\":\"⇓\",\"dash\":\"‐\",\"Dashv\":\"⫤\",\"dashv\":\"⊣\",\"dbkarow\":\"⤏\",\"dblac\":\"˝\",\"Dcaron\":\"Ď\",\"dcaron\":\"ď\",\"Dcy\":\"Д\",\"dcy\":\"д\",\"ddagger\":\"‡\",\"ddarr\":\"⇊\",\"DD\":\"ⅅ\",\"dd\":\"ⅆ\",\"DDotrahd\":\"⤑\",\"ddotseq\":\"⩷\",\"deg\":\"°\",\"Del\":\"∇\",\"Delta\":\"Δ\",\"delta\":\"δ\",\"demptyv\":\"⦱\",\"dfisht\":\"⥿\",\"Dfr\":\"𝔇\",\"dfr\":\"𝔡\",\"dHar\":\"⥥\",\"dharl\":\"⇃\",\"dharr\":\"⇂\",\"DiacriticalAcute\":\"´\",\"DiacriticalDot\":\"˙\",\"DiacriticalDoubleAcute\":\"˝\",\"DiacriticalGrave\":\"`\",\"DiacriticalTilde\":\"˜\",\"diam\":\"⋄\",\"diamond\":\"⋄\",\"Diamond\":\"⋄\",\"diamondsuit\":\"♦\",\"diams\":\"♦\",\"die\":\"¨\",\"DifferentialD\":\"ⅆ\",\"digamma\":\"ϝ\",\"disin\":\"⋲\",\"div\":\"÷\",\"divide\":\"÷\",\"divideontimes\":\"⋇\",\"divonx\":\"⋇\",\"DJcy\":\"Ђ\",\"djcy\":\"ђ\",\"dlcorn\":\"⌞\",\"dlcrop\":\"⌍\",\"dollar\":\"$\",\"Dopf\":\"𝔻\",\"dopf\":\"𝕕\",\"Dot\":\"¨\",\"dot\":\"˙\",\"DotDot\":\"⃜\",\"doteq\":\"≐\",\"doteqdot\":\"≑\",\"DotEqual\":\"≐\",\"dotminus\":\"∸\",\"dotplus\":\"∔\",\"dotsquare\":\"⊡\",\"doublebarwedge\":\"⌆\",\"DoubleContourIntegral\":\"∯\",\"DoubleDot\":\"¨\",\"DoubleDownArrow\":\"⇓\",\"DoubleLeftArrow\":\"⇐\",\"DoubleLeftRightArrow\":\"⇔\",\"DoubleLeftTee\":\"⫤\",\"DoubleLongLeftArrow\":\"⟸\",\"DoubleLongLeftRightArrow\":\"⟺\",\"DoubleLongRightArrow\":\"⟹\",\"DoubleRightArrow\":\"⇒\",\"DoubleRightTee\":\"⊨\",\"DoubleUpArrow\":\"⇑\",\"DoubleUpDownArrow\":\"⇕\",\"DoubleVerticalBar\":\"∥\",\"DownArrowBar\":\"⤓\",\"downarrow\":\"↓\",\"DownArrow\":\"↓\",\"Downarrow\":\"⇓\",\"DownArrowUpArrow\":\"⇵\",\"DownBreve\":\"̑\",\"downdownarrows\":\"⇊\",\"downharpoonleft\":\"⇃\",\"downharpoonright\":\"⇂\",\"DownLeftRightVector\":\"⥐\",\"DownLeftTeeVector\":\"⥞\",\"DownLeftVectorBar\":\"⥖\",\"DownLeftVector\":\"↽\",\"DownRightTeeVector\":\"⥟\",\"DownRightVectorBar\":\"⥗\",\"DownRightVector\":\"⇁\",\"DownTeeArrow\":\"↧\",\"DownTee\":\"⊤\",\"drbkarow\":\"⤐\",\"drcorn\":\"⌟\",\"drcrop\":\"⌌\",\"Dscr\":\"𝒟\",\"dscr\":\"𝒹\",\"DScy\":\"Ѕ\",\"dscy\":\"ѕ\",\"dsol\":\"⧶\",\"Dstrok\":\"Đ\",\"dstrok\":\"đ\",\"dtdot\":\"⋱\",\"dtri\":\"▿\",\"dtrif\":\"▾\",\"duarr\":\"⇵\",\"duhar\":\"⥯\",\"dwangle\":\"⦦\",\"DZcy\":\"Џ\",\"dzcy\":\"џ\",\"dzigrarr\":\"⟿\",\"Eacute\":\"É\",\"eacute\":\"é\",\"easter\":\"⩮\",\"Ecaron\":\"Ě\",\"ecaron\":\"ě\",\"Ecirc\":\"Ê\",\"ecirc\":\"ê\",\"ecir\":\"≖\",\"ecolon\":\"≕\",\"Ecy\":\"Э\",\"ecy\":\"э\",\"eDDot\":\"⩷\",\"Edot\":\"Ė\",\"edot\":\"ė\",\"eDot\":\"≑\",\"ee\":\"ⅇ\",\"efDot\":\"≒\",\"Efr\":\"𝔈\",\"efr\":\"𝔢\",\"eg\":\"⪚\",\"Egrave\":\"È\",\"egrave\":\"è\",\"egs\":\"⪖\",\"egsdot\":\"⪘\",\"el\":\"⪙\",\"Element\":\"∈\",\"elinters\":\"⏧\",\"ell\":\"ℓ\",\"els\":\"⪕\",\"elsdot\":\"⪗\",\"Emacr\":\"Ē\",\"emacr\":\"ē\",\"empty\":\"∅\",\"emptyset\":\"∅\",\"EmptySmallSquare\":\"◻\",\"emptyv\":\"∅\",\"EmptyVerySmallSquare\":\"▫\",\"emsp13\":\" \",\"emsp14\":\" \",\"emsp\":\" \",\"ENG\":\"Ŋ\",\"eng\":\"ŋ\",\"ensp\":\" \",\"Eogon\":\"Ę\",\"eogon\":\"ę\",\"Eopf\":\"𝔼\",\"eopf\":\"𝕖\",\"epar\":\"⋕\",\"eparsl\":\"⧣\",\"eplus\":\"⩱\",\"epsi\":\"ε\",\"Epsilon\":\"Ε\",\"epsilon\":\"ε\",\"epsiv\":\"ϵ\",\"eqcirc\":\"≖\",\"eqcolon\":\"≕\",\"eqsim\":\"≂\",\"eqslantgtr\":\"⪖\",\"eqslantless\":\"⪕\",\"Equal\":\"⩵\",\"equals\":\"=\",\"EqualTilde\":\"≂\",\"equest\":\"≟\",\"Equilibrium\":\"⇌\",\"equiv\":\"≡\",\"equivDD\":\"⩸\",\"eqvparsl\":\"⧥\",\"erarr\":\"⥱\",\"erDot\":\"≓\",\"escr\":\"ℯ\",\"Escr\":\"ℰ\",\"esdot\":\"≐\",\"Esim\":\"⩳\",\"esim\":\"≂\",\"Eta\":\"Η\",\"eta\":\"η\",\"ETH\":\"Ð\",\"eth\":\"ð\",\"Euml\":\"Ë\",\"euml\":\"ë\",\"euro\":\"€\",\"excl\":\"!\",\"exist\":\"∃\",\"Exists\":\"∃\",\"expectation\":\"ℰ\",\"exponentiale\":\"ⅇ\",\"ExponentialE\":\"ⅇ\",\"fallingdotseq\":\"≒\",\"Fcy\":\"Ф\",\"fcy\":\"ф\",\"female\":\"♀\",\"ffilig\":\"ffi\",\"fflig\":\"ff\",\"ffllig\":\"ffl\",\"Ffr\":\"𝔉\",\"ffr\":\"𝔣\",\"filig\":\"fi\",\"FilledSmallSquare\":\"◼\",\"FilledVerySmallSquare\":\"▪\",\"fjlig\":\"fj\",\"flat\":\"♭\",\"fllig\":\"fl\",\"fltns\":\"▱\",\"fnof\":\"ƒ\",\"Fopf\":\"𝔽\",\"fopf\":\"𝕗\",\"forall\":\"∀\",\"ForAll\":\"∀\",\"fork\":\"⋔\",\"forkv\":\"⫙\",\"Fouriertrf\":\"ℱ\",\"fpartint\":\"⨍\",\"frac12\":\"½\",\"frac13\":\"⅓\",\"frac14\":\"¼\",\"frac15\":\"⅕\",\"frac16\":\"⅙\",\"frac18\":\"⅛\",\"frac23\":\"⅔\",\"frac25\":\"⅖\",\"frac34\":\"¾\",\"frac35\":\"⅗\",\"frac38\":\"⅜\",\"frac45\":\"⅘\",\"frac56\":\"⅚\",\"frac58\":\"⅝\",\"frac78\":\"⅞\",\"frasl\":\"⁄\",\"frown\":\"⌢\",\"fscr\":\"𝒻\",\"Fscr\":\"ℱ\",\"gacute\":\"ǵ\",\"Gamma\":\"Γ\",\"gamma\":\"γ\",\"Gammad\":\"Ϝ\",\"gammad\":\"ϝ\",\"gap\":\"⪆\",\"Gbreve\":\"Ğ\",\"gbreve\":\"ğ\",\"Gcedil\":\"Ģ\",\"Gcirc\":\"Ĝ\",\"gcirc\":\"ĝ\",\"Gcy\":\"Г\",\"gcy\":\"г\",\"Gdot\":\"Ġ\",\"gdot\":\"ġ\",\"ge\":\"≥\",\"gE\":\"≧\",\"gEl\":\"⪌\",\"gel\":\"⋛\",\"geq\":\"≥\",\"geqq\":\"≧\",\"geqslant\":\"⩾\",\"gescc\":\"⪩\",\"ges\":\"⩾\",\"gesdot\":\"⪀\",\"gesdoto\":\"⪂\",\"gesdotol\":\"⪄\",\"gesl\":\"⋛︀\",\"gesles\":\"⪔\",\"Gfr\":\"𝔊\",\"gfr\":\"𝔤\",\"gg\":\"≫\",\"Gg\":\"⋙\",\"ggg\":\"⋙\",\"gimel\":\"ℷ\",\"GJcy\":\"Ѓ\",\"gjcy\":\"ѓ\",\"gla\":\"⪥\",\"gl\":\"≷\",\"glE\":\"⪒\",\"glj\":\"⪤\",\"gnap\":\"⪊\",\"gnapprox\":\"⪊\",\"gne\":\"⪈\",\"gnE\":\"≩\",\"gneq\":\"⪈\",\"gneqq\":\"≩\",\"gnsim\":\"⋧\",\"Gopf\":\"𝔾\",\"gopf\":\"𝕘\",\"grave\":\"`\",\"GreaterEqual\":\"≥\",\"GreaterEqualLess\":\"⋛\",\"GreaterFullEqual\":\"≧\",\"GreaterGreater\":\"⪢\",\"GreaterLess\":\"≷\",\"GreaterSlantEqual\":\"⩾\",\"GreaterTilde\":\"≳\",\"Gscr\":\"𝒢\",\"gscr\":\"ℊ\",\"gsim\":\"≳\",\"gsime\":\"⪎\",\"gsiml\":\"⪐\",\"gtcc\":\"⪧\",\"gtcir\":\"⩺\",\"gt\":\">\",\"GT\":\">\",\"Gt\":\"≫\",\"gtdot\":\"⋗\",\"gtlPar\":\"⦕\",\"gtquest\":\"⩼\",\"gtrapprox\":\"⪆\",\"gtrarr\":\"⥸\",\"gtrdot\":\"⋗\",\"gtreqless\":\"⋛\",\"gtreqqless\":\"⪌\",\"gtrless\":\"≷\",\"gtrsim\":\"≳\",\"gvertneqq\":\"≩︀\",\"gvnE\":\"≩︀\",\"Hacek\":\"ˇ\",\"hairsp\":\" \",\"half\":\"½\",\"hamilt\":\"ℋ\",\"HARDcy\":\"Ъ\",\"hardcy\":\"ъ\",\"harrcir\":\"⥈\",\"harr\":\"↔\",\"hArr\":\"⇔\",\"harrw\":\"↭\",\"Hat\":\"^\",\"hbar\":\"ℏ\",\"Hcirc\":\"Ĥ\",\"hcirc\":\"ĥ\",\"hearts\":\"♥\",\"heartsuit\":\"♥\",\"hellip\":\"…\",\"hercon\":\"⊹\",\"hfr\":\"𝔥\",\"Hfr\":\"ℌ\",\"HilbertSpace\":\"ℋ\",\"hksearow\":\"⤥\",\"hkswarow\":\"⤦\",\"hoarr\":\"⇿\",\"homtht\":\"∻\",\"hookleftarrow\":\"↩\",\"hookrightarrow\":\"↪\",\"hopf\":\"𝕙\",\"Hopf\":\"ℍ\",\"horbar\":\"―\",\"HorizontalLine\":\"─\",\"hscr\":\"𝒽\",\"Hscr\":\"ℋ\",\"hslash\":\"ℏ\",\"Hstrok\":\"Ħ\",\"hstrok\":\"ħ\",\"HumpDownHump\":\"≎\",\"HumpEqual\":\"≏\",\"hybull\":\"⁃\",\"hyphen\":\"‐\",\"Iacute\":\"Í\",\"iacute\":\"í\",\"ic\":\"⁣\",\"Icirc\":\"Î\",\"icirc\":\"î\",\"Icy\":\"И\",\"icy\":\"и\",\"Idot\":\"İ\",\"IEcy\":\"Е\",\"iecy\":\"е\",\"iexcl\":\"¡\",\"iff\":\"⇔\",\"ifr\":\"𝔦\",\"Ifr\":\"ℑ\",\"Igrave\":\"Ì\",\"igrave\":\"ì\",\"ii\":\"ⅈ\",\"iiiint\":\"⨌\",\"iiint\":\"∭\",\"iinfin\":\"⧜\",\"iiota\":\"℩\",\"IJlig\":\"IJ\",\"ijlig\":\"ij\",\"Imacr\":\"Ī\",\"imacr\":\"ī\",\"image\":\"ℑ\",\"ImaginaryI\":\"ⅈ\",\"imagline\":\"ℐ\",\"imagpart\":\"ℑ\",\"imath\":\"ı\",\"Im\":\"ℑ\",\"imof\":\"⊷\",\"imped\":\"Ƶ\",\"Implies\":\"⇒\",\"incare\":\"℅\",\"in\":\"∈\",\"infin\":\"∞\",\"infintie\":\"⧝\",\"inodot\":\"ı\",\"intcal\":\"⊺\",\"int\":\"∫\",\"Int\":\"∬\",\"integers\":\"ℤ\",\"Integral\":\"∫\",\"intercal\":\"⊺\",\"Intersection\":\"⋂\",\"intlarhk\":\"⨗\",\"intprod\":\"⨼\",\"InvisibleComma\":\"⁣\",\"InvisibleTimes\":\"⁢\",\"IOcy\":\"Ё\",\"iocy\":\"ё\",\"Iogon\":\"Į\",\"iogon\":\"į\",\"Iopf\":\"𝕀\",\"iopf\":\"𝕚\",\"Iota\":\"Ι\",\"iota\":\"ι\",\"iprod\":\"⨼\",\"iquest\":\"¿\",\"iscr\":\"𝒾\",\"Iscr\":\"ℐ\",\"isin\":\"∈\",\"isindot\":\"⋵\",\"isinE\":\"⋹\",\"isins\":\"⋴\",\"isinsv\":\"⋳\",\"isinv\":\"∈\",\"it\":\"⁢\",\"Itilde\":\"Ĩ\",\"itilde\":\"ĩ\",\"Iukcy\":\"І\",\"iukcy\":\"і\",\"Iuml\":\"Ï\",\"iuml\":\"ï\",\"Jcirc\":\"Ĵ\",\"jcirc\":\"ĵ\",\"Jcy\":\"Й\",\"jcy\":\"й\",\"Jfr\":\"𝔍\",\"jfr\":\"𝔧\",\"jmath\":\"ȷ\",\"Jopf\":\"𝕁\",\"jopf\":\"𝕛\",\"Jscr\":\"𝒥\",\"jscr\":\"𝒿\",\"Jsercy\":\"Ј\",\"jsercy\":\"ј\",\"Jukcy\":\"Є\",\"jukcy\":\"є\",\"Kappa\":\"Κ\",\"kappa\":\"κ\",\"kappav\":\"ϰ\",\"Kcedil\":\"Ķ\",\"kcedil\":\"ķ\",\"Kcy\":\"К\",\"kcy\":\"к\",\"Kfr\":\"𝔎\",\"kfr\":\"𝔨\",\"kgreen\":\"ĸ\",\"KHcy\":\"Х\",\"khcy\":\"х\",\"KJcy\":\"Ќ\",\"kjcy\":\"ќ\",\"Kopf\":\"𝕂\",\"kopf\":\"𝕜\",\"Kscr\":\"𝒦\",\"kscr\":\"𝓀\",\"lAarr\":\"⇚\",\"Lacute\":\"Ĺ\",\"lacute\":\"ĺ\",\"laemptyv\":\"⦴\",\"lagran\":\"ℒ\",\"Lambda\":\"Λ\",\"lambda\":\"λ\",\"lang\":\"⟨\",\"Lang\":\"⟪\",\"langd\":\"⦑\",\"langle\":\"⟨\",\"lap\":\"⪅\",\"Laplacetrf\":\"ℒ\",\"laquo\":\"«\",\"larrb\":\"⇤\",\"larrbfs\":\"⤟\",\"larr\":\"←\",\"Larr\":\"↞\",\"lArr\":\"⇐\",\"larrfs\":\"⤝\",\"larrhk\":\"↩\",\"larrlp\":\"↫\",\"larrpl\":\"⤹\",\"larrsim\":\"⥳\",\"larrtl\":\"↢\",\"latail\":\"⤙\",\"lAtail\":\"⤛\",\"lat\":\"⪫\",\"late\":\"⪭\",\"lates\":\"⪭︀\",\"lbarr\":\"⤌\",\"lBarr\":\"⤎\",\"lbbrk\":\"❲\",\"lbrace\":\"{\",\"lbrack\":\"[\",\"lbrke\":\"⦋\",\"lbrksld\":\"⦏\",\"lbrkslu\":\"⦍\",\"Lcaron\":\"Ľ\",\"lcaron\":\"ľ\",\"Lcedil\":\"Ļ\",\"lcedil\":\"ļ\",\"lceil\":\"⌈\",\"lcub\":\"{\",\"Lcy\":\"Л\",\"lcy\":\"л\",\"ldca\":\"⤶\",\"ldquo\":\"“\",\"ldquor\":\"„\",\"ldrdhar\":\"⥧\",\"ldrushar\":\"⥋\",\"ldsh\":\"↲\",\"le\":\"≤\",\"lE\":\"≦\",\"LeftAngleBracket\":\"⟨\",\"LeftArrowBar\":\"⇤\",\"leftarrow\":\"←\",\"LeftArrow\":\"←\",\"Leftarrow\":\"⇐\",\"LeftArrowRightArrow\":\"⇆\",\"leftarrowtail\":\"↢\",\"LeftCeiling\":\"⌈\",\"LeftDoubleBracket\":\"⟦\",\"LeftDownTeeVector\":\"⥡\",\"LeftDownVectorBar\":\"⥙\",\"LeftDownVector\":\"⇃\",\"LeftFloor\":\"⌊\",\"leftharpoondown\":\"↽\",\"leftharpoonup\":\"↼\",\"leftleftarrows\":\"⇇\",\"leftrightarrow\":\"↔\",\"LeftRightArrow\":\"↔\",\"Leftrightarrow\":\"⇔\",\"leftrightarrows\":\"⇆\",\"leftrightharpoons\":\"⇋\",\"leftrightsquigarrow\":\"↭\",\"LeftRightVector\":\"⥎\",\"LeftTeeArrow\":\"↤\",\"LeftTee\":\"⊣\",\"LeftTeeVector\":\"⥚\",\"leftthreetimes\":\"⋋\",\"LeftTriangleBar\":\"⧏\",\"LeftTriangle\":\"⊲\",\"LeftTriangleEqual\":\"⊴\",\"LeftUpDownVector\":\"⥑\",\"LeftUpTeeVector\":\"⥠\",\"LeftUpVectorBar\":\"⥘\",\"LeftUpVector\":\"↿\",\"LeftVectorBar\":\"⥒\",\"LeftVector\":\"↼\",\"lEg\":\"⪋\",\"leg\":\"⋚\",\"leq\":\"≤\",\"leqq\":\"≦\",\"leqslant\":\"⩽\",\"lescc\":\"⪨\",\"les\":\"⩽\",\"lesdot\":\"⩿\",\"lesdoto\":\"⪁\",\"lesdotor\":\"⪃\",\"lesg\":\"⋚︀\",\"lesges\":\"⪓\",\"lessapprox\":\"⪅\",\"lessdot\":\"⋖\",\"lesseqgtr\":\"⋚\",\"lesseqqgtr\":\"⪋\",\"LessEqualGreater\":\"⋚\",\"LessFullEqual\":\"≦\",\"LessGreater\":\"≶\",\"lessgtr\":\"≶\",\"LessLess\":\"⪡\",\"lesssim\":\"≲\",\"LessSlantEqual\":\"⩽\",\"LessTilde\":\"≲\",\"lfisht\":\"⥼\",\"lfloor\":\"⌊\",\"Lfr\":\"𝔏\",\"lfr\":\"𝔩\",\"lg\":\"≶\",\"lgE\":\"⪑\",\"lHar\":\"⥢\",\"lhard\":\"↽\",\"lharu\":\"↼\",\"lharul\":\"⥪\",\"lhblk\":\"▄\",\"LJcy\":\"Љ\",\"ljcy\":\"љ\",\"llarr\":\"⇇\",\"ll\":\"≪\",\"Ll\":\"⋘\",\"llcorner\":\"⌞\",\"Lleftarrow\":\"⇚\",\"llhard\":\"⥫\",\"lltri\":\"◺\",\"Lmidot\":\"Ŀ\",\"lmidot\":\"ŀ\",\"lmoustache\":\"⎰\",\"lmoust\":\"⎰\",\"lnap\":\"⪉\",\"lnapprox\":\"⪉\",\"lne\":\"⪇\",\"lnE\":\"≨\",\"lneq\":\"⪇\",\"lneqq\":\"≨\",\"lnsim\":\"⋦\",\"loang\":\"⟬\",\"loarr\":\"⇽\",\"lobrk\":\"⟦\",\"longleftarrow\":\"⟵\",\"LongLeftArrow\":\"⟵\",\"Longleftarrow\":\"⟸\",\"longleftrightarrow\":\"⟷\",\"LongLeftRightArrow\":\"⟷\",\"Longleftrightarrow\":\"⟺\",\"longmapsto\":\"⟼\",\"longrightarrow\":\"⟶\",\"LongRightArrow\":\"⟶\",\"Longrightarrow\":\"⟹\",\"looparrowleft\":\"↫\",\"looparrowright\":\"↬\",\"lopar\":\"⦅\",\"Lopf\":\"𝕃\",\"lopf\":\"𝕝\",\"loplus\":\"⨭\",\"lotimes\":\"⨴\",\"lowast\":\"∗\",\"lowbar\":\"_\",\"LowerLeftArrow\":\"↙\",\"LowerRightArrow\":\"↘\",\"loz\":\"◊\",\"lozenge\":\"◊\",\"lozf\":\"⧫\",\"lpar\":\"(\",\"lparlt\":\"⦓\",\"lrarr\":\"⇆\",\"lrcorner\":\"⌟\",\"lrhar\":\"⇋\",\"lrhard\":\"⥭\",\"lrm\":\"‎\",\"lrtri\":\"⊿\",\"lsaquo\":\"‹\",\"lscr\":\"𝓁\",\"Lscr\":\"ℒ\",\"lsh\":\"↰\",\"Lsh\":\"↰\",\"lsim\":\"≲\",\"lsime\":\"⪍\",\"lsimg\":\"⪏\",\"lsqb\":\"[\",\"lsquo\":\"‘\",\"lsquor\":\"‚\",\"Lstrok\":\"Ł\",\"lstrok\":\"ł\",\"ltcc\":\"⪦\",\"ltcir\":\"⩹\",\"lt\":\"<\",\"LT\":\"<\",\"Lt\":\"≪\",\"ltdot\":\"⋖\",\"lthree\":\"⋋\",\"ltimes\":\"⋉\",\"ltlarr\":\"⥶\",\"ltquest\":\"⩻\",\"ltri\":\"◃\",\"ltrie\":\"⊴\",\"ltrif\":\"◂\",\"ltrPar\":\"⦖\",\"lurdshar\":\"⥊\",\"luruhar\":\"⥦\",\"lvertneqq\":\"≨︀\",\"lvnE\":\"≨︀\",\"macr\":\"¯\",\"male\":\"♂\",\"malt\":\"✠\",\"maltese\":\"✠\",\"Map\":\"⤅\",\"map\":\"↦\",\"mapsto\":\"↦\",\"mapstodown\":\"↧\",\"mapstoleft\":\"↤\",\"mapstoup\":\"↥\",\"marker\":\"▮\",\"mcomma\":\"⨩\",\"Mcy\":\"М\",\"mcy\":\"м\",\"mdash\":\"—\",\"mDDot\":\"∺\",\"measuredangle\":\"∡\",\"MediumSpace\":\" \",\"Mellintrf\":\"ℳ\",\"Mfr\":\"𝔐\",\"mfr\":\"𝔪\",\"mho\":\"℧\",\"micro\":\"µ\",\"midast\":\"*\",\"midcir\":\"⫰\",\"mid\":\"∣\",\"middot\":\"·\",\"minusb\":\"⊟\",\"minus\":\"−\",\"minusd\":\"∸\",\"minusdu\":\"⨪\",\"MinusPlus\":\"∓\",\"mlcp\":\"⫛\",\"mldr\":\"…\",\"mnplus\":\"∓\",\"models\":\"⊧\",\"Mopf\":\"𝕄\",\"mopf\":\"𝕞\",\"mp\":\"∓\",\"mscr\":\"𝓂\",\"Mscr\":\"ℳ\",\"mstpos\":\"∾\",\"Mu\":\"Μ\",\"mu\":\"μ\",\"multimap\":\"⊸\",\"mumap\":\"⊸\",\"nabla\":\"∇\",\"Nacute\":\"Ń\",\"nacute\":\"ń\",\"nang\":\"∠⃒\",\"nap\":\"≉\",\"napE\":\"⩰̸\",\"napid\":\"≋̸\",\"napos\":\"ʼn\",\"napprox\":\"≉\",\"natural\":\"♮\",\"naturals\":\"ℕ\",\"natur\":\"♮\",\"nbsp\":\" \",\"nbump\":\"≎̸\",\"nbumpe\":\"≏̸\",\"ncap\":\"⩃\",\"Ncaron\":\"Ň\",\"ncaron\":\"ň\",\"Ncedil\":\"Ņ\",\"ncedil\":\"ņ\",\"ncong\":\"≇\",\"ncongdot\":\"⩭̸\",\"ncup\":\"⩂\",\"Ncy\":\"Н\",\"ncy\":\"н\",\"ndash\":\"–\",\"nearhk\":\"⤤\",\"nearr\":\"↗\",\"neArr\":\"⇗\",\"nearrow\":\"↗\",\"ne\":\"≠\",\"nedot\":\"≐̸\",\"NegativeMediumSpace\":\"​\",\"NegativeThickSpace\":\"​\",\"NegativeThinSpace\":\"​\",\"NegativeVeryThinSpace\":\"​\",\"nequiv\":\"≢\",\"nesear\":\"⤨\",\"nesim\":\"≂̸\",\"NestedGreaterGreater\":\"≫\",\"NestedLessLess\":\"≪\",\"NewLine\":\"\\\\n\",\"nexist\":\"∄\",\"nexists\":\"∄\",\"Nfr\":\"𝔑\",\"nfr\":\"𝔫\",\"ngE\":\"≧̸\",\"nge\":\"≱\",\"ngeq\":\"≱\",\"ngeqq\":\"≧̸\",\"ngeqslant\":\"⩾̸\",\"nges\":\"⩾̸\",\"nGg\":\"⋙̸\",\"ngsim\":\"≵\",\"nGt\":\"≫⃒\",\"ngt\":\"≯\",\"ngtr\":\"≯\",\"nGtv\":\"≫̸\",\"nharr\":\"↮\",\"nhArr\":\"⇎\",\"nhpar\":\"⫲\",\"ni\":\"∋\",\"nis\":\"⋼\",\"nisd\":\"⋺\",\"niv\":\"∋\",\"NJcy\":\"Њ\",\"njcy\":\"њ\",\"nlarr\":\"↚\",\"nlArr\":\"⇍\",\"nldr\":\"‥\",\"nlE\":\"≦̸\",\"nle\":\"≰\",\"nleftarrow\":\"↚\",\"nLeftarrow\":\"⇍\",\"nleftrightarrow\":\"↮\",\"nLeftrightarrow\":\"⇎\",\"nleq\":\"≰\",\"nleqq\":\"≦̸\",\"nleqslant\":\"⩽̸\",\"nles\":\"⩽̸\",\"nless\":\"≮\",\"nLl\":\"⋘̸\",\"nlsim\":\"≴\",\"nLt\":\"≪⃒\",\"nlt\":\"≮\",\"nltri\":\"⋪\",\"nltrie\":\"⋬\",\"nLtv\":\"≪̸\",\"nmid\":\"∤\",\"NoBreak\":\"⁠\",\"NonBreakingSpace\":\" \",\"nopf\":\"𝕟\",\"Nopf\":\"ℕ\",\"Not\":\"⫬\",\"not\":\"¬\",\"NotCongruent\":\"≢\",\"NotCupCap\":\"≭\",\"NotDoubleVerticalBar\":\"∦\",\"NotElement\":\"∉\",\"NotEqual\":\"≠\",\"NotEqualTilde\":\"≂̸\",\"NotExists\":\"∄\",\"NotGreater\":\"≯\",\"NotGreaterEqual\":\"≱\",\"NotGreaterFullEqual\":\"≧̸\",\"NotGreaterGreater\":\"≫̸\",\"NotGreaterLess\":\"≹\",\"NotGreaterSlantEqual\":\"⩾̸\",\"NotGreaterTilde\":\"≵\",\"NotHumpDownHump\":\"≎̸\",\"NotHumpEqual\":\"≏̸\",\"notin\":\"∉\",\"notindot\":\"⋵̸\",\"notinE\":\"⋹̸\",\"notinva\":\"∉\",\"notinvb\":\"⋷\",\"notinvc\":\"⋶\",\"NotLeftTriangleBar\":\"⧏̸\",\"NotLeftTriangle\":\"⋪\",\"NotLeftTriangleEqual\":\"⋬\",\"NotLess\":\"≮\",\"NotLessEqual\":\"≰\",\"NotLessGreater\":\"≸\",\"NotLessLess\":\"≪̸\",\"NotLessSlantEqual\":\"⩽̸\",\"NotLessTilde\":\"≴\",\"NotNestedGreaterGreater\":\"⪢̸\",\"NotNestedLessLess\":\"⪡̸\",\"notni\":\"∌\",\"notniva\":\"∌\",\"notnivb\":\"⋾\",\"notnivc\":\"⋽\",\"NotPrecedes\":\"⊀\",\"NotPrecedesEqual\":\"⪯̸\",\"NotPrecedesSlantEqual\":\"⋠\",\"NotReverseElement\":\"∌\",\"NotRightTriangleBar\":\"⧐̸\",\"NotRightTriangle\":\"⋫\",\"NotRightTriangleEqual\":\"⋭\",\"NotSquareSubset\":\"⊏̸\",\"NotSquareSubsetEqual\":\"⋢\",\"NotSquareSuperset\":\"⊐̸\",\"NotSquareSupersetEqual\":\"⋣\",\"NotSubset\":\"⊂⃒\",\"NotSubsetEqual\":\"⊈\",\"NotSucceeds\":\"⊁\",\"NotSucceedsEqual\":\"⪰̸\",\"NotSucceedsSlantEqual\":\"⋡\",\"NotSucceedsTilde\":\"≿̸\",\"NotSuperset\":\"⊃⃒\",\"NotSupersetEqual\":\"⊉\",\"NotTilde\":\"≁\",\"NotTildeEqual\":\"≄\",\"NotTildeFullEqual\":\"≇\",\"NotTildeTilde\":\"≉\",\"NotVerticalBar\":\"∤\",\"nparallel\":\"∦\",\"npar\":\"∦\",\"nparsl\":\"⫽⃥\",\"npart\":\"∂̸\",\"npolint\":\"⨔\",\"npr\":\"⊀\",\"nprcue\":\"⋠\",\"nprec\":\"⊀\",\"npreceq\":\"⪯̸\",\"npre\":\"⪯̸\",\"nrarrc\":\"⤳̸\",\"nrarr\":\"↛\",\"nrArr\":\"⇏\",\"nrarrw\":\"↝̸\",\"nrightarrow\":\"↛\",\"nRightarrow\":\"⇏\",\"nrtri\":\"⋫\",\"nrtrie\":\"⋭\",\"nsc\":\"⊁\",\"nsccue\":\"⋡\",\"nsce\":\"⪰̸\",\"Nscr\":\"𝒩\",\"nscr\":\"𝓃\",\"nshortmid\":\"∤\",\"nshortparallel\":\"∦\",\"nsim\":\"≁\",\"nsime\":\"≄\",\"nsimeq\":\"≄\",\"nsmid\":\"∤\",\"nspar\":\"∦\",\"nsqsube\":\"⋢\",\"nsqsupe\":\"⋣\",\"nsub\":\"⊄\",\"nsubE\":\"⫅̸\",\"nsube\":\"⊈\",\"nsubset\":\"⊂⃒\",\"nsubseteq\":\"⊈\",\"nsubseteqq\":\"⫅̸\",\"nsucc\":\"⊁\",\"nsucceq\":\"⪰̸\",\"nsup\":\"⊅\",\"nsupE\":\"⫆̸\",\"nsupe\":\"⊉\",\"nsupset\":\"⊃⃒\",\"nsupseteq\":\"⊉\",\"nsupseteqq\":\"⫆̸\",\"ntgl\":\"≹\",\"Ntilde\":\"Ñ\",\"ntilde\":\"ñ\",\"ntlg\":\"≸\",\"ntriangleleft\":\"⋪\",\"ntrianglelefteq\":\"⋬\",\"ntriangleright\":\"⋫\",\"ntrianglerighteq\":\"⋭\",\"Nu\":\"Ν\",\"nu\":\"ν\",\"num\":\"#\",\"numero\":\"№\",\"numsp\":\" \",\"nvap\":\"≍⃒\",\"nvdash\":\"⊬\",\"nvDash\":\"⊭\",\"nVdash\":\"⊮\",\"nVDash\":\"⊯\",\"nvge\":\"≥⃒\",\"nvgt\":\">⃒\",\"nvHarr\":\"⤄\",\"nvinfin\":\"⧞\",\"nvlArr\":\"⤂\",\"nvle\":\"≤⃒\",\"nvlt\":\"<⃒\",\"nvltrie\":\"⊴⃒\",\"nvrArr\":\"⤃\",\"nvrtrie\":\"⊵⃒\",\"nvsim\":\"∼⃒\",\"nwarhk\":\"⤣\",\"nwarr\":\"↖\",\"nwArr\":\"⇖\",\"nwarrow\":\"↖\",\"nwnear\":\"⤧\",\"Oacute\":\"Ó\",\"oacute\":\"ó\",\"oast\":\"⊛\",\"Ocirc\":\"Ô\",\"ocirc\":\"ô\",\"ocir\":\"⊚\",\"Ocy\":\"О\",\"ocy\":\"о\",\"odash\":\"⊝\",\"Odblac\":\"Ő\",\"odblac\":\"ő\",\"odiv\":\"⨸\",\"odot\":\"⊙\",\"odsold\":\"⦼\",\"OElig\":\"Œ\",\"oelig\":\"œ\",\"ofcir\":\"⦿\",\"Ofr\":\"𝔒\",\"ofr\":\"𝔬\",\"ogon\":\"˛\",\"Ograve\":\"Ò\",\"ograve\":\"ò\",\"ogt\":\"⧁\",\"ohbar\":\"⦵\",\"ohm\":\"Ω\",\"oint\":\"∮\",\"olarr\":\"↺\",\"olcir\":\"⦾\",\"olcross\":\"⦻\",\"oline\":\"‾\",\"olt\":\"⧀\",\"Omacr\":\"Ō\",\"omacr\":\"ō\",\"Omega\":\"Ω\",\"omega\":\"ω\",\"Omicron\":\"Ο\",\"omicron\":\"ο\",\"omid\":\"⦶\",\"ominus\":\"⊖\",\"Oopf\":\"𝕆\",\"oopf\":\"𝕠\",\"opar\":\"⦷\",\"OpenCurlyDoubleQuote\":\"“\",\"OpenCurlyQuote\":\"‘\",\"operp\":\"⦹\",\"oplus\":\"⊕\",\"orarr\":\"↻\",\"Or\":\"⩔\",\"or\":\"∨\",\"ord\":\"⩝\",\"order\":\"ℴ\",\"orderof\":\"ℴ\",\"ordf\":\"ª\",\"ordm\":\"º\",\"origof\":\"⊶\",\"oror\":\"⩖\",\"orslope\":\"⩗\",\"orv\":\"⩛\",\"oS\":\"Ⓢ\",\"Oscr\":\"𝒪\",\"oscr\":\"ℴ\",\"Oslash\":\"Ø\",\"oslash\":\"ø\",\"osol\":\"⊘\",\"Otilde\":\"Õ\",\"otilde\":\"õ\",\"otimesas\":\"⨶\",\"Otimes\":\"⨷\",\"otimes\":\"⊗\",\"Ouml\":\"Ö\",\"ouml\":\"ö\",\"ovbar\":\"⌽\",\"OverBar\":\"‾\",\"OverBrace\":\"⏞\",\"OverBracket\":\"⎴\",\"OverParenthesis\":\"⏜\",\"para\":\"¶\",\"parallel\":\"∥\",\"par\":\"∥\",\"parsim\":\"⫳\",\"parsl\":\"⫽\",\"part\":\"∂\",\"PartialD\":\"∂\",\"Pcy\":\"П\",\"pcy\":\"п\",\"percnt\":\"%\",\"period\":\".\",\"permil\":\"‰\",\"perp\":\"⊥\",\"pertenk\":\"‱\",\"Pfr\":\"𝔓\",\"pfr\":\"𝔭\",\"Phi\":\"Φ\",\"phi\":\"φ\",\"phiv\":\"ϕ\",\"phmmat\":\"ℳ\",\"phone\":\"☎\",\"Pi\":\"Π\",\"pi\":\"π\",\"pitchfork\":\"⋔\",\"piv\":\"ϖ\",\"planck\":\"ℏ\",\"planckh\":\"ℎ\",\"plankv\":\"ℏ\",\"plusacir\":\"⨣\",\"plusb\":\"⊞\",\"pluscir\":\"⨢\",\"plus\":\"+\",\"plusdo\":\"∔\",\"plusdu\":\"⨥\",\"pluse\":\"⩲\",\"PlusMinus\":\"±\",\"plusmn\":\"±\",\"plussim\":\"⨦\",\"plustwo\":\"⨧\",\"pm\":\"±\",\"Poincareplane\":\"ℌ\",\"pointint\":\"⨕\",\"popf\":\"𝕡\",\"Popf\":\"ℙ\",\"pound\":\"£\",\"prap\":\"⪷\",\"Pr\":\"⪻\",\"pr\":\"≺\",\"prcue\":\"≼\",\"precapprox\":\"⪷\",\"prec\":\"≺\",\"preccurlyeq\":\"≼\",\"Precedes\":\"≺\",\"PrecedesEqual\":\"⪯\",\"PrecedesSlantEqual\":\"≼\",\"PrecedesTilde\":\"≾\",\"preceq\":\"⪯\",\"precnapprox\":\"⪹\",\"precneqq\":\"⪵\",\"precnsim\":\"⋨\",\"pre\":\"⪯\",\"prE\":\"⪳\",\"precsim\":\"≾\",\"prime\":\"′\",\"Prime\":\"″\",\"primes\":\"ℙ\",\"prnap\":\"⪹\",\"prnE\":\"⪵\",\"prnsim\":\"⋨\",\"prod\":\"∏\",\"Product\":\"∏\",\"profalar\":\"⌮\",\"profline\":\"⌒\",\"profsurf\":\"⌓\",\"prop\":\"∝\",\"Proportional\":\"∝\",\"Proportion\":\"∷\",\"propto\":\"∝\",\"prsim\":\"≾\",\"prurel\":\"⊰\",\"Pscr\":\"𝒫\",\"pscr\":\"𝓅\",\"Psi\":\"Ψ\",\"psi\":\"ψ\",\"puncsp\":\" \",\"Qfr\":\"𝔔\",\"qfr\":\"𝔮\",\"qint\":\"⨌\",\"qopf\":\"𝕢\",\"Qopf\":\"ℚ\",\"qprime\":\"⁗\",\"Qscr\":\"𝒬\",\"qscr\":\"𝓆\",\"quaternions\":\"ℍ\",\"quatint\":\"⨖\",\"quest\":\"?\",\"questeq\":\"≟\",\"quot\":\"\\\\\"\",\"QUOT\":\"\\\\\"\",\"rAarr\":\"⇛\",\"race\":\"∽̱\",\"Racute\":\"Ŕ\",\"racute\":\"ŕ\",\"radic\":\"√\",\"raemptyv\":\"⦳\",\"rang\":\"⟩\",\"Rang\":\"⟫\",\"rangd\":\"⦒\",\"range\":\"⦥\",\"rangle\":\"⟩\",\"raquo\":\"»\",\"rarrap\":\"⥵\",\"rarrb\":\"⇥\",\"rarrbfs\":\"⤠\",\"rarrc\":\"⤳\",\"rarr\":\"→\",\"Rarr\":\"↠\",\"rArr\":\"⇒\",\"rarrfs\":\"⤞\",\"rarrhk\":\"↪\",\"rarrlp\":\"↬\",\"rarrpl\":\"⥅\",\"rarrsim\":\"⥴\",\"Rarrtl\":\"⤖\",\"rarrtl\":\"↣\",\"rarrw\":\"↝\",\"ratail\":\"⤚\",\"rAtail\":\"⤜\",\"ratio\":\"∶\",\"rationals\":\"ℚ\",\"rbarr\":\"⤍\",\"rBarr\":\"⤏\",\"RBarr\":\"⤐\",\"rbbrk\":\"❳\",\"rbrace\":\"}\",\"rbrack\":\"]\",\"rbrke\":\"⦌\",\"rbrksld\":\"⦎\",\"rbrkslu\":\"⦐\",\"Rcaron\":\"Ř\",\"rcaron\":\"ř\",\"Rcedil\":\"Ŗ\",\"rcedil\":\"ŗ\",\"rceil\":\"⌉\",\"rcub\":\"}\",\"Rcy\":\"Р\",\"rcy\":\"р\",\"rdca\":\"⤷\",\"rdldhar\":\"⥩\",\"rdquo\":\"”\",\"rdquor\":\"”\",\"rdsh\":\"↳\",\"real\":\"ℜ\",\"realine\":\"ℛ\",\"realpart\":\"ℜ\",\"reals\":\"ℝ\",\"Re\":\"ℜ\",\"rect\":\"▭\",\"reg\":\"®\",\"REG\":\"®\",\"ReverseElement\":\"∋\",\"ReverseEquilibrium\":\"⇋\",\"ReverseUpEquilibrium\":\"⥯\",\"rfisht\":\"⥽\",\"rfloor\":\"⌋\",\"rfr\":\"𝔯\",\"Rfr\":\"ℜ\",\"rHar\":\"⥤\",\"rhard\":\"⇁\",\"rharu\":\"⇀\",\"rharul\":\"⥬\",\"Rho\":\"Ρ\",\"rho\":\"ρ\",\"rhov\":\"ϱ\",\"RightAngleBracket\":\"⟩\",\"RightArrowBar\":\"⇥\",\"rightarrow\":\"→\",\"RightArrow\":\"→\",\"Rightarrow\":\"⇒\",\"RightArrowLeftArrow\":\"⇄\",\"rightarrowtail\":\"↣\",\"RightCeiling\":\"⌉\",\"RightDoubleBracket\":\"⟧\",\"RightDownTeeVector\":\"⥝\",\"RightDownVectorBar\":\"⥕\",\"RightDownVector\":\"⇂\",\"RightFloor\":\"⌋\",\"rightharpoondown\":\"⇁\",\"rightharpoonup\":\"⇀\",\"rightleftarrows\":\"⇄\",\"rightleftharpoons\":\"⇌\",\"rightrightarrows\":\"⇉\",\"rightsquigarrow\":\"↝\",\"RightTeeArrow\":\"↦\",\"RightTee\":\"⊢\",\"RightTeeVector\":\"⥛\",\"rightthreetimes\":\"⋌\",\"RightTriangleBar\":\"⧐\",\"RightTriangle\":\"⊳\",\"RightTriangleEqual\":\"⊵\",\"RightUpDownVector\":\"⥏\",\"RightUpTeeVector\":\"⥜\",\"RightUpVectorBar\":\"⥔\",\"RightUpVector\":\"↾\",\"RightVectorBar\":\"⥓\",\"RightVector\":\"⇀\",\"ring\":\"˚\",\"risingdotseq\":\"≓\",\"rlarr\":\"⇄\",\"rlhar\":\"⇌\",\"rlm\":\"‏\",\"rmoustache\":\"⎱\",\"rmoust\":\"⎱\",\"rnmid\":\"⫮\",\"roang\":\"⟭\",\"roarr\":\"⇾\",\"robrk\":\"⟧\",\"ropar\":\"⦆\",\"ropf\":\"𝕣\",\"Ropf\":\"ℝ\",\"roplus\":\"⨮\",\"rotimes\":\"⨵\",\"RoundImplies\":\"⥰\",\"rpar\":\")\",\"rpargt\":\"⦔\",\"rppolint\":\"⨒\",\"rrarr\":\"⇉\",\"Rrightarrow\":\"⇛\",\"rsaquo\":\"›\",\"rscr\":\"𝓇\",\"Rscr\":\"ℛ\",\"rsh\":\"↱\",\"Rsh\":\"↱\",\"rsqb\":\"]\",\"rsquo\":\"’\",\"rsquor\":\"’\",\"rthree\":\"⋌\",\"rtimes\":\"⋊\",\"rtri\":\"▹\",\"rtrie\":\"⊵\",\"rtrif\":\"▸\",\"rtriltri\":\"⧎\",\"RuleDelayed\":\"⧴\",\"ruluhar\":\"⥨\",\"rx\":\"℞\",\"Sacute\":\"Ś\",\"sacute\":\"ś\",\"sbquo\":\"‚\",\"scap\":\"⪸\",\"Scaron\":\"Š\",\"scaron\":\"š\",\"Sc\":\"⪼\",\"sc\":\"≻\",\"sccue\":\"≽\",\"sce\":\"⪰\",\"scE\":\"⪴\",\"Scedil\":\"Ş\",\"scedil\":\"ş\",\"Scirc\":\"Ŝ\",\"scirc\":\"ŝ\",\"scnap\":\"⪺\",\"scnE\":\"⪶\",\"scnsim\":\"⋩\",\"scpolint\":\"⨓\",\"scsim\":\"≿\",\"Scy\":\"С\",\"scy\":\"с\",\"sdotb\":\"⊡\",\"sdot\":\"⋅\",\"sdote\":\"⩦\",\"searhk\":\"⤥\",\"searr\":\"↘\",\"seArr\":\"⇘\",\"searrow\":\"↘\",\"sect\":\"§\",\"semi\":\";\",\"seswar\":\"⤩\",\"setminus\":\"∖\",\"setmn\":\"∖\",\"sext\":\"✶\",\"Sfr\":\"𝔖\",\"sfr\":\"𝔰\",\"sfrown\":\"⌢\",\"sharp\":\"♯\",\"SHCHcy\":\"Щ\",\"shchcy\":\"щ\",\"SHcy\":\"Ш\",\"shcy\":\"ш\",\"ShortDownArrow\":\"↓\",\"ShortLeftArrow\":\"←\",\"shortmid\":\"∣\",\"shortparallel\":\"∥\",\"ShortRightArrow\":\"→\",\"ShortUpArrow\":\"↑\",\"shy\":\"­\",\"Sigma\":\"Σ\",\"sigma\":\"σ\",\"sigmaf\":\"ς\",\"sigmav\":\"ς\",\"sim\":\"∼\",\"simdot\":\"⩪\",\"sime\":\"≃\",\"simeq\":\"≃\",\"simg\":\"⪞\",\"simgE\":\"⪠\",\"siml\":\"⪝\",\"simlE\":\"⪟\",\"simne\":\"≆\",\"simplus\":\"⨤\",\"simrarr\":\"⥲\",\"slarr\":\"←\",\"SmallCircle\":\"∘\",\"smallsetminus\":\"∖\",\"smashp\":\"⨳\",\"smeparsl\":\"⧤\",\"smid\":\"∣\",\"smile\":\"⌣\",\"smt\":\"⪪\",\"smte\":\"⪬\",\"smtes\":\"⪬︀\",\"SOFTcy\":\"Ь\",\"softcy\":\"ь\",\"solbar\":\"⌿\",\"solb\":\"⧄\",\"sol\":\"/\",\"Sopf\":\"𝕊\",\"sopf\":\"𝕤\",\"spades\":\"♠\",\"spadesuit\":\"♠\",\"spar\":\"∥\",\"sqcap\":\"⊓\",\"sqcaps\":\"⊓︀\",\"sqcup\":\"⊔\",\"sqcups\":\"⊔︀\",\"Sqrt\":\"√\",\"sqsub\":\"⊏\",\"sqsube\":\"⊑\",\"sqsubset\":\"⊏\",\"sqsubseteq\":\"⊑\",\"sqsup\":\"⊐\",\"sqsupe\":\"⊒\",\"sqsupset\":\"⊐\",\"sqsupseteq\":\"⊒\",\"square\":\"□\",\"Square\":\"□\",\"SquareIntersection\":\"⊓\",\"SquareSubset\":\"⊏\",\"SquareSubsetEqual\":\"⊑\",\"SquareSuperset\":\"⊐\",\"SquareSupersetEqual\":\"⊒\",\"SquareUnion\":\"⊔\",\"squarf\":\"▪\",\"squ\":\"□\",\"squf\":\"▪\",\"srarr\":\"→\",\"Sscr\":\"𝒮\",\"sscr\":\"𝓈\",\"ssetmn\":\"∖\",\"ssmile\":\"⌣\",\"sstarf\":\"⋆\",\"Star\":\"⋆\",\"star\":\"☆\",\"starf\":\"★\",\"straightepsilon\":\"ϵ\",\"straightphi\":\"ϕ\",\"strns\":\"¯\",\"sub\":\"⊂\",\"Sub\":\"⋐\",\"subdot\":\"⪽\",\"subE\":\"⫅\",\"sube\":\"⊆\",\"subedot\":\"⫃\",\"submult\":\"⫁\",\"subnE\":\"⫋\",\"subne\":\"⊊\",\"subplus\":\"⪿\",\"subrarr\":\"⥹\",\"subset\":\"⊂\",\"Subset\":\"⋐\",\"subseteq\":\"⊆\",\"subseteqq\":\"⫅\",\"SubsetEqual\":\"⊆\",\"subsetneq\":\"⊊\",\"subsetneqq\":\"⫋\",\"subsim\":\"⫇\",\"subsub\":\"⫕\",\"subsup\":\"⫓\",\"succapprox\":\"⪸\",\"succ\":\"≻\",\"succcurlyeq\":\"≽\",\"Succeeds\":\"≻\",\"SucceedsEqual\":\"⪰\",\"SucceedsSlantEqual\":\"≽\",\"SucceedsTilde\":\"≿\",\"succeq\":\"⪰\",\"succnapprox\":\"⪺\",\"succneqq\":\"⪶\",\"succnsim\":\"⋩\",\"succsim\":\"≿\",\"SuchThat\":\"∋\",\"sum\":\"∑\",\"Sum\":\"∑\",\"sung\":\"♪\",\"sup1\":\"¹\",\"sup2\":\"²\",\"sup3\":\"³\",\"sup\":\"⊃\",\"Sup\":\"⋑\",\"supdot\":\"⪾\",\"supdsub\":\"⫘\",\"supE\":\"⫆\",\"supe\":\"⊇\",\"supedot\":\"⫄\",\"Superset\":\"⊃\",\"SupersetEqual\":\"⊇\",\"suphsol\":\"⟉\",\"suphsub\":\"⫗\",\"suplarr\":\"⥻\",\"supmult\":\"⫂\",\"supnE\":\"⫌\",\"supne\":\"⊋\",\"supplus\":\"⫀\",\"supset\":\"⊃\",\"Supset\":\"⋑\",\"supseteq\":\"⊇\",\"supseteqq\":\"⫆\",\"supsetneq\":\"⊋\",\"supsetneqq\":\"⫌\",\"supsim\":\"⫈\",\"supsub\":\"⫔\",\"supsup\":\"⫖\",\"swarhk\":\"⤦\",\"swarr\":\"↙\",\"swArr\":\"⇙\",\"swarrow\":\"↙\",\"swnwar\":\"⤪\",\"szlig\":\"ß\",\"Tab\":\"\\\\t\",\"target\":\"⌖\",\"Tau\":\"Τ\",\"tau\":\"τ\",\"tbrk\":\"⎴\",\"Tcaron\":\"Ť\",\"tcaron\":\"ť\",\"Tcedil\":\"Ţ\",\"tcedil\":\"ţ\",\"Tcy\":\"Т\",\"tcy\":\"т\",\"tdot\":\"⃛\",\"telrec\":\"⌕\",\"Tfr\":\"𝔗\",\"tfr\":\"𝔱\",\"there4\":\"∴\",\"therefore\":\"∴\",\"Therefore\":\"∴\",\"Theta\":\"Θ\",\"theta\":\"θ\",\"thetasym\":\"ϑ\",\"thetav\":\"ϑ\",\"thickapprox\":\"≈\",\"thicksim\":\"∼\",\"ThickSpace\":\"  \",\"ThinSpace\":\" \",\"thinsp\":\" \",\"thkap\":\"≈\",\"thksim\":\"∼\",\"THORN\":\"Þ\",\"thorn\":\"þ\",\"tilde\":\"˜\",\"Tilde\":\"∼\",\"TildeEqual\":\"≃\",\"TildeFullEqual\":\"≅\",\"TildeTilde\":\"≈\",\"timesbar\":\"⨱\",\"timesb\":\"⊠\",\"times\":\"×\",\"timesd\":\"⨰\",\"tint\":\"∭\",\"toea\":\"⤨\",\"topbot\":\"⌶\",\"topcir\":\"⫱\",\"top\":\"⊤\",\"Topf\":\"𝕋\",\"topf\":\"𝕥\",\"topfork\":\"⫚\",\"tosa\":\"⤩\",\"tprime\":\"‴\",\"trade\":\"™\",\"TRADE\":\"™\",\"triangle\":\"▵\",\"triangledown\":\"▿\",\"triangleleft\":\"◃\",\"trianglelefteq\":\"⊴\",\"triangleq\":\"≜\",\"triangleright\":\"▹\",\"trianglerighteq\":\"⊵\",\"tridot\":\"◬\",\"trie\":\"≜\",\"triminus\":\"⨺\",\"TripleDot\":\"⃛\",\"triplus\":\"⨹\",\"trisb\":\"⧍\",\"tritime\":\"⨻\",\"trpezium\":\"⏢\",\"Tscr\":\"𝒯\",\"tscr\":\"𝓉\",\"TScy\":\"Ц\",\"tscy\":\"ц\",\"TSHcy\":\"Ћ\",\"tshcy\":\"ћ\",\"Tstrok\":\"Ŧ\",\"tstrok\":\"ŧ\",\"twixt\":\"≬\",\"twoheadleftarrow\":\"↞\",\"twoheadrightarrow\":\"↠\",\"Uacute\":\"Ú\",\"uacute\":\"ú\",\"uarr\":\"↑\",\"Uarr\":\"↟\",\"uArr\":\"⇑\",\"Uarrocir\":\"⥉\",\"Ubrcy\":\"Ў\",\"ubrcy\":\"ў\",\"Ubreve\":\"Ŭ\",\"ubreve\":\"ŭ\",\"Ucirc\":\"Û\",\"ucirc\":\"û\",\"Ucy\":\"У\",\"ucy\":\"у\",\"udarr\":\"⇅\",\"Udblac\":\"Ű\",\"udblac\":\"ű\",\"udhar\":\"⥮\",\"ufisht\":\"⥾\",\"Ufr\":\"𝔘\",\"ufr\":\"𝔲\",\"Ugrave\":\"Ù\",\"ugrave\":\"ù\",\"uHar\":\"⥣\",\"uharl\":\"↿\",\"uharr\":\"↾\",\"uhblk\":\"▀\",\"ulcorn\":\"⌜\",\"ulcorner\":\"⌜\",\"ulcrop\":\"⌏\",\"ultri\":\"◸\",\"Umacr\":\"Ū\",\"umacr\":\"ū\",\"uml\":\"¨\",\"UnderBar\":\"_\",\"UnderBrace\":\"⏟\",\"UnderBracket\":\"⎵\",\"UnderParenthesis\":\"⏝\",\"Union\":\"⋃\",\"UnionPlus\":\"⊎\",\"Uogon\":\"Ų\",\"uogon\":\"ų\",\"Uopf\":\"𝕌\",\"uopf\":\"𝕦\",\"UpArrowBar\":\"⤒\",\"uparrow\":\"↑\",\"UpArrow\":\"↑\",\"Uparrow\":\"⇑\",\"UpArrowDownArrow\":\"⇅\",\"updownarrow\":\"↕\",\"UpDownArrow\":\"↕\",\"Updownarrow\":\"⇕\",\"UpEquilibrium\":\"⥮\",\"upharpoonleft\":\"↿\",\"upharpoonright\":\"↾\",\"uplus\":\"⊎\",\"UpperLeftArrow\":\"↖\",\"UpperRightArrow\":\"↗\",\"upsi\":\"υ\",\"Upsi\":\"ϒ\",\"upsih\":\"ϒ\",\"Upsilon\":\"Υ\",\"upsilon\":\"υ\",\"UpTeeArrow\":\"↥\",\"UpTee\":\"⊥\",\"upuparrows\":\"⇈\",\"urcorn\":\"⌝\",\"urcorner\":\"⌝\",\"urcrop\":\"⌎\",\"Uring\":\"Ů\",\"uring\":\"ů\",\"urtri\":\"◹\",\"Uscr\":\"𝒰\",\"uscr\":\"𝓊\",\"utdot\":\"⋰\",\"Utilde\":\"Ũ\",\"utilde\":\"ũ\",\"utri\":\"▵\",\"utrif\":\"▴\",\"uuarr\":\"⇈\",\"Uuml\":\"Ü\",\"uuml\":\"ü\",\"uwangle\":\"⦧\",\"vangrt\":\"⦜\",\"varepsilon\":\"ϵ\",\"varkappa\":\"ϰ\",\"varnothing\":\"∅\",\"varphi\":\"ϕ\",\"varpi\":\"ϖ\",\"varpropto\":\"∝\",\"varr\":\"↕\",\"vArr\":\"⇕\",\"varrho\":\"ϱ\",\"varsigma\":\"ς\",\"varsubsetneq\":\"⊊︀\",\"varsubsetneqq\":\"⫋︀\",\"varsupsetneq\":\"⊋︀\",\"varsupsetneqq\":\"⫌︀\",\"vartheta\":\"ϑ\",\"vartriangleleft\":\"⊲\",\"vartriangleright\":\"⊳\",\"vBar\":\"⫨\",\"Vbar\":\"⫫\",\"vBarv\":\"⫩\",\"Vcy\":\"В\",\"vcy\":\"в\",\"vdash\":\"⊢\",\"vDash\":\"⊨\",\"Vdash\":\"⊩\",\"VDash\":\"⊫\",\"Vdashl\":\"⫦\",\"veebar\":\"⊻\",\"vee\":\"∨\",\"Vee\":\"⋁\",\"veeeq\":\"≚\",\"vellip\":\"⋮\",\"verbar\":\"|\",\"Verbar\":\"‖\",\"vert\":\"|\",\"Vert\":\"‖\",\"VerticalBar\":\"∣\",\"VerticalLine\":\"|\",\"VerticalSeparator\":\"❘\",\"VerticalTilde\":\"≀\",\"VeryThinSpace\":\" \",\"Vfr\":\"𝔙\",\"vfr\":\"𝔳\",\"vltri\":\"⊲\",\"vnsub\":\"⊂⃒\",\"vnsup\":\"⊃⃒\",\"Vopf\":\"𝕍\",\"vopf\":\"𝕧\",\"vprop\":\"∝\",\"vrtri\":\"⊳\",\"Vscr\":\"𝒱\",\"vscr\":\"𝓋\",\"vsubnE\":\"⫋︀\",\"vsubne\":\"⊊︀\",\"vsupnE\":\"⫌︀\",\"vsupne\":\"⊋︀\",\"Vvdash\":\"⊪\",\"vzigzag\":\"⦚\",\"Wcirc\":\"Ŵ\",\"wcirc\":\"ŵ\",\"wedbar\":\"⩟\",\"wedge\":\"∧\",\"Wedge\":\"⋀\",\"wedgeq\":\"≙\",\"weierp\":\"℘\",\"Wfr\":\"𝔚\",\"wfr\":\"𝔴\",\"Wopf\":\"𝕎\",\"wopf\":\"𝕨\",\"wp\":\"℘\",\"wr\":\"≀\",\"wreath\":\"≀\",\"Wscr\":\"𝒲\",\"wscr\":\"𝓌\",\"xcap\":\"⋂\",\"xcirc\":\"◯\",\"xcup\":\"⋃\",\"xdtri\":\"▽\",\"Xfr\":\"𝔛\",\"xfr\":\"𝔵\",\"xharr\":\"⟷\",\"xhArr\":\"⟺\",\"Xi\":\"Ξ\",\"xi\":\"ξ\",\"xlarr\":\"⟵\",\"xlArr\":\"⟸\",\"xmap\":\"⟼\",\"xnis\":\"⋻\",\"xodot\":\"⨀\",\"Xopf\":\"𝕏\",\"xopf\":\"𝕩\",\"xoplus\":\"⨁\",\"xotime\":\"⨂\",\"xrarr\":\"⟶\",\"xrArr\":\"⟹\",\"Xscr\":\"𝒳\",\"xscr\":\"𝓍\",\"xsqcup\":\"⨆\",\"xuplus\":\"⨄\",\"xutri\":\"△\",\"xvee\":\"⋁\",\"xwedge\":\"⋀\",\"Yacute\":\"Ý\",\"yacute\":\"ý\",\"YAcy\":\"Я\",\"yacy\":\"я\",\"Ycirc\":\"Ŷ\",\"ycirc\":\"ŷ\",\"Ycy\":\"Ы\",\"ycy\":\"ы\",\"yen\":\"¥\",\"Yfr\":\"𝔜\",\"yfr\":\"𝔶\",\"YIcy\":\"Ї\",\"yicy\":\"ї\",\"Yopf\":\"𝕐\",\"yopf\":\"𝕪\",\"Yscr\":\"𝒴\",\"yscr\":\"𝓎\",\"YUcy\":\"Ю\",\"yucy\":\"ю\",\"yuml\":\"ÿ\",\"Yuml\":\"Ÿ\",\"Zacute\":\"Ź\",\"zacute\":\"ź\",\"Zcaron\":\"Ž\",\"zcaron\":\"ž\",\"Zcy\":\"З\",\"zcy\":\"з\",\"Zdot\":\"Ż\",\"zdot\":\"ż\",\"zeetrf\":\"ℨ\",\"ZeroWidthSpace\":\"​\",\"Zeta\":\"Ζ\",\"zeta\":\"ζ\",\"zfr\":\"𝔷\",\"Zfr\":\"ℨ\",\"ZHcy\":\"Ж\",\"zhcy\":\"ж\",\"zigrarr\":\"⇝\",\"zopf\":\"𝕫\",\"Zopf\":\"ℤ\",\"Zscr\":\"𝒵\",\"zscr\":\"𝓏\",\"zwj\":\"‍\",\"zwnj\":\"‌\"}');\n\n/***/ })\n\n/******/ \t});\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tvar cachedModule = __webpack_module_cache__[moduleId];\n/******/ \t\tif (cachedModule !== undefined) {\n/******/ \t\t\treturn cachedModule.exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\t// no module.id needed\n/******/ \t\t\t// no module.loaded needed\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t(() => {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = (exports, definition) => {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/make namespace object */\n/******/ \t(() => {\n/******/ \t\t// define __esModule on exports\n/******/ \t\t__webpack_require__.r = (exports) => {\n/******/ \t\t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t\t}\n/******/ \t\t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/************************************************************************/\nvar __webpack_exports__ = {};\n// This entry need to be wrapped in an IIFE because it need to be in strict mode.\n(() => {\n\"use strict\";\n// Require normalize.css.\n\n// Require local CSS.\n\n// Require jQuery.\nconst $ = __webpack_require__(9755);\n// Setup global jQuery.\nwindow.$ = $;\nwindow.jQuery = $;\n// Require Story.\nconst Story = __webpack_require__(3213);\n// Create new Story instance.\nwindow.Story = new Story();\n// Create global store shortcut.\nwindow.s = window.Story.store;\n// Start story.\nwindow.Story.start();\n\n})();\n\n/******/ })()\n;</script>\n\t</body>\n</html>\n"});
\ No newline at end of file
+window.storyFormat({"name":"Snowman","version":"3.0.0","description":"An advanced story format for authors more experienced with HTML, CSS, and JavaScript. See its <a href='https://videlais.github.io/snowman/#/' target='_blank' rel='noopener noreferrer'>documentation</a>.","proofing":false,"license":"MIT","setup":"","source":"<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n\t\t<meta charset=\"utf-8\">\n\t\t<title>{{STORY_NAME}}</title>\n\t\t<style>/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}body{color:#222;font:1.5em Helvetica Neue,Helvetica,Arial,sans-serif;margin-right:1em}tw-icon{cursor:pointer;font-size:2em}tw-story{box-sizing:border-box;display:flex;flex-direction:row;font-size:1.5em;line-height:1.5em;margin-top:1em;min-height:100%;width:100%}tw-passage{display:block;width:90%}a,tw-link{color:#222;cursor:pointer;text-decoration-color:#ccc}a,a:hover,tw-icon:hover,tw-link,tw-link:hover{text-decoration:underline}tw-sidebar{margin-left:1em;width:10%}a:hover{color:#cc8929}a:active,a:hover{text-decoration-color:#cc8929}a:active{color:#ffb040}tw-storydata{display:none}tw-screenlock{align-items:center;background-color:#fff;display:flex;height:100%;justify-content:center;left:0;position:fixed;top:0;width:100%;z-index:100000}.loading{-webkit-animation:spin 2s linear infinite;animation:spin 2s linear infinite;border:16px solid #f3f3f3;border-radius:50%;border-top-color:#3498db;height:250px;width:250px}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(1turn)}}@keyframes spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}</style>\n\t</head>\n\t<body>\n\t\t{{STORY_DATA}}\n\t\t<tw-story>\n\t\t\t<tw-sidebar>\n\t\t\t\t<tw-icon tabindex=\"0\" alt=\"Undo\" title=\"Undo\">↶</tw-icon>\n\t\t\t\t<tw-icon tabindex=\"1\" alt=\"Redo\" title=\"Redo\">↷</tw-icon>\n\t\t\t</tw-sidebar>\n\t\t\t<tw-passage class=\"passage\" aria-live=\"polite\"></tw-passage>\n\t\t</tw-story>\n\t\t<script>/******/ (() => { // webpackBootstrap\n/******/ \tvar __webpack_modules__ = ({\n\n/***/ 4155:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n/*\n * EJS Embedded JavaScript templates\n * Copyright 2112 Matthew Eernisse (mde@fleegix.org)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n*/\n\n\n\n/**\n * @file Embedded JavaScript templating engine. {@link http://ejs.co}\n * @author Matthew Eernisse <mde@fleegix.org>\n * @author Tiancheng \"Timothy\" Gu <timothygu99@gmail.com>\n * @project EJS\n * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}\n */\n\n/**\n * EJS internal functions.\n *\n * Technically this \"module\" lies in the same file as {@link module:ejs}, for\n * the sake of organization all the private functions re grouped into this\n * module.\n *\n * @module ejs-internal\n * @private\n */\n\n/**\n * Embedded JavaScript templating engine.\n *\n * @module ejs\n * @public\n */\n\n\nvar fs = __webpack_require__(7280);\nvar path = __webpack_require__(7024);\nvar utils = __webpack_require__(3182);\n\nvar scopeOptionWarned = false;\n/** @type {string} */\nvar _VERSION_STRING = (__webpack_require__(3840)/* .version */ .rE);\nvar _DEFAULT_OPEN_DELIMITER = '<';\nvar _DEFAULT_CLOSE_DELIMITER = '>';\nvar _DEFAULT_DELIMITER = '%';\nvar _DEFAULT_LOCALS_NAME = 'locals';\nvar _NAME = 'ejs';\nvar _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';\nvar _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',\n  'client', '_with', 'rmWhitespace', 'strict', 'filename', 'async'];\n// We don't allow 'cache' option to be passed in the data obj for\n// the normal `render` call, but this is where Express 2 & 3 put it\n// so we make an exception for `renderFile`\nvar _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');\nvar _BOM = /^\\uFEFF/;\nvar _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;\n\n/**\n * EJS template function cache. This can be a LRU object from lru-cache NPM\n * module. By default, it is {@link module:utils.cache}, a simple in-process\n * cache that grows continuously.\n *\n * @type {Cache}\n */\n\nexports.cache = utils.cache;\n\n/**\n * Custom file loader. Useful for template preprocessing or restricting access\n * to a certain part of the filesystem.\n *\n * @type {fileLoader}\n */\n\nexports.fileLoader = fs.readFileSync;\n\n/**\n * Name of the object containing the locals.\n *\n * This variable is overridden by {@link Options}`.localsName` if it is not\n * `undefined`.\n *\n * @type {String}\n * @public\n */\n\nexports.localsName = _DEFAULT_LOCALS_NAME;\n\n/**\n * Promise implementation -- defaults to the native implementation if available\n * This is mostly just for testability\n *\n * @type {PromiseConstructorLike}\n * @public\n */\n\nexports.promiseImpl = (new Function('return this;'))().Promise;\n\n/**\n * Get the path to the included file from the parent file path and the\n * specified path.\n *\n * @param {String}  name     specified path\n * @param {String}  filename parent file path\n * @param {Boolean} [isDir=false] whether the parent file path is a directory\n * @return {String}\n */\nexports.resolveInclude = function(name, filename, isDir) {\n  var dirname = path.dirname;\n  var extname = path.extname;\n  var resolve = path.resolve;\n  var includePath = resolve(isDir ? filename : dirname(filename), name);\n  var ext = extname(name);\n  if (!ext) {\n    includePath += '.ejs';\n  }\n  return includePath;\n};\n\n/**\n * Try to resolve file path on multiple directories\n *\n * @param  {String}        name  specified path\n * @param  {Array<String>} paths list of possible parent directory paths\n * @return {String}\n */\nfunction resolvePaths(name, paths) {\n  var filePath;\n  if (paths.some(function (v) {\n    filePath = exports.resolveInclude(name, v, true);\n    return fs.existsSync(filePath);\n  })) {\n    return filePath;\n  }\n}\n\n/**\n * Get the path to the included file by Options\n *\n * @param  {String}  path    specified path\n * @param  {Options} options compilation options\n * @return {String}\n */\nfunction getIncludePath(path, options) {\n  var includePath;\n  var filePath;\n  var views = options.views;\n  var match = /^[A-Za-z]+:\\\\|^\\//.exec(path);\n\n  // Abs path\n  if (match && match.length) {\n    path = path.replace(/^\\/*/, '');\n    if (Array.isArray(options.root)) {\n      includePath = resolvePaths(path, options.root);\n    } else {\n      includePath = exports.resolveInclude(path, options.root || '/', true);\n    }\n  }\n  // Relative paths\n  else {\n    // Look relative to a passed filename first\n    if (options.filename) {\n      filePath = exports.resolveInclude(path, options.filename);\n      if (fs.existsSync(filePath)) {\n        includePath = filePath;\n      }\n    }\n    // Then look in any views directories\n    if (!includePath && Array.isArray(views)) {\n      includePath = resolvePaths(path, views);\n    }\n    if (!includePath && typeof options.includer !== 'function') {\n      throw new Error('Could not find the include file \"' +\n          options.escapeFunction(path) + '\"');\n    }\n  }\n  return includePath;\n}\n\n/**\n * Get the template from a string or a file, either compiled on-the-fly or\n * read from cache (if enabled), and cache the template if needed.\n *\n * If `template` is not set, the file specified in `options.filename` will be\n * read.\n *\n * If `options.cache` is true, this function reads the file from\n * `options.filename` so it must be set prior to calling this function.\n *\n * @memberof module:ejs-internal\n * @param {Options} options   compilation options\n * @param {String} [template] template source\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `options.client`, either type might be returned.\n * @static\n */\n\nfunction handleCache(options, template) {\n  var func;\n  var filename = options.filename;\n  var hasTemplate = arguments.length > 1;\n\n  if (options.cache) {\n    if (!filename) {\n      throw new Error('cache option requires a filename');\n    }\n    func = exports.cache.get(filename);\n    if (func) {\n      return func;\n    }\n    if (!hasTemplate) {\n      template = fileLoader(filename).toString().replace(_BOM, '');\n    }\n  }\n  else if (!hasTemplate) {\n    // istanbul ignore if: should not happen at all\n    if (!filename) {\n      throw new Error('Internal EJS error: no file name or template '\n                    + 'provided');\n    }\n    template = fileLoader(filename).toString().replace(_BOM, '');\n  }\n  func = exports.compile(template, options);\n  if (options.cache) {\n    exports.cache.set(filename, func);\n  }\n  return func;\n}\n\n/**\n * Try calling handleCache with the given options and data and call the\n * callback with the result. If an error occurs, call the callback with\n * the error. Used by renderFile().\n *\n * @memberof module:ejs-internal\n * @param {Options} options    compilation options\n * @param {Object} data        template data\n * @param {RenderFileCallback} cb callback\n * @static\n */\n\nfunction tryHandleCache(options, data, cb) {\n  var result;\n  if (!cb) {\n    if (typeof exports.promiseImpl == 'function') {\n      return new exports.promiseImpl(function (resolve, reject) {\n        try {\n          result = handleCache(options)(data);\n          resolve(result);\n        }\n        catch (err) {\n          reject(err);\n        }\n      });\n    }\n    else {\n      throw new Error('Please provide a callback function');\n    }\n  }\n  else {\n    try {\n      result = handleCache(options)(data);\n    }\n    catch (err) {\n      return cb(err);\n    }\n\n    cb(null, result);\n  }\n}\n\n/**\n * fileLoader is independent\n *\n * @param {String} filePath ejs file path.\n * @return {String} The contents of the specified file.\n * @static\n */\n\nfunction fileLoader(filePath){\n  return exports.fileLoader(filePath);\n}\n\n/**\n * Get the template function.\n *\n * If `options.cache` is `true`, then the template is cached.\n *\n * @memberof module:ejs-internal\n * @param {String}  path    path for the specified file\n * @param {Options} options compilation options\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `options.client`, either type might be returned\n * @static\n */\n\nfunction includeFile(path, options) {\n  var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);\n  opts.filename = getIncludePath(path, opts);\n  if (typeof options.includer === 'function') {\n    var includerResult = options.includer(path, opts.filename);\n    if (includerResult) {\n      if (includerResult.filename) {\n        opts.filename = includerResult.filename;\n      }\n      if (includerResult.template) {\n        return handleCache(opts, includerResult.template);\n      }\n    }\n  }\n  return handleCache(opts);\n}\n\n/**\n * Re-throw the given `err` in context to the `str` of ejs, `filename`, and\n * `lineno`.\n *\n * @implements {RethrowCallback}\n * @memberof module:ejs-internal\n * @param {Error}  err      Error object\n * @param {String} str      EJS source\n * @param {String} flnm     file name of the EJS file\n * @param {Number} lineno   line number of the error\n * @param {EscapeCallback} esc\n * @static\n */\n\nfunction rethrow(err, str, flnm, lineno, esc) {\n  var lines = str.split('\\n');\n  var start = Math.max(lineno - 3, 0);\n  var end = Math.min(lines.length, lineno + 3);\n  var filename = esc(flnm);\n  // Error context\n  var context = lines.slice(start, end).map(function (line, i){\n    var curr = i + start + 1;\n    return (curr == lineno ? ' >> ' : '    ')\n      + curr\n      + '| '\n      + line;\n  }).join('\\n');\n\n  // Alter exception message\n  err.path = filename;\n  err.message = (filename || 'ejs') + ':'\n    + lineno + '\\n'\n    + context + '\\n\\n'\n    + err.message;\n\n  throw err;\n}\n\nfunction stripSemi(str){\n  return str.replace(/;(\\s*$)/, '$1');\n}\n\n/**\n * Compile the given `str` of ejs into a template function.\n *\n * @param {String}  template EJS template\n *\n * @param {Options} [opts] compilation options\n *\n * @return {(TemplateFunction|ClientFunction)}\n * Depending on the value of `opts.client`, either type might be returned.\n * Note that the return type of the function also depends on the value of `opts.async`.\n * @public\n */\n\nexports.compile = function compile(template, opts) {\n  var templ;\n\n  // v1 compat\n  // 'scope' is 'context'\n  // FIXME: Remove this in a future version\n  if (opts && opts.scope) {\n    if (!scopeOptionWarned){\n      console.warn('`scope` option is deprecated and will be removed in EJS 3');\n      scopeOptionWarned = true;\n    }\n    if (!opts.context) {\n      opts.context = opts.scope;\n    }\n    delete opts.scope;\n  }\n  templ = new Template(template, opts);\n  return templ.compile();\n};\n\n/**\n * Render the given `template` of ejs.\n *\n * If you would like to include options but not data, you need to explicitly\n * call this function with `data` being an empty object or `null`.\n *\n * @param {String}   template EJS template\n * @param {Object}  [data={}] template data\n * @param {Options} [opts={}] compilation and rendering options\n * @return {(String|Promise<String>)}\n * Return value type depends on `opts.async`.\n * @public\n */\n\nexports.render = function (template, d, o) {\n  var data = d || utils.createNullProtoObjWherePossible();\n  var opts = o || utils.createNullProtoObjWherePossible();\n\n  // No options object -- if there are optiony names\n  // in the data, copy them to options\n  if (arguments.length == 2) {\n    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);\n  }\n\n  return handleCache(opts, template)(data);\n};\n\n/**\n * Render an EJS file at the given `path` and callback `cb(err, str)`.\n *\n * If you would like to include options but not data, you need to explicitly\n * call this function with `data` being an empty object or `null`.\n *\n * @param {String}             path     path to the EJS file\n * @param {Object}            [data={}] template data\n * @param {Options}           [opts={}] compilation and rendering options\n * @param {RenderFileCallback} cb callback\n * @public\n */\n\nexports.renderFile = function () {\n  var args = Array.prototype.slice.call(arguments);\n  var filename = args.shift();\n  var cb;\n  var opts = {filename: filename};\n  var data;\n  var viewOpts;\n\n  // Do we have a callback?\n  if (typeof arguments[arguments.length - 1] == 'function') {\n    cb = args.pop();\n  }\n  // Do we have data/opts?\n  if (args.length) {\n    // Should always have data obj\n    data = args.shift();\n    // Normal passed opts (data obj + opts obj)\n    if (args.length) {\n      // Use shallowCopy so we don't pollute passed in opts obj with new vals\n      utils.shallowCopy(opts, args.pop());\n    }\n    // Special casing for Express (settings + opts-in-data)\n    else {\n      // Express 3 and 4\n      if (data.settings) {\n        // Pull a few things from known locations\n        if (data.settings.views) {\n          opts.views = data.settings.views;\n        }\n        if (data.settings['view cache']) {\n          opts.cache = true;\n        }\n        // Undocumented after Express 2, but still usable, esp. for\n        // items that are unsafe to be passed along with data, like `root`\n        viewOpts = data.settings['view options'];\n        if (viewOpts) {\n          utils.shallowCopy(opts, viewOpts);\n        }\n      }\n      // Express 2 and lower, values set in app.locals, or people who just\n      // want to pass options in their data. NOTE: These values will override\n      // anything previously set in settings  or settings['view options']\n      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);\n    }\n    opts.filename = filename;\n  }\n  else {\n    data = utils.createNullProtoObjWherePossible();\n  }\n\n  return tryHandleCache(opts, data, cb);\n};\n\n/**\n * Clear intermediate JavaScript cache. Calls {@link Cache#reset}.\n * @public\n */\n\n/**\n * EJS template class\n * @public\n */\nexports.Template = Template;\n\nexports.clearCache = function () {\n  exports.cache.reset();\n};\n\nfunction Template(text, optsParam) {\n  var opts = utils.hasOwnOnlyObject(optsParam);\n  var options = utils.createNullProtoObjWherePossible();\n  this.templateText = text;\n  /** @type {string | null} */\n  this.mode = null;\n  this.truncate = false;\n  this.currentLine = 1;\n  this.source = '';\n  options.client = opts.client || false;\n  options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;\n  options.compileDebug = opts.compileDebug !== false;\n  options.debug = !!opts.debug;\n  options.filename = opts.filename;\n  options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;\n  options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;\n  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;\n  options.strict = opts.strict || false;\n  options.context = opts.context;\n  options.cache = opts.cache || false;\n  options.rmWhitespace = opts.rmWhitespace;\n  options.root = opts.root;\n  options.includer = opts.includer;\n  options.outputFunctionName = opts.outputFunctionName;\n  options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;\n  options.views = opts.views;\n  options.async = opts.async;\n  options.destructuredLocals = opts.destructuredLocals;\n  options.legacyInclude = typeof opts.legacyInclude != 'undefined' ? !!opts.legacyInclude : true;\n\n  if (options.strict) {\n    options._with = false;\n  }\n  else {\n    options._with = typeof opts._with != 'undefined' ? opts._with : true;\n  }\n\n  this.opts = options;\n\n  this.regex = this.createRegex();\n}\n\nTemplate.modes = {\n  EVAL: 'eval',\n  ESCAPED: 'escaped',\n  RAW: 'raw',\n  COMMENT: 'comment',\n  LITERAL: 'literal'\n};\n\nTemplate.prototype = {\n  createRegex: function () {\n    var str = _REGEX_STRING;\n    var delim = utils.escapeRegExpChars(this.opts.delimiter);\n    var open = utils.escapeRegExpChars(this.opts.openDelimiter);\n    var close = utils.escapeRegExpChars(this.opts.closeDelimiter);\n    str = str.replace(/%/g, delim)\n      .replace(/</g, open)\n      .replace(/>/g, close);\n    return new RegExp(str);\n  },\n\n  compile: function () {\n    /** @type {string} */\n    var src;\n    /** @type {ClientFunction} */\n    var fn;\n    var opts = this.opts;\n    var prepended = '';\n    var appended = '';\n    /** @type {EscapeCallback} */\n    var escapeFn = opts.escapeFunction;\n    /** @type {FunctionConstructor} */\n    var ctor;\n    /** @type {string} */\n    var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : 'undefined';\n\n    if (!this.source) {\n      this.generateSource();\n      prepended +=\n        '  var __output = \"\";\\n' +\n        '  function __append(s) { if (s !== undefined && s !== null) __output += s }\\n';\n      if (opts.outputFunctionName) {\n        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {\n          throw new Error('outputFunctionName is not a valid JS identifier.');\n        }\n        prepended += '  var ' + opts.outputFunctionName + ' = __append;' + '\\n';\n      }\n      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {\n        throw new Error('localsName is not a valid JS identifier.');\n      }\n      if (opts.destructuredLocals && opts.destructuredLocals.length) {\n        var destructuring = '  var __locals = (' + opts.localsName + ' || {}),\\n';\n        for (var i = 0; i < opts.destructuredLocals.length; i++) {\n          var name = opts.destructuredLocals[i];\n          if (!_JS_IDENTIFIER.test(name)) {\n            throw new Error('destructuredLocals[' + i + '] is not a valid JS identifier.');\n          }\n          if (i > 0) {\n            destructuring += ',\\n  ';\n          }\n          destructuring += name + ' = __locals.' + name;\n        }\n        prepended += destructuring + ';\\n';\n      }\n      if (opts._with !== false) {\n        prepended +=  '  with (' + opts.localsName + ' || {}) {' + '\\n';\n        appended += '  }' + '\\n';\n      }\n      appended += '  return __output;' + '\\n';\n      this.source = prepended + this.source + appended;\n    }\n\n    if (opts.compileDebug) {\n      src = 'var __line = 1' + '\\n'\n        + '  , __lines = ' + JSON.stringify(this.templateText) + '\\n'\n        + '  , __filename = ' + sanitizedFilename + ';' + '\\n'\n        + 'try {' + '\\n'\n        + this.source\n        + '} catch (e) {' + '\\n'\n        + '  rethrow(e, __lines, __filename, __line, escapeFn);' + '\\n'\n        + '}' + '\\n';\n    }\n    else {\n      src = this.source;\n    }\n\n    if (opts.client) {\n      src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\\n' + src;\n      if (opts.compileDebug) {\n        src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\\n' + src;\n      }\n    }\n\n    if (opts.strict) {\n      src = '\"use strict\";\\n' + src;\n    }\n    if (opts.debug) {\n      console.log(src);\n    }\n    if (opts.compileDebug && opts.filename) {\n      src = src + '\\n'\n        + '//# sourceURL=' + sanitizedFilename + '\\n';\n    }\n\n    try {\n      if (opts.async) {\n        // Have to use generated function for this, since in envs without support,\n        // it breaks in parsing\n        try {\n          ctor = (new Function('return (async function(){}).constructor;'))();\n        }\n        catch(e) {\n          if (e instanceof SyntaxError) {\n            throw new Error('This environment does not support async/await');\n          }\n          else {\n            throw e;\n          }\n        }\n      }\n      else {\n        ctor = Function;\n      }\n      fn = new ctor(opts.localsName + ', escapeFn, include, rethrow', src);\n    }\n    catch(e) {\n      // istanbul ignore else\n      if (e instanceof SyntaxError) {\n        if (opts.filename) {\n          e.message += ' in ' + opts.filename;\n        }\n        e.message += ' while compiling ejs\\n\\n';\n        e.message += 'If the above error is not helpful, you may want to try EJS-Lint:\\n';\n        e.message += 'https://github.com/RyanZim/EJS-Lint';\n        if (!opts.async) {\n          e.message += '\\n';\n          e.message += 'Or, if you meant to create an async function, pass `async: true` as an option.';\n        }\n      }\n      throw e;\n    }\n\n    // Return a callable function which will execute the function\n    // created by the source-code, with the passed data as locals\n    // Adds a local `include` function which allows full recursive include\n    var returnedFn = opts.client ? fn : function anonymous(data) {\n      var include = function (path, includeData) {\n        var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);\n        if (includeData) {\n          d = utils.shallowCopy(d, includeData);\n        }\n        return includeFile(path, opts)(d);\n      };\n      return fn.apply(opts.context,\n        [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);\n    };\n    if (opts.filename && typeof Object.defineProperty === 'function') {\n      var filename = opts.filename;\n      var basename = path.basename(filename, path.extname(filename));\n      try {\n        Object.defineProperty(returnedFn, 'name', {\n          value: basename,\n          writable: false,\n          enumerable: false,\n          configurable: true\n        });\n      } catch (e) {/* ignore */}\n    }\n    return returnedFn;\n  },\n\n  generateSource: function () {\n    var opts = this.opts;\n\n    if (opts.rmWhitespace) {\n      // Have to use two separate replace here as `^` and `$` operators don't\n      // work well with `\\r` and empty lines don't work well with the `m` flag.\n      this.templateText =\n        this.templateText.replace(/[\\r\\n]+/g, '\\n').replace(/^\\s+|\\s+$/gm, '');\n    }\n\n    // Slurp spaces and tabs before <%_ and after _%>\n    this.templateText =\n      this.templateText.replace(/[ \\t]*<%_/gm, '<%_').replace(/_%>[ \\t]*/gm, '_%>');\n\n    var self = this;\n    var matches = this.parseTemplateText();\n    var d = this.opts.delimiter;\n    var o = this.opts.openDelimiter;\n    var c = this.opts.closeDelimiter;\n\n    if (matches && matches.length) {\n      matches.forEach(function (line, index) {\n        var closing;\n        // If this is an opening tag, check for closing tags\n        // FIXME: May end up with some false positives here\n        // Better to store modes as k/v with openDelimiter + delimiter as key\n        // Then this can simply check against the map\n        if ( line.indexOf(o + d) === 0        // If it is a tag\n          && line.indexOf(o + d + d) !== 0) { // and is not escaped\n          closing = matches[index + 2];\n          if (!(closing == d + c || closing == '-' + d + c || closing == '_' + d + c)) {\n            throw new Error('Could not find matching close tag for \"' + line + '\".');\n          }\n        }\n        self.scanLine(line);\n      });\n    }\n\n  },\n\n  parseTemplateText: function () {\n    var str = this.templateText;\n    var pat = this.regex;\n    var result = pat.exec(str);\n    var arr = [];\n    var firstPos;\n\n    while (result) {\n      firstPos = result.index;\n\n      if (firstPos !== 0) {\n        arr.push(str.substring(0, firstPos));\n        str = str.slice(firstPos);\n      }\n\n      arr.push(result[0]);\n      str = str.slice(result[0].length);\n      result = pat.exec(str);\n    }\n\n    if (str) {\n      arr.push(str);\n    }\n\n    return arr;\n  },\n\n  _addOutput: function (line) {\n    if (this.truncate) {\n      // Only replace single leading linebreak in the line after\n      // -%> tag -- this is the single, trailing linebreak\n      // after the tag that the truncation mode replaces\n      // Handle Win / Unix / old Mac linebreaks -- do the \\r\\n\n      // combo first in the regex-or\n      line = line.replace(/^(?:\\r\\n|\\r|\\n)/, '');\n      this.truncate = false;\n    }\n    if (!line) {\n      return line;\n    }\n\n    // Preserve literal slashes\n    line = line.replace(/\\\\/g, '\\\\\\\\');\n\n    // Convert linebreaks\n    line = line.replace(/\\n/g, '\\\\n');\n    line = line.replace(/\\r/g, '\\\\r');\n\n    // Escape double-quotes\n    // - this will be the delimiter during execution\n    line = line.replace(/\"/g, '\\\\\"');\n    this.source += '    ; __append(\"' + line + '\")' + '\\n';\n  },\n\n  scanLine: function (line) {\n    var self = this;\n    var d = this.opts.delimiter;\n    var o = this.opts.openDelimiter;\n    var c = this.opts.closeDelimiter;\n    var newLineCount = 0;\n\n    newLineCount = (line.split('\\n').length - 1);\n\n    switch (line) {\n    case o + d:\n    case o + d + '_':\n      this.mode = Template.modes.EVAL;\n      break;\n    case o + d + '=':\n      this.mode = Template.modes.ESCAPED;\n      break;\n    case o + d + '-':\n      this.mode = Template.modes.RAW;\n      break;\n    case o + d + '#':\n      this.mode = Template.modes.COMMENT;\n      break;\n    case o + d + d:\n      this.mode = Template.modes.LITERAL;\n      this.source += '    ; __append(\"' + line.replace(o + d + d, o + d) + '\")' + '\\n';\n      break;\n    case d + d + c:\n      this.mode = Template.modes.LITERAL;\n      this.source += '    ; __append(\"' + line.replace(d + d + c, d + c) + '\")' + '\\n';\n      break;\n    case d + c:\n    case '-' + d + c:\n    case '_' + d + c:\n      if (this.mode == Template.modes.LITERAL) {\n        this._addOutput(line);\n      }\n\n      this.mode = null;\n      this.truncate = line.indexOf('-') === 0 || line.indexOf('_') === 0;\n      break;\n    default:\n      // In script mode, depends on type of tag\n      if (this.mode) {\n        // If '//' is found without a line break, add a line break.\n        switch (this.mode) {\n        case Template.modes.EVAL:\n        case Template.modes.ESCAPED:\n        case Template.modes.RAW:\n          if (line.lastIndexOf('//') > line.lastIndexOf('\\n')) {\n            line += '\\n';\n          }\n        }\n        switch (this.mode) {\n        // Just executing code\n        case Template.modes.EVAL:\n          this.source += '    ; ' + line + '\\n';\n          break;\n          // Exec, esc, and output\n        case Template.modes.ESCAPED:\n          this.source += '    ; __append(escapeFn(' + stripSemi(line) + '))' + '\\n';\n          break;\n          // Exec and output\n        case Template.modes.RAW:\n          this.source += '    ; __append(' + stripSemi(line) + ')' + '\\n';\n          break;\n        case Template.modes.COMMENT:\n          // Do nothing\n          break;\n          // Literal <%% mode, append as raw output\n        case Template.modes.LITERAL:\n          this._addOutput(line);\n          break;\n        }\n      }\n      // In string mode, just add the output\n      else {\n        this._addOutput(line);\n      }\n    }\n\n    if (self.opts.compileDebug && newLineCount) {\n      this.currentLine += newLineCount;\n      this.source += '    ; __line = ' + this.currentLine + '\\n';\n    }\n  }\n};\n\n/**\n * Escape characters reserved in XML.\n *\n * This is simply an export of {@link module:utils.escapeXML}.\n *\n * If `markup` is `undefined` or `null`, the empty string is returned.\n *\n * @param {String} markup Input string\n * @return {String} Escaped string\n * @public\n * @func\n * */\nexports.escapeXML = utils.escapeXML;\n\n/**\n * Express.js support.\n *\n * This is an alias for {@link module:ejs.renderFile}, in order to support\n * Express.js out-of-the-box.\n *\n * @func\n */\n\nexports.__express = exports.renderFile;\n\n/**\n * Version of EJS.\n *\n * @readonly\n * @type {String}\n * @public\n */\n\nexports.VERSION = _VERSION_STRING;\n\n/**\n * Name for detection of EJS.\n *\n * @readonly\n * @type {String}\n * @public\n */\n\nexports.name = _NAME;\n\n/* istanbul ignore if */\nif (typeof window != 'undefined') {\n  window.ejs = exports;\n}\n\n\n\n/***/ }),\n\n/***/ 3182:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n/*\n * EJS Embedded JavaScript templates\n * Copyright 2112 Matthew Eernisse (mde@fleegix.org)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n*/\n\n/**\n * Private utility functions\n * @module utils\n * @private\n */\n\n\n\nvar regExpChars = /[|\\\\{}()[\\]^$+*?.]/g;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); };\n\n/**\n * Escape characters reserved in regular expressions.\n *\n * If `string` is `undefined` or `null`, the empty string is returned.\n *\n * @param {String} string Input string\n * @return {String} Escaped string\n * @static\n * @private\n */\nexports.escapeRegExpChars = function (string) {\n  // istanbul ignore if\n  if (!string) {\n    return '';\n  }\n  return String(string).replace(regExpChars, '\\\\$&');\n};\n\nvar _ENCODE_HTML_RULES = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&#34;',\n  \"'\": '&#39;'\n};\nvar _MATCH_HTML = /[&<>'\"]/g;\n\nfunction encode_char(c) {\n  return _ENCODE_HTML_RULES[c] || c;\n}\n\n/**\n * Stringified version of constants used by {@link module:utils.escapeXML}.\n *\n * It is used in the process of generating {@link ClientFunction}s.\n *\n * @readonly\n * @type {String}\n */\n\nvar escapeFuncStr =\n  'var _ENCODE_HTML_RULES = {\\n'\n+ '      \"&\": \"&amp;\"\\n'\n+ '    , \"<\": \"&lt;\"\\n'\n+ '    , \">\": \"&gt;\"\\n'\n+ '    , \\'\"\\': \"&#34;\"\\n'\n+ '    , \"\\'\": \"&#39;\"\\n'\n+ '    }\\n'\n+ '  , _MATCH_HTML = /[&<>\\'\"]/g;\\n'\n+ 'function encode_char(c) {\\n'\n+ '  return _ENCODE_HTML_RULES[c] || c;\\n'\n+ '};\\n';\n\n/**\n * Escape characters reserved in XML.\n *\n * If `markup` is `undefined` or `null`, the empty string is returned.\n *\n * @implements {EscapeCallback}\n * @param {String} markup Input string\n * @return {String} Escaped string\n * @static\n * @private\n */\n\nexports.escapeXML = function (markup) {\n  return markup == undefined\n    ? ''\n    : String(markup)\n      .replace(_MATCH_HTML, encode_char);\n};\n\nfunction escapeXMLToString() {\n  return Function.prototype.toString.call(this) + ';\\n' + escapeFuncStr;\n}\n\ntry {\n  if (typeof Object.defineProperty === 'function') {\n  // If the Function prototype is frozen, the \"toString\" property is non-writable. This means that any objects which inherit this property\n  // cannot have the property changed using an assignment. If using strict mode, attempting that will cause an error. If not using strict\n  // mode, attempting that will be silently ignored.\n  // However, we can still explicitly shadow the prototype's \"toString\" property by defining a new \"toString\" property on this object.\n    Object.defineProperty(exports.escapeXML, 'toString', { value: escapeXMLToString });\n  } else {\n    // If Object.defineProperty() doesn't exist, attempt to shadow this property using the assignment operator.\n    exports.escapeXML.toString = escapeXMLToString;\n  }\n} catch (err) {\n  console.warn('Unable to set escapeXML.toString (is the Function prototype frozen?)');\n}\n\n/**\n * Naive copy of properties from one object to another.\n * Does not recurse into non-scalar properties\n * Does not check to see if the property has a value before copying\n *\n * @param  {Object} to   Destination object\n * @param  {Object} from Source object\n * @return {Object}      Destination object\n * @static\n * @private\n */\nexports.shallowCopy = function (to, from) {\n  from = from || {};\n  if ((to !== null) && (to !== undefined)) {\n    for (var p in from) {\n      if (!hasOwn(from, p)) {\n        continue;\n      }\n      if (p === '__proto__' || p === 'constructor') {\n        continue;\n      }\n      to[p] = from[p];\n    }\n  }\n  return to;\n};\n\n/**\n * Naive copy of a list of key names, from one object to another.\n * Only copies property if it is actually defined\n * Does not recurse into non-scalar properties\n *\n * @param  {Object} to   Destination object\n * @param  {Object} from Source object\n * @param  {Array} list List of properties to copy\n * @return {Object}      Destination object\n * @static\n * @private\n */\nexports.shallowCopyFromList = function (to, from, list) {\n  list = list || [];\n  from = from || {};\n  if ((to !== null) && (to !== undefined)) {\n    for (var i = 0; i < list.length; i++) {\n      var p = list[i];\n      if (typeof from[p] != 'undefined') {\n        if (!hasOwn(from, p)) {\n          continue;\n        }\n        if (p === '__proto__' || p === 'constructor') {\n          continue;\n        }\n        to[p] = from[p];\n      }\n    }\n  }\n  return to;\n};\n\n/**\n * Simple in-process cache implementation. Does not implement limits of any\n * sort.\n *\n * @implements {Cache}\n * @static\n * @private\n */\nexports.cache = {\n  _data: {},\n  set: function (key, val) {\n    this._data[key] = val;\n  },\n  get: function (key) {\n    return this._data[key];\n  },\n  remove: function (key) {\n    delete this._data[key];\n  },\n  reset: function () {\n    this._data = {};\n  }\n};\n\n/**\n * Transforms hyphen case variable into camel case.\n *\n * @param {String} string Hyphen case string\n * @return {String} Camel case string\n * @static\n * @private\n */\nexports.hyphenToCamel = function (str) {\n  return str.replace(/-[a-z]/g, function (match) { return match[1].toUpperCase(); });\n};\n\n/**\n * Returns a null-prototype object in runtimes that support it\n *\n * @return {Object} Object, prototype will be set to null where possible\n * @static\n * @private\n */\nexports.createNullProtoObjWherePossible = (function () {\n  if (typeof Object.create == 'function') {\n    return function () {\n      return Object.create(null);\n    };\n  }\n  if (!({__proto__: null} instanceof Object)) {\n    return function () {\n      return {__proto__: null};\n    };\n  }\n  // Not possible, just pass through\n  return function () {\n    return {};\n  };\n})();\n\nexports.hasOwnOnlyObject = function (obj) {\n  var o = exports.createNullProtoObjWherePossible();\n  for (var p in obj) {\n    if (hasOwn(obj, p)) {\n      o[p] = obj[p];\n    }\n  }\n  return o;\n};\n\n\n\n/***/ }),\n\n/***/ 9878:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.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 = void 0;\nvar decode_data_html_js_1 = __importDefault(__webpack_require__(3603));\nexports.htmlDecodeTree = decode_data_html_js_1.default;\nvar decode_data_xml_js_1 = __importDefault(__webpack_require__(2517));\nexports.xmlDecodeTree = decode_data_xml_js_1.default;\nvar decode_codepoint_js_1 = __importStar(__webpack_require__(5096));\nexports.decodeCodePoint = decode_codepoint_js_1.default;\nvar decode_codepoint_js_2 = __webpack_require__(5096);\nObject.defineProperty(exports, \"replaceCodePoint\", ({ enumerable: true, get: function () { return decode_codepoint_js_2.replaceCodePoint; } }));\nObject.defineProperty(exports, \"fromCodePoint\", ({ enumerable: true, get: function () { return decode_codepoint_js_2.fromCodePoint; } }));\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n    CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n    CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n    CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n    CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nvar TO_LOWER_BIT = 32;\nvar BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 16256] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags = exports.BinTrieFlags || (exports.BinTrieFlags = {}));\nfunction isNumber(code) {\n    return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));\n}\nfunction isAsciiAlphaNumeric(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||\n        isNumber(code));\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\nvar DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode = exports.DecodingMode || (exports.DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nvar EntityDecoder = /** @class */ (function () {\n    function EntityDecoder(\n    /** The tree used to decode entities. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For multi-byte named entities, this will be called multiple times,\n     * with the second codepoint, and the same `consumed` value.\n     *\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of bytes consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n        /** The current state of the decoder. */\n        this.state = EntityDecoderState.EntityStart;\n        /** Characters that were consumed while parsing an entity. */\n        this.consumed = 1;\n        /**\n         * The result of the entity.\n         *\n         * Either the result index of a numeric entity, or the codepoint of a\n         * numeric entity.\n         */\n        this.result = 0;\n        /** The current index in the decode tree. */\n        this.treeIndex = 0;\n        /** The number of characters that were consumed in excess. */\n        this.excess = 1;\n        /** The mode in which the decoder is operating. */\n        this.decodeMode = DecodingMode.Strict;\n    }\n    /** Resets the instance to make it reusable. */\n    EntityDecoder.prototype.startEntity = function (decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n    };\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     *\n     * @param string The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    EntityDecoder.prototype.write = function (str, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (str.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(str, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(str, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(str, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(str, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(str, offset);\n            }\n            case EntityDecoderState.NamedEntity: {\n                return this.stateNamedEntity(str, offset);\n            }\n        }\n    };\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    EntityDecoder.prototype.stateNumericStart = function (str, offset) {\n        if (offset >= str.length) {\n            return -1;\n        }\n        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(str, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(str, offset);\n    };\n    EntityDecoder.prototype.addToNumericResult = function (str, start, end, base) {\n        if (start !== end) {\n            var digitCount = end - start;\n            this.result =\n                this.result * Math.pow(base, digitCount) +\n                    parseInt(str.substr(start, digitCount), base);\n            this.consumed += digitCount;\n        }\n    };\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    EntityDecoder.prototype.stateNumericHex = function (str, offset) {\n        var startIdx = offset;\n        while (offset < str.length) {\n            var char = str.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 16);\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 16);\n        return -1;\n    };\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    EntityDecoder.prototype.stateNumericDecimal = function (str, offset) {\n        var startIdx = offset;\n        while (offset < str.length) {\n            var char = str.charCodeAt(offset);\n            if (isNumber(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 10);\n                return this.emitNumericEntity(char, 2);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 10);\n        return -1;\n    };\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     *\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    EntityDecoder.prototype.emitNumericEntity = function (lastCp, expectedLength) {\n        var _a;\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint((0, decode_codepoint_js_1.replaceCodePoint)(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    };\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    EntityDecoder.prototype.stateNamedEntity = function (str, offset) {\n        var decodeTree = this.decodeTree;\n        var current = decodeTree[this.treeIndex];\n        // The mask is the number of bytes of the value, including the current byte.\n        var valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n        for (; offset < str.length; offset++, this.excess++) {\n            var char = str.charCodeAt(offset);\n            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n            if (this.treeIndex < 0) {\n                return this.result === 0 ||\n                    // If we are parsing an attribute\n                    (this.decodeMode === DecodingMode.Attribute &&\n                        // We shouldn't have consumed any characters after the entity,\n                        (valueLength === 0 ||\n                            // And there should be no invalid characters.\n                            isEntityInAttributeInvalidEnd(char)))\n                    ? 0\n                    : this.emitNotTerminatedNamedEntity();\n            }\n            current = decodeTree[this.treeIndex];\n            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            // If the branch is a value, store it and continue\n            if (valueLength !== 0) {\n                // If the entity is terminated by a semicolon, we are done.\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n                }\n                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n                if (this.decodeMode !== DecodingMode.Strict) {\n                    this.result = this.treeIndex;\n                    this.consumed += this.excess;\n                    this.excess = 0;\n                }\n            }\n        }\n        return -1;\n    };\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     *\n     * @returns The number of characters consumed.\n     */\n    EntityDecoder.prototype.emitNotTerminatedNamedEntity = function () {\n        var _a;\n        var _b = this, result = _b.result, decodeTree = _b.decodeTree;\n        var valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    };\n    /**\n     * Emit a named entity.\n     *\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength The number of bytes in the entity.\n     * @param consumed The number of characters consumed.\n     *\n     * @returns The number of characters consumed.\n     */\n    EntityDecoder.prototype.emitNamedEntityData = function (result, valueLength, consumed) {\n        var decodeTree = this.decodeTree;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // For multi-byte values, we need to emit the second byte.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    };\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     *\n     * @returns The number of characters consumed.\n     */\n    EntityDecoder.prototype.end = function () {\n        var _a;\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            case EntityDecoderState.EntityStart: {\n                // Return 0 if we have no entity.\n                return 0;\n            }\n        }\n    };\n    return EntityDecoder;\n}());\nexports.EntityDecoder = EntityDecoder;\n/**\n * Creates a function that decodes entities in a string.\n *\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n    var ret = \"\";\n    var decoder = new EntityDecoder(decodeTree, function (str) { return (ret += (0, decode_codepoint_js_1.fromCodePoint)(str)); });\n    return function decodeWithTrie(str, decodeMode) {\n        var lastIndex = 0;\n        var offset = 0;\n        while ((offset = str.indexOf(\"&\", offset)) >= 0) {\n            ret += str.slice(lastIndex, offset);\n            decoder.startEntity(decodeMode);\n            var len = decoder.write(str, \n            // Skip the \"&\"\n            offset + 1);\n            if (len < 0) {\n                lastIndex = offset + decoder.end();\n                break;\n            }\n            lastIndex = offset + len;\n            // If `len` is 0, skip the current `&` and continue.\n            offset = len === 0 ? lastIndex + 1 : lastIndex;\n        }\n        var result = ret + str.slice(lastIndex);\n        // Make sure we don't keep a reference to the final string.\n        ret = \"\";\n        return result;\n    };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIdx The index right after the current node and its value.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nfunction determineBranch(decodeTree, current, nodeIdx, char) {\n    var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    var jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch encoded in jump offset\n    if (branchCount === 0) {\n        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;\n    }\n    // Case 2: Multiple branches encoded in jump table\n    if (jumpOffset) {\n        var value = char - jumpOffset;\n        return value < 0 || value >= branchCount\n            ? -1\n            : decodeTree[nodeIdx + value] - 1;\n    }\n    // Case 3: Multiple branches encoded in dictionary\n    // Binary search for the character.\n    var lo = nodeIdx;\n    var hi = lo + branchCount - 1;\n    while (lo <= hi) {\n        var mid = (lo + hi) >>> 1;\n        var midVal = decodeTree[mid];\n        if (midVal < char) {\n            lo = mid + 1;\n        }\n        else if (midVal > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[mid + branchCount];\n        }\n    }\n    return -1;\n}\nexports.determineBranch = determineBranch;\nvar htmlDecoder = getDecoder(decode_data_html_js_1.default);\nvar xmlDecoder = getDecoder(decode_data_xml_js_1.default);\n/**\n * Decodes an HTML string.\n *\n * @param str The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nfunction decodeHTML(str, mode) {\n    if (mode === void 0) { mode = DecodingMode.Legacy; }\n    return htmlDecoder(str, mode);\n}\nexports.decodeHTML = decodeHTML;\n/**\n * Decodes an HTML string in an attribute.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nfunction decodeHTMLAttribute(str) {\n    return htmlDecoder(str, DecodingMode.Attribute);\n}\nexports.decodeHTMLAttribute = decodeHTMLAttribute;\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nfunction decodeHTMLStrict(str) {\n    return htmlDecoder(str, DecodingMode.Strict);\n}\nexports.decodeHTMLStrict = decodeHTMLStrict;\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nfunction decodeXML(str) {\n    return xmlDecoder(str, DecodingMode.Strict);\n}\nexports.decodeXML = decodeXML;\n//# sourceMappingURL=decode.js.map\n\n/***/ }),\n\n/***/ 5096:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.replaceCodePoint = exports.fromCodePoint = void 0;\nvar decodeMap = new Map([\n    [0, 65533],\n    // C1 Unicode control character reference replacements\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexports.fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n    var output = \"\";\n    if (codePoint > 0xffff) {\n        codePoint -= 0x10000;\n        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n        codePoint = 0xdc00 | (codePoint & 0x3ff);\n    }\n    output += String.fromCharCode(codePoint);\n    return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nfunction replaceCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return 0xfffd;\n    }\n    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\nexports.replaceCodePoint = replaceCodePoint;\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nfunction decodeCodePoint(codePoint) {\n    return (0, exports.fromCodePoint)(replaceCodePoint(codePoint));\n}\nexports[\"default\"] = decodeCodePoint;\n//# sourceMappingURL=decode_codepoint.js.map\n\n/***/ }),\n\n/***/ 1818:\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.encodeNonAsciiHTML = exports.encodeHTML = void 0;\nvar encode_html_js_1 = __importDefault(__webpack_require__(5504));\nvar escape_js_1 = __webpack_require__(5987);\nvar htmlReplacer = /[\\t\\n!-,./:-@[-`\\f{-}$\\x80-\\uFFFF]/g;\n/**\n * Encodes all characters in the input using HTML entities. This includes\n * characters that are valid ASCII characters in HTML documents, such as `#`.\n *\n * To get a more compact output, consider using the `encodeNonAsciiHTML`\n * function, which will only encode characters that are not valid in HTML\n * documents, as well as non-ASCII characters.\n *\n * If a character has no equivalent entity, a numeric hexadecimal reference\n * (eg. `&#xfc;`) will be used.\n */\nfunction encodeHTML(data) {\n    return encodeHTMLTrieRe(htmlReplacer, data);\n}\nexports.encodeHTML = encodeHTML;\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in HTML\n * documents using HTML entities. This function will not encode characters that\n * are valid in HTML documents, such as `#`.\n *\n * If a character has no equivalent entity, a numeric hexadecimal reference\n * (eg. `&#xfc;`) will be used.\n */\nfunction encodeNonAsciiHTML(data) {\n    return encodeHTMLTrieRe(escape_js_1.xmlReplacer, data);\n}\nexports.encodeNonAsciiHTML = encodeNonAsciiHTML;\nfunction encodeHTMLTrieRe(regExp, str) {\n    var ret = \"\";\n    var lastIdx = 0;\n    var match;\n    while ((match = regExp.exec(str)) !== null) {\n        var i = match.index;\n        ret += str.substring(lastIdx, i);\n        var char = str.charCodeAt(i);\n        var next = encode_html_js_1.default.get(char);\n        if (typeof next === \"object\") {\n            // We are in a branch. Try to match the next char.\n            if (i + 1 < str.length) {\n                var nextChar = str.charCodeAt(i + 1);\n                var value = typeof next.n === \"number\"\n                    ? next.n === nextChar\n                        ? next.o\n                        : undefined\n                    : next.n.get(nextChar);\n                if (value !== undefined) {\n                    ret += value;\n                    lastIdx = regExp.lastIndex += 1;\n                    continue;\n                }\n            }\n            next = next.v;\n        }\n        // We might have a tree node without a value; skip and use a numeric entity.\n        if (next !== undefined) {\n            ret += next;\n            lastIdx = i + 1;\n        }\n        else {\n            var cp = (0, escape_js_1.getCodePoint)(str, i);\n            ret += \"&#x\".concat(cp.toString(16), \";\");\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = regExp.lastIndex += Number(cp !== char);\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\n//# sourceMappingURL=encode.js.map\n\n/***/ }),\n\n/***/ 5987:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.escapeText = exports.escapeAttribute = exports.escapeUTF8 = exports.escape = exports.encodeXML = exports.getCodePoint = exports.xmlReplacer = void 0;\nexports.xmlReplacer = /[\"&'<>$\\x80-\\uFFFF]/g;\nvar xmlCodeMap = new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [39, \"&apos;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n]);\n// For compatibility with node < 4, we wrap `codePointAt`\nexports.getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? function (str, index) { return str.codePointAt(index); }\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        function (c, index) {\n            return (c.charCodeAt(index) & 0xfc00) === 0xd800\n                ? (c.charCodeAt(index) - 0xd800) * 0x400 +\n                    c.charCodeAt(index + 1) -\n                    0xdc00 +\n                    0x10000\n                : c.charCodeAt(index);\n        };\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nfunction encodeXML(str) {\n    var ret = \"\";\n    var lastIdx = 0;\n    var match;\n    while ((match = exports.xmlReplacer.exec(str)) !== null) {\n        var i = match.index;\n        var char = str.charCodeAt(i);\n        var next = xmlCodeMap.get(char);\n        if (next !== undefined) {\n            ret += str.substring(lastIdx, i) + next;\n            lastIdx = i + 1;\n        }\n        else {\n            ret += \"\".concat(str.substring(lastIdx, i), \"&#x\").concat((0, exports.getCodePoint)(str, i).toString(16), \";\");\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = exports.xmlReplacer.lastIndex += Number((char & 0xfc00) === 0xd800);\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\nexports.encodeXML = encodeXML;\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nexports.escape = encodeXML;\n/**\n * Creates a function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n *\n * @param regex Regular expression to match characters to escape.\n * @param map Map of characters to escape to their entities.\n *\n * @returns Function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n */\nfunction getEscaper(regex, map) {\n    return function escape(data) {\n        var match;\n        var lastIdx = 0;\n        var result = \"\";\n        while ((match = regex.exec(data))) {\n            if (lastIdx !== match.index) {\n                result += data.substring(lastIdx, match.index);\n            }\n            // We know that this character will be in the map.\n            result += map.get(match[0].charCodeAt(0));\n            // Every match will be of length 1\n            lastIdx = match.index + 1;\n        }\n        return result + data.substring(lastIdx);\n    };\n}\n/**\n * Encodes all characters not valid in XML documents using XML entities.\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nexports.escapeUTF8 = getEscaper(/[&<>'\"]/g, xmlCodeMap);\n/**\n * Encodes all characters that have to be escaped in HTML attributes,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexports.escapeAttribute = getEscaper(/[\"&\\u00A0]/g, new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [160, \"&nbsp;\"],\n]));\n/**\n * Encodes all characters that have to be escaped in HTML text,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexports.escapeText = getEscaper(/[&<>\\u00A0]/g, new Map([\n    [38, \"&amp;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n    [160, \"&nbsp;\"],\n]));\n//# sourceMappingURL=escape.js.map\n\n/***/ }),\n\n/***/ 3603:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Generated using scripts/write-decode-map.ts\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports[\"default\"] = new Uint16Array(\n// prettier-ignore\n\"\\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\"\n    .split(\"\")\n    .map(function (c) { return c.charCodeAt(0); }));\n//# sourceMappingURL=decode-data-html.js.map\n\n/***/ }),\n\n/***/ 2517:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Generated using scripts/write-decode-map.ts\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports[\"default\"] = new Uint16Array(\n// prettier-ignore\n\"\\u0200aglq\\t\\x15\\x18\\x1b\\u026d\\x0f\\0\\0\\x12p;\\u4026os;\\u4027t;\\u403et;\\u403cuot;\\u4022\"\n    .split(\"\")\n    .map(function (c) { return c.charCodeAt(0); }));\n//# sourceMappingURL=decode-data-xml.js.map\n\n/***/ }),\n\n/***/ 5504:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n// Generated using scripts/write-encode-map.ts\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nfunction restoreDiff(arr) {\n    for (var i = 1; i < arr.length; i++) {\n        arr[i][0] += arr[i - 1][0] + 1;\n    }\n    return arr;\n}\n// prettier-ignore\nexports[\"default\"] = new Map(/* #__PURE__ */ restoreDiff([[9, \"&Tab;\"], [0, \"&NewLine;\"], [22, \"&excl;\"], [0, \"&quot;\"], [0, \"&num;\"], [0, \"&dollar;\"], [0, \"&percnt;\"], [0, \"&amp;\"], [0, \"&apos;\"], [0, \"&lpar;\"], [0, \"&rpar;\"], [0, \"&ast;\"], [0, \"&plus;\"], [0, \"&comma;\"], [1, \"&period;\"], [0, \"&sol;\"], [10, \"&colon;\"], [0, \"&semi;\"], [0, { v: \"&lt;\", n: 8402, o: \"&nvlt;\" }], [0, { v: \"&equals;\", n: 8421, o: \"&bne;\" }], [0, { v: \"&gt;\", n: 8402, o: \"&nvgt;\" }], [0, \"&quest;\"], [0, \"&commat;\"], [26, \"&lbrack;\"], [0, \"&bsol;\"], [0, \"&rbrack;\"], [0, \"&Hat;\"], [0, \"&lowbar;\"], [0, \"&DiacriticalGrave;\"], [5, { n: 106, o: \"&fjlig;\" }], [20, \"&lbrace;\"], [0, \"&verbar;\"], [0, \"&rbrace;\"], [34, \"&nbsp;\"], [0, \"&iexcl;\"], [0, \"&cent;\"], [0, \"&pound;\"], [0, \"&curren;\"], [0, \"&yen;\"], [0, \"&brvbar;\"], [0, \"&sect;\"], [0, \"&die;\"], [0, \"&copy;\"], [0, \"&ordf;\"], [0, \"&laquo;\"], [0, \"&not;\"], [0, \"&shy;\"], [0, \"&circledR;\"], [0, \"&macr;\"], [0, \"&deg;\"], [0, \"&PlusMinus;\"], [0, \"&sup2;\"], [0, \"&sup3;\"], [0, \"&acute;\"], [0, \"&micro;\"], [0, \"&para;\"], [0, \"&centerdot;\"], [0, \"&cedil;\"], [0, \"&sup1;\"], [0, \"&ordm;\"], [0, \"&raquo;\"], [0, \"&frac14;\"], [0, \"&frac12;\"], [0, \"&frac34;\"], [0, \"&iquest;\"], [0, \"&Agrave;\"], [0, \"&Aacute;\"], [0, \"&Acirc;\"], [0, \"&Atilde;\"], [0, \"&Auml;\"], [0, \"&angst;\"], [0, \"&AElig;\"], [0, \"&Ccedil;\"], [0, \"&Egrave;\"], [0, \"&Eacute;\"], [0, \"&Ecirc;\"], [0, \"&Euml;\"], [0, \"&Igrave;\"], [0, \"&Iacute;\"], [0, \"&Icirc;\"], [0, \"&Iuml;\"], [0, \"&ETH;\"], [0, \"&Ntilde;\"], [0, \"&Ograve;\"], [0, \"&Oacute;\"], [0, \"&Ocirc;\"], [0, \"&Otilde;\"], [0, \"&Ouml;\"], [0, \"&times;\"], [0, \"&Oslash;\"], [0, \"&Ugrave;\"], [0, \"&Uacute;\"], [0, \"&Ucirc;\"], [0, \"&Uuml;\"], [0, \"&Yacute;\"], [0, \"&THORN;\"], [0, \"&szlig;\"], [0, \"&agrave;\"], [0, \"&aacute;\"], [0, \"&acirc;\"], [0, \"&atilde;\"], [0, \"&auml;\"], [0, \"&aring;\"], [0, \"&aelig;\"], [0, \"&ccedil;\"], [0, \"&egrave;\"], [0, \"&eacute;\"], [0, \"&ecirc;\"], [0, \"&euml;\"], [0, \"&igrave;\"], [0, \"&iacute;\"], [0, \"&icirc;\"], [0, \"&iuml;\"], [0, \"&eth;\"], [0, \"&ntilde;\"], [0, \"&ograve;\"], [0, \"&oacute;\"], [0, \"&ocirc;\"], [0, \"&otilde;\"], [0, \"&ouml;\"], [0, \"&div;\"], [0, \"&oslash;\"], [0, \"&ugrave;\"], [0, \"&uacute;\"], [0, \"&ucirc;\"], [0, \"&uuml;\"], [0, \"&yacute;\"], [0, \"&thorn;\"], [0, \"&yuml;\"], [0, \"&Amacr;\"], [0, \"&amacr;\"], [0, \"&Abreve;\"], [0, \"&abreve;\"], [0, \"&Aogon;\"], [0, \"&aogon;\"], [0, \"&Cacute;\"], [0, \"&cacute;\"], [0, \"&Ccirc;\"], [0, \"&ccirc;\"], [0, \"&Cdot;\"], [0, \"&cdot;\"], [0, \"&Ccaron;\"], [0, \"&ccaron;\"], [0, \"&Dcaron;\"], [0, \"&dcaron;\"], [0, \"&Dstrok;\"], [0, \"&dstrok;\"], [0, \"&Emacr;\"], [0, \"&emacr;\"], [2, \"&Edot;\"], [0, \"&edot;\"], [0, \"&Eogon;\"], [0, \"&eogon;\"], [0, \"&Ecaron;\"], [0, \"&ecaron;\"], [0, \"&Gcirc;\"], [0, \"&gcirc;\"], [0, \"&Gbreve;\"], [0, \"&gbreve;\"], [0, \"&Gdot;\"], [0, \"&gdot;\"], [0, \"&Gcedil;\"], [1, \"&Hcirc;\"], [0, \"&hcirc;\"], [0, \"&Hstrok;\"], [0, \"&hstrok;\"], [0, \"&Itilde;\"], [0, \"&itilde;\"], [0, \"&Imacr;\"], [0, \"&imacr;\"], [2, \"&Iogon;\"], [0, \"&iogon;\"], [0, \"&Idot;\"], [0, \"&imath;\"], [0, \"&IJlig;\"], [0, \"&ijlig;\"], [0, \"&Jcirc;\"], [0, \"&jcirc;\"], [0, \"&Kcedil;\"], [0, \"&kcedil;\"], [0, \"&kgreen;\"], [0, \"&Lacute;\"], [0, \"&lacute;\"], [0, \"&Lcedil;\"], [0, \"&lcedil;\"], [0, \"&Lcaron;\"], [0, \"&lcaron;\"], [0, \"&Lmidot;\"], [0, \"&lmidot;\"], [0, \"&Lstrok;\"], [0, \"&lstrok;\"], [0, \"&Nacute;\"], [0, \"&nacute;\"], [0, \"&Ncedil;\"], [0, \"&ncedil;\"], [0, \"&Ncaron;\"], [0, \"&ncaron;\"], [0, \"&napos;\"], [0, \"&ENG;\"], [0, \"&eng;\"], [0, \"&Omacr;\"], [0, \"&omacr;\"], [2, \"&Odblac;\"], [0, \"&odblac;\"], [0, \"&OElig;\"], [0, \"&oelig;\"], [0, \"&Racute;\"], [0, \"&racute;\"], [0, \"&Rcedil;\"], [0, \"&rcedil;\"], [0, \"&Rcaron;\"], [0, \"&rcaron;\"], [0, \"&Sacute;\"], [0, \"&sacute;\"], [0, \"&Scirc;\"], [0, \"&scirc;\"], [0, \"&Scedil;\"], [0, \"&scedil;\"], [0, \"&Scaron;\"], [0, \"&scaron;\"], [0, \"&Tcedil;\"], [0, \"&tcedil;\"], [0, \"&Tcaron;\"], [0, \"&tcaron;\"], [0, \"&Tstrok;\"], [0, \"&tstrok;\"], [0, \"&Utilde;\"], [0, \"&utilde;\"], [0, \"&Umacr;\"], [0, \"&umacr;\"], [0, \"&Ubreve;\"], [0, \"&ubreve;\"], [0, \"&Uring;\"], [0, \"&uring;\"], [0, \"&Udblac;\"], [0, \"&udblac;\"], [0, \"&Uogon;\"], [0, \"&uogon;\"], [0, \"&Wcirc;\"], [0, \"&wcirc;\"], [0, \"&Ycirc;\"], [0, \"&ycirc;\"], [0, \"&Yuml;\"], [0, \"&Zacute;\"], [0, \"&zacute;\"], [0, \"&Zdot;\"], [0, \"&zdot;\"], [0, \"&Zcaron;\"], [0, \"&zcaron;\"], [19, \"&fnof;\"], [34, \"&imped;\"], [63, \"&gacute;\"], [65, \"&jmath;\"], [142, \"&circ;\"], [0, \"&caron;\"], [16, \"&breve;\"], [0, \"&DiacriticalDot;\"], [0, \"&ring;\"], [0, \"&ogon;\"], [0, \"&DiacriticalTilde;\"], [0, \"&dblac;\"], [51, \"&DownBreve;\"], [127, \"&Alpha;\"], [0, \"&Beta;\"], [0, \"&Gamma;\"], [0, \"&Delta;\"], [0, \"&Epsilon;\"], [0, \"&Zeta;\"], [0, \"&Eta;\"], [0, \"&Theta;\"], [0, \"&Iota;\"], [0, \"&Kappa;\"], [0, \"&Lambda;\"], [0, \"&Mu;\"], [0, \"&Nu;\"], [0, \"&Xi;\"], [0, \"&Omicron;\"], [0, \"&Pi;\"], [0, \"&Rho;\"], [1, \"&Sigma;\"], [0, \"&Tau;\"], [0, \"&Upsilon;\"], [0, \"&Phi;\"], [0, \"&Chi;\"], [0, \"&Psi;\"], [0, \"&ohm;\"], [7, \"&alpha;\"], [0, \"&beta;\"], [0, \"&gamma;\"], [0, \"&delta;\"], [0, \"&epsi;\"], [0, \"&zeta;\"], [0, \"&eta;\"], [0, \"&theta;\"], [0, \"&iota;\"], [0, \"&kappa;\"], [0, \"&lambda;\"], [0, \"&mu;\"], [0, \"&nu;\"], [0, \"&xi;\"], [0, \"&omicron;\"], [0, \"&pi;\"], [0, \"&rho;\"], [0, \"&sigmaf;\"], [0, \"&sigma;\"], [0, \"&tau;\"], [0, \"&upsi;\"], [0, \"&phi;\"], [0, \"&chi;\"], [0, \"&psi;\"], [0, \"&omega;\"], [7, \"&thetasym;\"], [0, \"&Upsi;\"], [2, \"&phiv;\"], [0, \"&piv;\"], [5, \"&Gammad;\"], [0, \"&digamma;\"], [18, \"&kappav;\"], [0, \"&rhov;\"], [3, \"&epsiv;\"], [0, \"&backepsilon;\"], [10, \"&IOcy;\"], [0, \"&DJcy;\"], [0, \"&GJcy;\"], [0, \"&Jukcy;\"], [0, \"&DScy;\"], [0, \"&Iukcy;\"], [0, \"&YIcy;\"], [0, \"&Jsercy;\"], [0, \"&LJcy;\"], [0, \"&NJcy;\"], [0, \"&TSHcy;\"], [0, \"&KJcy;\"], [1, \"&Ubrcy;\"], [0, \"&DZcy;\"], [0, \"&Acy;\"], [0, \"&Bcy;\"], [0, \"&Vcy;\"], [0, \"&Gcy;\"], [0, \"&Dcy;\"], [0, \"&IEcy;\"], [0, \"&ZHcy;\"], [0, \"&Zcy;\"], [0, \"&Icy;\"], [0, \"&Jcy;\"], [0, \"&Kcy;\"], [0, \"&Lcy;\"], [0, \"&Mcy;\"], [0, \"&Ncy;\"], [0, \"&Ocy;\"], [0, \"&Pcy;\"], [0, \"&Rcy;\"], [0, \"&Scy;\"], [0, \"&Tcy;\"], [0, \"&Ucy;\"], [0, \"&Fcy;\"], [0, \"&KHcy;\"], [0, \"&TScy;\"], [0, \"&CHcy;\"], [0, \"&SHcy;\"], [0, \"&SHCHcy;\"], [0, \"&HARDcy;\"], [0, \"&Ycy;\"], [0, \"&SOFTcy;\"], [0, \"&Ecy;\"], [0, \"&YUcy;\"], [0, \"&YAcy;\"], [0, \"&acy;\"], [0, \"&bcy;\"], [0, \"&vcy;\"], [0, \"&gcy;\"], [0, \"&dcy;\"], [0, \"&iecy;\"], [0, \"&zhcy;\"], [0, \"&zcy;\"], [0, \"&icy;\"], [0, \"&jcy;\"], [0, \"&kcy;\"], [0, \"&lcy;\"], [0, \"&mcy;\"], [0, \"&ncy;\"], [0, \"&ocy;\"], [0, \"&pcy;\"], [0, \"&rcy;\"], [0, \"&scy;\"], [0, \"&tcy;\"], [0, \"&ucy;\"], [0, \"&fcy;\"], [0, \"&khcy;\"], [0, \"&tscy;\"], [0, \"&chcy;\"], [0, \"&shcy;\"], [0, \"&shchcy;\"], [0, \"&hardcy;\"], [0, \"&ycy;\"], [0, \"&softcy;\"], [0, \"&ecy;\"], [0, \"&yucy;\"], [0, \"&yacy;\"], [1, \"&iocy;\"], [0, \"&djcy;\"], [0, \"&gjcy;\"], [0, \"&jukcy;\"], [0, \"&dscy;\"], [0, \"&iukcy;\"], [0, \"&yicy;\"], [0, \"&jsercy;\"], [0, \"&ljcy;\"], [0, \"&njcy;\"], [0, \"&tshcy;\"], [0, \"&kjcy;\"], [1, \"&ubrcy;\"], [0, \"&dzcy;\"], [7074, \"&ensp;\"], [0, \"&emsp;\"], [0, \"&emsp13;\"], [0, \"&emsp14;\"], [1, \"&numsp;\"], [0, \"&puncsp;\"], [0, \"&ThinSpace;\"], [0, \"&hairsp;\"], [0, \"&NegativeMediumSpace;\"], [0, \"&zwnj;\"], [0, \"&zwj;\"], [0, \"&lrm;\"], [0, \"&rlm;\"], [0, \"&dash;\"], [2, \"&ndash;\"], [0, \"&mdash;\"], [0, \"&horbar;\"], [0, \"&Verbar;\"], [1, \"&lsquo;\"], [0, \"&CloseCurlyQuote;\"], [0, \"&lsquor;\"], [1, \"&ldquo;\"], [0, \"&CloseCurlyDoubleQuote;\"], [0, \"&bdquo;\"], [1, \"&dagger;\"], [0, \"&Dagger;\"], [0, \"&bull;\"], [2, \"&nldr;\"], [0, \"&hellip;\"], [9, \"&permil;\"], [0, \"&pertenk;\"], [0, \"&prime;\"], [0, \"&Prime;\"], [0, \"&tprime;\"], [0, \"&backprime;\"], [3, \"&lsaquo;\"], [0, \"&rsaquo;\"], [3, \"&oline;\"], [2, \"&caret;\"], [1, \"&hybull;\"], [0, \"&frasl;\"], [10, \"&bsemi;\"], [7, \"&qprime;\"], [7, { v: \"&MediumSpace;\", n: 8202, o: \"&ThickSpace;\" }], [0, \"&NoBreak;\"], [0, \"&af;\"], [0, \"&InvisibleTimes;\"], [0, \"&ic;\"], [72, \"&euro;\"], [46, \"&tdot;\"], [0, \"&DotDot;\"], [37, \"&complexes;\"], [2, \"&incare;\"], [4, \"&gscr;\"], [0, \"&hamilt;\"], [0, \"&Hfr;\"], [0, \"&Hopf;\"], [0, \"&planckh;\"], [0, \"&hbar;\"], [0, \"&imagline;\"], [0, \"&Ifr;\"], [0, \"&lagran;\"], [0, \"&ell;\"], [1, \"&naturals;\"], [0, \"&numero;\"], [0, \"&copysr;\"], [0, \"&weierp;\"], [0, \"&Popf;\"], [0, \"&Qopf;\"], [0, \"&realine;\"], [0, \"&real;\"], [0, \"&reals;\"], [0, \"&rx;\"], [3, \"&trade;\"], [1, \"&integers;\"], [2, \"&mho;\"], [0, \"&zeetrf;\"], [0, \"&iiota;\"], [2, \"&bernou;\"], [0, \"&Cayleys;\"], [1, \"&escr;\"], [0, \"&Escr;\"], [0, \"&Fouriertrf;\"], [1, \"&Mellintrf;\"], [0, \"&order;\"], [0, \"&alefsym;\"], [0, \"&beth;\"], [0, \"&gimel;\"], [0, \"&daleth;\"], [12, \"&CapitalDifferentialD;\"], [0, \"&dd;\"], [0, \"&ee;\"], [0, \"&ii;\"], [10, \"&frac13;\"], [0, \"&frac23;\"], [0, \"&frac15;\"], [0, \"&frac25;\"], [0, \"&frac35;\"], [0, \"&frac45;\"], [0, \"&frac16;\"], [0, \"&frac56;\"], [0, \"&frac18;\"], [0, \"&frac38;\"], [0, \"&frac58;\"], [0, \"&frac78;\"], [49, \"&larr;\"], [0, \"&ShortUpArrow;\"], [0, \"&rarr;\"], [0, \"&darr;\"], [0, \"&harr;\"], [0, \"&updownarrow;\"], [0, \"&nwarr;\"], [0, \"&nearr;\"], [0, \"&LowerRightArrow;\"], [0, \"&LowerLeftArrow;\"], [0, \"&nlarr;\"], [0, \"&nrarr;\"], [1, { v: \"&rarrw;\", n: 824, o: \"&nrarrw;\" }], [0, \"&Larr;\"], [0, \"&Uarr;\"], [0, \"&Rarr;\"], [0, \"&Darr;\"], [0, \"&larrtl;\"], [0, \"&rarrtl;\"], [0, \"&LeftTeeArrow;\"], [0, \"&mapstoup;\"], [0, \"&map;\"], [0, \"&DownTeeArrow;\"], [1, \"&hookleftarrow;\"], [0, \"&hookrightarrow;\"], [0, \"&larrlp;\"], [0, \"&looparrowright;\"], [0, \"&harrw;\"], [0, \"&nharr;\"], [1, \"&lsh;\"], [0, \"&rsh;\"], [0, \"&ldsh;\"], [0, \"&rdsh;\"], [1, \"&crarr;\"], [0, \"&cularr;\"], [0, \"&curarr;\"], [2, \"&circlearrowleft;\"], [0, \"&circlearrowright;\"], [0, \"&leftharpoonup;\"], [0, \"&DownLeftVector;\"], [0, \"&RightUpVector;\"], [0, \"&LeftUpVector;\"], [0, \"&rharu;\"], [0, \"&DownRightVector;\"], [0, \"&dharr;\"], [0, \"&dharl;\"], [0, \"&RightArrowLeftArrow;\"], [0, \"&udarr;\"], [0, \"&LeftArrowRightArrow;\"], [0, \"&leftleftarrows;\"], [0, \"&upuparrows;\"], [0, \"&rightrightarrows;\"], [0, \"&ddarr;\"], [0, \"&leftrightharpoons;\"], [0, \"&Equilibrium;\"], [0, \"&nlArr;\"], [0, \"&nhArr;\"], [0, \"&nrArr;\"], [0, \"&DoubleLeftArrow;\"], [0, \"&DoubleUpArrow;\"], [0, \"&DoubleRightArrow;\"], [0, \"&dArr;\"], [0, \"&DoubleLeftRightArrow;\"], [0, \"&DoubleUpDownArrow;\"], [0, \"&nwArr;\"], [0, \"&neArr;\"], [0, \"&seArr;\"], [0, \"&swArr;\"], [0, \"&lAarr;\"], [0, \"&rAarr;\"], [1, \"&zigrarr;\"], [6, \"&larrb;\"], [0, \"&rarrb;\"], [15, \"&DownArrowUpArrow;\"], [7, \"&loarr;\"], [0, \"&roarr;\"], [0, \"&hoarr;\"], [0, \"&forall;\"], [0, \"&comp;\"], [0, { v: \"&part;\", n: 824, o: \"&npart;\" }], [0, \"&exist;\"], [0, \"&nexist;\"], [0, \"&empty;\"], [1, \"&Del;\"], [0, \"&Element;\"], [0, \"&NotElement;\"], [1, \"&ni;\"], [0, \"&notni;\"], [2, \"&prod;\"], [0, \"&coprod;\"], [0, \"&sum;\"], [0, \"&minus;\"], [0, \"&MinusPlus;\"], [0, \"&dotplus;\"], [1, \"&Backslash;\"], [0, \"&lowast;\"], [0, \"&compfn;\"], [1, \"&radic;\"], [2, \"&prop;\"], [0, \"&infin;\"], [0, \"&angrt;\"], [0, { v: \"&ang;\", n: 8402, o: \"&nang;\" }], [0, \"&angmsd;\"], [0, \"&angsph;\"], [0, \"&mid;\"], [0, \"&nmid;\"], [0, \"&DoubleVerticalBar;\"], [0, \"&NotDoubleVerticalBar;\"], [0, \"&and;\"], [0, \"&or;\"], [0, { v: \"&cap;\", n: 65024, o: \"&caps;\" }], [0, { v: \"&cup;\", n: 65024, o: \"&cups;\" }], [0, \"&int;\"], [0, \"&Int;\"], [0, \"&iiint;\"], [0, \"&conint;\"], [0, \"&Conint;\"], [0, \"&Cconint;\"], [0, \"&cwint;\"], [0, \"&ClockwiseContourIntegral;\"], [0, \"&awconint;\"], [0, \"&there4;\"], [0, \"&becaus;\"], [0, \"&ratio;\"], [0, \"&Colon;\"], [0, \"&dotminus;\"], [1, \"&mDDot;\"], [0, \"&homtht;\"], [0, { v: \"&sim;\", n: 8402, o: \"&nvsim;\" }], [0, { v: \"&backsim;\", n: 817, o: \"&race;\" }], [0, { v: \"&ac;\", n: 819, o: \"&acE;\" }], [0, \"&acd;\"], [0, \"&VerticalTilde;\"], [0, \"&NotTilde;\"], [0, { v: \"&eqsim;\", n: 824, o: \"&nesim;\" }], [0, \"&sime;\"], [0, \"&NotTildeEqual;\"], [0, \"&cong;\"], [0, \"&simne;\"], [0, \"&ncong;\"], [0, \"&ap;\"], [0, \"&nap;\"], [0, \"&ape;\"], [0, { v: \"&apid;\", n: 824, o: \"&napid;\" }], [0, \"&backcong;\"], [0, { v: \"&asympeq;\", n: 8402, o: \"&nvap;\" }], [0, { v: \"&bump;\", n: 824, o: \"&nbump;\" }], [0, { v: \"&bumpe;\", n: 824, o: \"&nbumpe;\" }], [0, { v: \"&doteq;\", n: 824, o: \"&nedot;\" }], [0, \"&doteqdot;\"], [0, \"&efDot;\"], [0, \"&erDot;\"], [0, \"&Assign;\"], [0, \"&ecolon;\"], [0, \"&ecir;\"], [0, \"&circeq;\"], [1, \"&wedgeq;\"], [0, \"&veeeq;\"], [1, \"&triangleq;\"], [2, \"&equest;\"], [0, \"&ne;\"], [0, { v: \"&Congruent;\", n: 8421, o: \"&bnequiv;\" }], [0, \"&nequiv;\"], [1, { v: \"&le;\", n: 8402, o: \"&nvle;\" }], [0, { v: \"&ge;\", n: 8402, o: \"&nvge;\" }], [0, { v: \"&lE;\", n: 824, o: \"&nlE;\" }], [0, { v: \"&gE;\", n: 824, o: \"&ngE;\" }], [0, { v: \"&lnE;\", n: 65024, o: \"&lvertneqq;\" }], [0, { v: \"&gnE;\", n: 65024, o: \"&gvertneqq;\" }], [0, { v: \"&ll;\", n: new Map(/* #__PURE__ */ restoreDiff([[824, \"&nLtv;\"], [7577, \"&nLt;\"]])) }], [0, { v: \"&gg;\", n: new Map(/* #__PURE__ */ restoreDiff([[824, \"&nGtv;\"], [7577, \"&nGt;\"]])) }], [0, \"&between;\"], [0, \"&NotCupCap;\"], [0, \"&nless;\"], [0, \"&ngt;\"], [0, \"&nle;\"], [0, \"&nge;\"], [0, \"&lesssim;\"], [0, \"&GreaterTilde;\"], [0, \"&nlsim;\"], [0, \"&ngsim;\"], [0, \"&LessGreater;\"], [0, \"&gl;\"], [0, \"&NotLessGreater;\"], [0, \"&NotGreaterLess;\"], [0, \"&pr;\"], [0, \"&sc;\"], [0, \"&prcue;\"], [0, \"&sccue;\"], [0, \"&PrecedesTilde;\"], [0, { v: \"&scsim;\", n: 824, o: \"&NotSucceedsTilde;\" }], [0, \"&NotPrecedes;\"], [0, \"&NotSucceeds;\"], [0, { v: \"&sub;\", n: 8402, o: \"&NotSubset;\" }], [0, { v: \"&sup;\", n: 8402, o: \"&NotSuperset;\" }], [0, \"&nsub;\"], [0, \"&nsup;\"], [0, \"&sube;\"], [0, \"&supe;\"], [0, \"&NotSubsetEqual;\"], [0, \"&NotSupersetEqual;\"], [0, { v: \"&subne;\", n: 65024, o: \"&varsubsetneq;\" }], [0, { v: \"&supne;\", n: 65024, o: \"&varsupsetneq;\" }], [1, \"&cupdot;\"], [0, \"&UnionPlus;\"], [0, { v: \"&sqsub;\", n: 824, o: \"&NotSquareSubset;\" }], [0, { v: \"&sqsup;\", n: 824, o: \"&NotSquareSuperset;\" }], [0, \"&sqsube;\"], [0, \"&sqsupe;\"], [0, { v: \"&sqcap;\", n: 65024, o: \"&sqcaps;\" }], [0, { v: \"&sqcup;\", n: 65024, o: \"&sqcups;\" }], [0, \"&CirclePlus;\"], [0, \"&CircleMinus;\"], [0, \"&CircleTimes;\"], [0, \"&osol;\"], [0, \"&CircleDot;\"], [0, \"&circledcirc;\"], [0, \"&circledast;\"], [1, \"&circleddash;\"], [0, \"&boxplus;\"], [0, \"&boxminus;\"], [0, \"&boxtimes;\"], [0, \"&dotsquare;\"], [0, \"&RightTee;\"], [0, \"&dashv;\"], [0, \"&DownTee;\"], [0, \"&bot;\"], [1, \"&models;\"], [0, \"&DoubleRightTee;\"], [0, \"&Vdash;\"], [0, \"&Vvdash;\"], [0, \"&VDash;\"], [0, \"&nvdash;\"], [0, \"&nvDash;\"], [0, \"&nVdash;\"], [0, \"&nVDash;\"], [0, \"&prurel;\"], [1, \"&LeftTriangle;\"], [0, \"&RightTriangle;\"], [0, { v: \"&LeftTriangleEqual;\", n: 8402, o: \"&nvltrie;\" }], [0, { v: \"&RightTriangleEqual;\", n: 8402, o: \"&nvrtrie;\" }], [0, \"&origof;\"], [0, \"&imof;\"], [0, \"&multimap;\"], [0, \"&hercon;\"], [0, \"&intcal;\"], [0, \"&veebar;\"], [1, \"&barvee;\"], [0, \"&angrtvb;\"], [0, \"&lrtri;\"], [0, \"&bigwedge;\"], [0, \"&bigvee;\"], [0, \"&bigcap;\"], [0, \"&bigcup;\"], [0, \"&diam;\"], [0, \"&sdot;\"], [0, \"&sstarf;\"], [0, \"&divideontimes;\"], [0, \"&bowtie;\"], [0, \"&ltimes;\"], [0, \"&rtimes;\"], [0, \"&leftthreetimes;\"], [0, \"&rightthreetimes;\"], [0, \"&backsimeq;\"], [0, \"&curlyvee;\"], [0, \"&curlywedge;\"], [0, \"&Sub;\"], [0, \"&Sup;\"], [0, \"&Cap;\"], [0, \"&Cup;\"], [0, \"&fork;\"], [0, \"&epar;\"], [0, \"&lessdot;\"], [0, \"&gtdot;\"], [0, { v: \"&Ll;\", n: 824, o: \"&nLl;\" }], [0, { v: \"&Gg;\", n: 824, o: \"&nGg;\" }], [0, { v: \"&leg;\", n: 65024, o: \"&lesg;\" }], [0, { v: \"&gel;\", n: 65024, o: \"&gesl;\" }], [2, \"&cuepr;\"], [0, \"&cuesc;\"], [0, \"&NotPrecedesSlantEqual;\"], [0, \"&NotSucceedsSlantEqual;\"], [0, \"&NotSquareSubsetEqual;\"], [0, \"&NotSquareSupersetEqual;\"], [2, \"&lnsim;\"], [0, \"&gnsim;\"], [0, \"&precnsim;\"], [0, \"&scnsim;\"], [0, \"&nltri;\"], [0, \"&NotRightTriangle;\"], [0, \"&nltrie;\"], [0, \"&NotRightTriangleEqual;\"], [0, \"&vellip;\"], [0, \"&ctdot;\"], [0, \"&utdot;\"], [0, \"&dtdot;\"], [0, \"&disin;\"], [0, \"&isinsv;\"], [0, \"&isins;\"], [0, { v: \"&isindot;\", n: 824, o: \"&notindot;\" }], [0, \"&notinvc;\"], [0, \"&notinvb;\"], [1, { v: \"&isinE;\", n: 824, o: \"&notinE;\" }], [0, \"&nisd;\"], [0, \"&xnis;\"], [0, \"&nis;\"], [0, \"&notnivc;\"], [0, \"&notnivb;\"], [6, \"&barwed;\"], [0, \"&Barwed;\"], [1, \"&lceil;\"], [0, \"&rceil;\"], [0, \"&LeftFloor;\"], [0, \"&rfloor;\"], [0, \"&drcrop;\"], [0, \"&dlcrop;\"], [0, \"&urcrop;\"], [0, \"&ulcrop;\"], [0, \"&bnot;\"], [1, \"&profline;\"], [0, \"&profsurf;\"], [1, \"&telrec;\"], [0, \"&target;\"], [5, \"&ulcorn;\"], [0, \"&urcorn;\"], [0, \"&dlcorn;\"], [0, \"&drcorn;\"], [2, \"&frown;\"], [0, \"&smile;\"], [9, \"&cylcty;\"], [0, \"&profalar;\"], [7, \"&topbot;\"], [6, \"&ovbar;\"], [1, \"&solbar;\"], [60, \"&angzarr;\"], [51, \"&lmoustache;\"], [0, \"&rmoustache;\"], [2, \"&OverBracket;\"], [0, \"&bbrk;\"], [0, \"&bbrktbrk;\"], [37, \"&OverParenthesis;\"], [0, \"&UnderParenthesis;\"], [0, \"&OverBrace;\"], [0, \"&UnderBrace;\"], [2, \"&trpezium;\"], [4, \"&elinters;\"], [59, \"&blank;\"], [164, \"&circledS;\"], [55, \"&boxh;\"], [1, \"&boxv;\"], [9, \"&boxdr;\"], [3, \"&boxdl;\"], [3, \"&boxur;\"], [3, \"&boxul;\"], [3, \"&boxvr;\"], [7, \"&boxvl;\"], [7, \"&boxhd;\"], [7, \"&boxhu;\"], [7, \"&boxvh;\"], [19, \"&boxH;\"], [0, \"&boxV;\"], [0, \"&boxdR;\"], [0, \"&boxDr;\"], [0, \"&boxDR;\"], [0, \"&boxdL;\"], [0, \"&boxDl;\"], [0, \"&boxDL;\"], [0, \"&boxuR;\"], [0, \"&boxUr;\"], [0, \"&boxUR;\"], [0, \"&boxuL;\"], [0, \"&boxUl;\"], [0, \"&boxUL;\"], [0, \"&boxvR;\"], [0, \"&boxVr;\"], [0, \"&boxVR;\"], [0, \"&boxvL;\"], [0, \"&boxVl;\"], [0, \"&boxVL;\"], [0, \"&boxHd;\"], [0, \"&boxhD;\"], [0, \"&boxHD;\"], [0, \"&boxHu;\"], [0, \"&boxhU;\"], [0, \"&boxHU;\"], [0, \"&boxvH;\"], [0, \"&boxVh;\"], [0, \"&boxVH;\"], [19, \"&uhblk;\"], [3, \"&lhblk;\"], [3, \"&block;\"], [8, \"&blk14;\"], [0, \"&blk12;\"], [0, \"&blk34;\"], [13, \"&square;\"], [8, \"&blacksquare;\"], [0, \"&EmptyVerySmallSquare;\"], [1, \"&rect;\"], [0, \"&marker;\"], [2, \"&fltns;\"], [1, \"&bigtriangleup;\"], [0, \"&blacktriangle;\"], [0, \"&triangle;\"], [2, \"&blacktriangleright;\"], [0, \"&rtri;\"], [3, \"&bigtriangledown;\"], [0, \"&blacktriangledown;\"], [0, \"&dtri;\"], [2, \"&blacktriangleleft;\"], [0, \"&ltri;\"], [6, \"&loz;\"], [0, \"&cir;\"], [32, \"&tridot;\"], [2, \"&bigcirc;\"], [8, \"&ultri;\"], [0, \"&urtri;\"], [0, \"&lltri;\"], [0, \"&EmptySmallSquare;\"], [0, \"&FilledSmallSquare;\"], [8, \"&bigstar;\"], [0, \"&star;\"], [7, \"&phone;\"], [49, \"&female;\"], [1, \"&male;\"], [29, \"&spades;\"], [2, \"&clubs;\"], [1, \"&hearts;\"], [0, \"&diamondsuit;\"], [3, \"&sung;\"], [2, \"&flat;\"], [0, \"&natural;\"], [0, \"&sharp;\"], [163, \"&check;\"], [3, \"&cross;\"], [8, \"&malt;\"], [21, \"&sext;\"], [33, \"&VerticalSeparator;\"], [25, \"&lbbrk;\"], [0, \"&rbbrk;\"], [84, \"&bsolhsub;\"], [0, \"&suphsol;\"], [28, \"&LeftDoubleBracket;\"], [0, \"&RightDoubleBracket;\"], [0, \"&lang;\"], [0, \"&rang;\"], [0, \"&Lang;\"], [0, \"&Rang;\"], [0, \"&loang;\"], [0, \"&roang;\"], [7, \"&longleftarrow;\"], [0, \"&longrightarrow;\"], [0, \"&longleftrightarrow;\"], [0, \"&DoubleLongLeftArrow;\"], [0, \"&DoubleLongRightArrow;\"], [0, \"&DoubleLongLeftRightArrow;\"], [1, \"&longmapsto;\"], [2, \"&dzigrarr;\"], [258, \"&nvlArr;\"], [0, \"&nvrArr;\"], [0, \"&nvHarr;\"], [0, \"&Map;\"], [6, \"&lbarr;\"], [0, \"&bkarow;\"], [0, \"&lBarr;\"], [0, \"&dbkarow;\"], [0, \"&drbkarow;\"], [0, \"&DDotrahd;\"], [0, \"&UpArrowBar;\"], [0, \"&DownArrowBar;\"], [2, \"&Rarrtl;\"], [2, \"&latail;\"], [0, \"&ratail;\"], [0, \"&lAtail;\"], [0, \"&rAtail;\"], [0, \"&larrfs;\"], [0, \"&rarrfs;\"], [0, \"&larrbfs;\"], [0, \"&rarrbfs;\"], [2, \"&nwarhk;\"], [0, \"&nearhk;\"], [0, \"&hksearow;\"], [0, \"&hkswarow;\"], [0, \"&nwnear;\"], [0, \"&nesear;\"], [0, \"&seswar;\"], [0, \"&swnwar;\"], [8, { v: \"&rarrc;\", n: 824, o: \"&nrarrc;\" }], [1, \"&cudarrr;\"], [0, \"&ldca;\"], [0, \"&rdca;\"], [0, \"&cudarrl;\"], [0, \"&larrpl;\"], [2, \"&curarrm;\"], [0, \"&cularrp;\"], [7, \"&rarrpl;\"], [2, \"&harrcir;\"], [0, \"&Uarrocir;\"], [0, \"&lurdshar;\"], [0, \"&ldrushar;\"], [2, \"&LeftRightVector;\"], [0, \"&RightUpDownVector;\"], [0, \"&DownLeftRightVector;\"], [0, \"&LeftUpDownVector;\"], [0, \"&LeftVectorBar;\"], [0, \"&RightVectorBar;\"], [0, \"&RightUpVectorBar;\"], [0, \"&RightDownVectorBar;\"], [0, \"&DownLeftVectorBar;\"], [0, \"&DownRightVectorBar;\"], [0, \"&LeftUpVectorBar;\"], [0, \"&LeftDownVectorBar;\"], [0, \"&LeftTeeVector;\"], [0, \"&RightTeeVector;\"], [0, \"&RightUpTeeVector;\"], [0, \"&RightDownTeeVector;\"], [0, \"&DownLeftTeeVector;\"], [0, \"&DownRightTeeVector;\"], [0, \"&LeftUpTeeVector;\"], [0, \"&LeftDownTeeVector;\"], [0, \"&lHar;\"], [0, \"&uHar;\"], [0, \"&rHar;\"], [0, \"&dHar;\"], [0, \"&luruhar;\"], [0, \"&ldrdhar;\"], [0, \"&ruluhar;\"], [0, \"&rdldhar;\"], [0, \"&lharul;\"], [0, \"&llhard;\"], [0, \"&rharul;\"], [0, \"&lrhard;\"], [0, \"&udhar;\"], [0, \"&duhar;\"], [0, \"&RoundImplies;\"], [0, \"&erarr;\"], [0, \"&simrarr;\"], [0, \"&larrsim;\"], [0, \"&rarrsim;\"], [0, \"&rarrap;\"], [0, \"&ltlarr;\"], [1, \"&gtrarr;\"], [0, \"&subrarr;\"], [1, \"&suplarr;\"], [0, \"&lfisht;\"], [0, \"&rfisht;\"], [0, \"&ufisht;\"], [0, \"&dfisht;\"], [5, \"&lopar;\"], [0, \"&ropar;\"], [4, \"&lbrke;\"], [0, \"&rbrke;\"], [0, \"&lbrkslu;\"], [0, \"&rbrksld;\"], [0, \"&lbrksld;\"], [0, \"&rbrkslu;\"], [0, \"&langd;\"], [0, \"&rangd;\"], [0, \"&lparlt;\"], [0, \"&rpargt;\"], [0, \"&gtlPar;\"], [0, \"&ltrPar;\"], [3, \"&vzigzag;\"], [1, \"&vangrt;\"], [0, \"&angrtvbd;\"], [6, \"&ange;\"], [0, \"&range;\"], [0, \"&dwangle;\"], [0, \"&uwangle;\"], [0, \"&angmsdaa;\"], [0, \"&angmsdab;\"], [0, \"&angmsdac;\"], [0, \"&angmsdad;\"], [0, \"&angmsdae;\"], [0, \"&angmsdaf;\"], [0, \"&angmsdag;\"], [0, \"&angmsdah;\"], [0, \"&bemptyv;\"], [0, \"&demptyv;\"], [0, \"&cemptyv;\"], [0, \"&raemptyv;\"], [0, \"&laemptyv;\"], [0, \"&ohbar;\"], [0, \"&omid;\"], [0, \"&opar;\"], [1, \"&operp;\"], [1, \"&olcross;\"], [0, \"&odsold;\"], [1, \"&olcir;\"], [0, \"&ofcir;\"], [0, \"&olt;\"], [0, \"&ogt;\"], [0, \"&cirscir;\"], [0, \"&cirE;\"], [0, \"&solb;\"], [0, \"&bsolb;\"], [3, \"&boxbox;\"], [3, \"&trisb;\"], [0, \"&rtriltri;\"], [0, { v: \"&LeftTriangleBar;\", n: 824, o: \"&NotLeftTriangleBar;\" }], [0, { v: \"&RightTriangleBar;\", n: 824, o: \"&NotRightTriangleBar;\" }], [11, \"&iinfin;\"], [0, \"&infintie;\"], [0, \"&nvinfin;\"], [4, \"&eparsl;\"], [0, \"&smeparsl;\"], [0, \"&eqvparsl;\"], [5, \"&blacklozenge;\"], [8, \"&RuleDelayed;\"], [1, \"&dsol;\"], [9, \"&bigodot;\"], [0, \"&bigoplus;\"], [0, \"&bigotimes;\"], [1, \"&biguplus;\"], [1, \"&bigsqcup;\"], [5, \"&iiiint;\"], [0, \"&fpartint;\"], [2, \"&cirfnint;\"], [0, \"&awint;\"], [0, \"&rppolint;\"], [0, \"&scpolint;\"], [0, \"&npolint;\"], [0, \"&pointint;\"], [0, \"&quatint;\"], [0, \"&intlarhk;\"], [10, \"&pluscir;\"], [0, \"&plusacir;\"], [0, \"&simplus;\"], [0, \"&plusdu;\"], [0, \"&plussim;\"], [0, \"&plustwo;\"], [1, \"&mcomma;\"], [0, \"&minusdu;\"], [2, \"&loplus;\"], [0, \"&roplus;\"], [0, \"&Cross;\"], [0, \"&timesd;\"], [0, \"&timesbar;\"], [1, \"&smashp;\"], [0, \"&lotimes;\"], [0, \"&rotimes;\"], [0, \"&otimesas;\"], [0, \"&Otimes;\"], [0, \"&odiv;\"], [0, \"&triplus;\"], [0, \"&triminus;\"], [0, \"&tritime;\"], [0, \"&intprod;\"], [2, \"&amalg;\"], [0, \"&capdot;\"], [1, \"&ncup;\"], [0, \"&ncap;\"], [0, \"&capand;\"], [0, \"&cupor;\"], [0, \"&cupcap;\"], [0, \"&capcup;\"], [0, \"&cupbrcap;\"], [0, \"&capbrcup;\"], [0, \"&cupcup;\"], [0, \"&capcap;\"], [0, \"&ccups;\"], [0, \"&ccaps;\"], [2, \"&ccupssm;\"], [2, \"&And;\"], [0, \"&Or;\"], [0, \"&andand;\"], [0, \"&oror;\"], [0, \"&orslope;\"], [0, \"&andslope;\"], [1, \"&andv;\"], [0, \"&orv;\"], [0, \"&andd;\"], [0, \"&ord;\"], [1, \"&wedbar;\"], [6, \"&sdote;\"], [3, \"&simdot;\"], [2, { v: \"&congdot;\", n: 824, o: \"&ncongdot;\" }], [0, \"&easter;\"], [0, \"&apacir;\"], [0, { v: \"&apE;\", n: 824, o: \"&napE;\" }], [0, \"&eplus;\"], [0, \"&pluse;\"], [0, \"&Esim;\"], [0, \"&Colone;\"], [0, \"&Equal;\"], [1, \"&ddotseq;\"], [0, \"&equivDD;\"], [0, \"&ltcir;\"], [0, \"&gtcir;\"], [0, \"&ltquest;\"], [0, \"&gtquest;\"], [0, { v: \"&leqslant;\", n: 824, o: \"&nleqslant;\" }], [0, { v: \"&geqslant;\", n: 824, o: \"&ngeqslant;\" }], [0, \"&lesdot;\"], [0, \"&gesdot;\"], [0, \"&lesdoto;\"], [0, \"&gesdoto;\"], [0, \"&lesdotor;\"], [0, \"&gesdotol;\"], [0, \"&lap;\"], [0, \"&gap;\"], [0, \"&lne;\"], [0, \"&gne;\"], [0, \"&lnap;\"], [0, \"&gnap;\"], [0, \"&lEg;\"], [0, \"&gEl;\"], [0, \"&lsime;\"], [0, \"&gsime;\"], [0, \"&lsimg;\"], [0, \"&gsiml;\"], [0, \"&lgE;\"], [0, \"&glE;\"], [0, \"&lesges;\"], [0, \"&gesles;\"], [0, \"&els;\"], [0, \"&egs;\"], [0, \"&elsdot;\"], [0, \"&egsdot;\"], [0, \"&el;\"], [0, \"&eg;\"], [2, \"&siml;\"], [0, \"&simg;\"], [0, \"&simlE;\"], [0, \"&simgE;\"], [0, { v: \"&LessLess;\", n: 824, o: \"&NotNestedLessLess;\" }], [0, { v: \"&GreaterGreater;\", n: 824, o: \"&NotNestedGreaterGreater;\" }], [1, \"&glj;\"], [0, \"&gla;\"], [0, \"&ltcc;\"], [0, \"&gtcc;\"], [0, \"&lescc;\"], [0, \"&gescc;\"], [0, \"&smt;\"], [0, \"&lat;\"], [0, { v: \"&smte;\", n: 65024, o: \"&smtes;\" }], [0, { v: \"&late;\", n: 65024, o: \"&lates;\" }], [0, \"&bumpE;\"], [0, { v: \"&PrecedesEqual;\", n: 824, o: \"&NotPrecedesEqual;\" }], [0, { v: \"&sce;\", n: 824, o: \"&NotSucceedsEqual;\" }], [2, \"&prE;\"], [0, \"&scE;\"], [0, \"&precneqq;\"], [0, \"&scnE;\"], [0, \"&prap;\"], [0, \"&scap;\"], [0, \"&precnapprox;\"], [0, \"&scnap;\"], [0, \"&Pr;\"], [0, \"&Sc;\"], [0, \"&subdot;\"], [0, \"&supdot;\"], [0, \"&subplus;\"], [0, \"&supplus;\"], [0, \"&submult;\"], [0, \"&supmult;\"], [0, \"&subedot;\"], [0, \"&supedot;\"], [0, { v: \"&subE;\", n: 824, o: \"&nsubE;\" }], [0, { v: \"&supE;\", n: 824, o: \"&nsupE;\" }], [0, \"&subsim;\"], [0, \"&supsim;\"], [2, { v: \"&subnE;\", n: 65024, o: \"&varsubsetneqq;\" }], [0, { v: \"&supnE;\", n: 65024, o: \"&varsupsetneqq;\" }], [2, \"&csub;\"], [0, \"&csup;\"], [0, \"&csube;\"], [0, \"&csupe;\"], [0, \"&subsup;\"], [0, \"&supsub;\"], [0, \"&subsub;\"], [0, \"&supsup;\"], [0, \"&suphsub;\"], [0, \"&supdsub;\"], [0, \"&forkv;\"], [0, \"&topfork;\"], [0, \"&mlcp;\"], [8, \"&Dashv;\"], [1, \"&Vdashl;\"], [0, \"&Barv;\"], [0, \"&vBar;\"], [0, \"&vBarv;\"], [1, \"&Vbar;\"], [0, \"&Not;\"], [0, \"&bNot;\"], [0, \"&rnmid;\"], [0, \"&cirmid;\"], [0, \"&midcir;\"], [0, \"&topcir;\"], [0, \"&nhpar;\"], [0, \"&parsim;\"], [9, { v: \"&parsl;\", n: 8421, o: \"&nparsl;\" }], [44343, { n: new Map(/* #__PURE__ */ restoreDiff([[56476, \"&Ascr;\"], [1, \"&Cscr;\"], [0, \"&Dscr;\"], [2, \"&Gscr;\"], [2, \"&Jscr;\"], [0, \"&Kscr;\"], [2, \"&Nscr;\"], [0, \"&Oscr;\"], [0, \"&Pscr;\"], [0, \"&Qscr;\"], [1, \"&Sscr;\"], [0, \"&Tscr;\"], [0, \"&Uscr;\"], [0, \"&Vscr;\"], [0, \"&Wscr;\"], [0, \"&Xscr;\"], [0, \"&Yscr;\"], [0, \"&Zscr;\"], [0, \"&ascr;\"], [0, \"&bscr;\"], [0, \"&cscr;\"], [0, \"&dscr;\"], [1, \"&fscr;\"], [1, \"&hscr;\"], [0, \"&iscr;\"], [0, \"&jscr;\"], [0, \"&kscr;\"], [0, \"&lscr;\"], [0, \"&mscr;\"], [0, \"&nscr;\"], [1, \"&pscr;\"], [0, \"&qscr;\"], [0, \"&rscr;\"], [0, \"&sscr;\"], [0, \"&tscr;\"], [0, \"&uscr;\"], [0, \"&vscr;\"], [0, \"&wscr;\"], [0, \"&xscr;\"], [0, \"&yscr;\"], [0, \"&zscr;\"], [52, \"&Afr;\"], [0, \"&Bfr;\"], [1, \"&Dfr;\"], [0, \"&Efr;\"], [0, \"&Ffr;\"], [0, \"&Gfr;\"], [2, \"&Jfr;\"], [0, \"&Kfr;\"], [0, \"&Lfr;\"], [0, \"&Mfr;\"], [0, \"&Nfr;\"], [0, \"&Ofr;\"], [0, \"&Pfr;\"], [0, \"&Qfr;\"], [1, \"&Sfr;\"], [0, \"&Tfr;\"], [0, \"&Ufr;\"], [0, \"&Vfr;\"], [0, \"&Wfr;\"], [0, \"&Xfr;\"], [0, \"&Yfr;\"], [1, \"&afr;\"], [0, \"&bfr;\"], [0, \"&cfr;\"], [0, \"&dfr;\"], [0, \"&efr;\"], [0, \"&ffr;\"], [0, \"&gfr;\"], [0, \"&hfr;\"], [0, \"&ifr;\"], [0, \"&jfr;\"], [0, \"&kfr;\"], [0, \"&lfr;\"], [0, \"&mfr;\"], [0, \"&nfr;\"], [0, \"&ofr;\"], [0, \"&pfr;\"], [0, \"&qfr;\"], [0, \"&rfr;\"], [0, \"&sfr;\"], [0, \"&tfr;\"], [0, \"&ufr;\"], [0, \"&vfr;\"], [0, \"&wfr;\"], [0, \"&xfr;\"], [0, \"&yfr;\"], [0, \"&zfr;\"], [0, \"&Aopf;\"], [0, \"&Bopf;\"], [1, \"&Dopf;\"], [0, \"&Eopf;\"], [0, \"&Fopf;\"], [0, \"&Gopf;\"], [1, \"&Iopf;\"], [0, \"&Jopf;\"], [0, \"&Kopf;\"], [0, \"&Lopf;\"], [0, \"&Mopf;\"], [1, \"&Oopf;\"], [3, \"&Sopf;\"], [0, \"&Topf;\"], [0, \"&Uopf;\"], [0, \"&Vopf;\"], [0, \"&Wopf;\"], [0, \"&Xopf;\"], [0, \"&Yopf;\"], [1, \"&aopf;\"], [0, \"&bopf;\"], [0, \"&copf;\"], [0, \"&dopf;\"], [0, \"&eopf;\"], [0, \"&fopf;\"], [0, \"&gopf;\"], [0, \"&hopf;\"], [0, \"&iopf;\"], [0, \"&jopf;\"], [0, \"&kopf;\"], [0, \"&lopf;\"], [0, \"&mopf;\"], [0, \"&nopf;\"], [0, \"&oopf;\"], [0, \"&popf;\"], [0, \"&qopf;\"], [0, \"&ropf;\"], [0, \"&sopf;\"], [0, \"&topf;\"], [0, \"&uopf;\"], [0, \"&vopf;\"], [0, \"&wopf;\"], [0, \"&xopf;\"], [0, \"&yopf;\"], [0, \"&zopf;\"]])) }], [8906, \"&fflig;\"], [0, \"&filig;\"], [0, \"&fllig;\"], [0, \"&ffilig;\"], [0, \"&ffllig;\"]]));\n//# sourceMappingURL=encode-html.js.map\n\n/***/ }),\n\n/***/ 2730:\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.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 = void 0;\nvar decode_js_1 = __webpack_require__(9878);\nvar encode_js_1 = __webpack_require__(1818);\nvar escape_js_1 = __webpack_require__(5987);\n/** The level of entities to support. */\nvar EntityLevel;\n(function (EntityLevel) {\n    /** Support only XML entities. */\n    EntityLevel[EntityLevel[\"XML\"] = 0] = \"XML\";\n    /** Support HTML entities, which are a superset of XML entities. */\n    EntityLevel[EntityLevel[\"HTML\"] = 1] = \"HTML\";\n})(EntityLevel = exports.EntityLevel || (exports.EntityLevel = {}));\nvar EncodingMode;\n(function (EncodingMode) {\n    /**\n     * The output is UTF-8 encoded. Only characters that need escaping within\n     * XML will be escaped.\n     */\n    EncodingMode[EncodingMode[\"UTF8\"] = 0] = \"UTF8\";\n    /**\n     * The output consists only of ASCII characters. Characters that need\n     * escaping within HTML, and characters that aren't ASCII characters will\n     * be escaped.\n     */\n    EncodingMode[EncodingMode[\"ASCII\"] = 1] = \"ASCII\";\n    /**\n     * Encode all characters that have an equivalent entity, as well as all\n     * characters that are not ASCII characters.\n     */\n    EncodingMode[EncodingMode[\"Extensive\"] = 2] = \"Extensive\";\n    /**\n     * Encode all characters that have to be escaped in HTML attributes,\n     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n     */\n    EncodingMode[EncodingMode[\"Attribute\"] = 3] = \"Attribute\";\n    /**\n     * Encode all characters that have to be escaped in HTML text,\n     * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n     */\n    EncodingMode[EncodingMode[\"Text\"] = 4] = \"Text\";\n})(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));\n/**\n * Decodes a string with entities.\n *\n * @param data String to decode.\n * @param options Decoding options.\n */\nfunction decode(data, options) {\n    if (options === void 0) { options = EntityLevel.XML; }\n    var level = typeof options === \"number\" ? options : options.level;\n    if (level === EntityLevel.HTML) {\n        var mode = typeof options === \"object\" ? options.mode : undefined;\n        return (0, decode_js_1.decodeHTML)(data, mode);\n    }\n    return (0, decode_js_1.decodeXML)(data);\n}\nexports.decode = decode;\n/**\n * Decodes a string with entities. Does not allow missing trailing semicolons for entities.\n *\n * @param data String to decode.\n * @param options Decoding options.\n * @deprecated Use `decode` with the `mode` set to `Strict`.\n */\nfunction decodeStrict(data, options) {\n    var _a;\n    if (options === void 0) { options = EntityLevel.XML; }\n    var opts = typeof options === \"number\" ? { level: options } : options;\n    (_a = opts.mode) !== null && _a !== void 0 ? _a : (opts.mode = decode_js_1.DecodingMode.Strict);\n    return decode(data, opts);\n}\nexports.decodeStrict = decodeStrict;\n/**\n * Encodes a string with entities.\n *\n * @param data String to encode.\n * @param options Encoding options.\n */\nfunction encode(data, options) {\n    if (options === void 0) { options = EntityLevel.XML; }\n    var opts = typeof options === \"number\" ? { level: options } : options;\n    // Mode `UTF8` just escapes XML entities\n    if (opts.mode === EncodingMode.UTF8)\n        return (0, escape_js_1.escapeUTF8)(data);\n    if (opts.mode === EncodingMode.Attribute)\n        return (0, escape_js_1.escapeAttribute)(data);\n    if (opts.mode === EncodingMode.Text)\n        return (0, escape_js_1.escapeText)(data);\n    if (opts.level === EntityLevel.HTML) {\n        if (opts.mode === EncodingMode.ASCII) {\n            return (0, encode_js_1.encodeNonAsciiHTML)(data);\n        }\n        return (0, encode_js_1.encodeHTML)(data);\n    }\n    // ASCII and Extensive are equivalent\n    return (0, escape_js_1.encodeXML)(data);\n}\nexports.encode = encode;\nvar escape_js_2 = __webpack_require__(5987);\nObject.defineProperty(exports, \"encodeXML\", ({ enumerable: true, get: function () { return escape_js_2.encodeXML; } }));\nObject.defineProperty(exports, \"escape\", ({ enumerable: true, get: function () { return escape_js_2.escape; } }));\nObject.defineProperty(exports, \"escapeUTF8\", ({ enumerable: true, get: function () { return escape_js_2.escapeUTF8; } }));\nObject.defineProperty(exports, \"escapeAttribute\", ({ enumerable: true, get: function () { return escape_js_2.escapeAttribute; } }));\nObject.defineProperty(exports, \"escapeText\", ({ enumerable: true, get: function () { return escape_js_2.escapeText; } }));\nvar encode_js_2 = __webpack_require__(1818);\nObject.defineProperty(exports, \"encodeHTML\", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } }));\nObject.defineProperty(exports, \"encodeNonAsciiHTML\", ({ enumerable: true, get: function () { return encode_js_2.encodeNonAsciiHTML; } }));\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"encodeHTML4\", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } }));\nObject.defineProperty(exports, \"encodeHTML5\", ({ enumerable: true, get: function () { return encode_js_2.encodeHTML; } }));\nvar decode_js_2 = __webpack_require__(9878);\nObject.defineProperty(exports, \"EntityDecoder\", ({ enumerable: true, get: function () { return decode_js_2.EntityDecoder; } }));\nObject.defineProperty(exports, \"DecodingMode\", ({ enumerable: true, get: function () { return decode_js_2.DecodingMode; } }));\nObject.defineProperty(exports, \"decodeXML\", ({ enumerable: true, get: function () { return decode_js_2.decodeXML; } }));\nObject.defineProperty(exports, \"decodeHTML\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTML; } }));\nObject.defineProperty(exports, \"decodeHTMLStrict\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } }));\nObject.defineProperty(exports, \"decodeHTMLAttribute\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTMLAttribute; } }));\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"decodeHTML4\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTML; } }));\nObject.defineProperty(exports, \"decodeHTML5\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTML; } }));\nObject.defineProperty(exports, \"decodeHTML4Strict\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } }));\nObject.defineProperty(exports, \"decodeHTML5Strict\", ({ enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } }));\nObject.defineProperty(exports, \"decodeXMLStrict\", ({ enumerable: true, get: function () { return decode_js_2.decodeXML; } }));\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 7007:\n/***/ ((module) => {\n\n\"use strict\";\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n\n\n/***/ }),\n\n/***/ 4692:\n/***/ (function(module, exports) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * jQuery JavaScript Library v3.7.1\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2023-08-28T13:37Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif (  true && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML <object> elements\n\t\t// (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n\t\t// We don't want to classify *any* DOM node as a function.\n\t\t// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n\t\t// Plus for old WebKit, typeof returns \"function\" for HTML collections\n\t\t// (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n\t\treturn typeof obj === \"function\" && typeof obj.nodeType !== \"number\" &&\n\t\t\ttypeof obj.item !== \"function\";\n\t};\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\nvar document = window.document;\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnonce: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, node, doc ) {\n\t\tdoc = doc || document;\n\n\t\tvar i, val,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\n\t\t\t\t// Support: Firefox 64+, Edge 18+\n\t\t\t\t// Some browsers don't support the \"nonce\" property on scripts.\n\t\t\t\t// On the other hand, just using `getAttribute` is not enough as\n\t\t\t\t// the `nonce` attribute is reset to an empty string whenever it\n\t\t\t\t// becomes browsing-context connected.\n\t\t\t\t// See https://github.com/whatwg/html/issues/2369\n\t\t\t\t// See https://html.spec.whatwg.org/#nonce-attributes\n\t\t\t\t// The `node.getAttribute` check was added for the sake of\n\t\t\t\t// `jQuery.globalEval` so that it can fake a nonce-containing node\n\t\t\t\t// via an object.\n\t\t\t\tval = node[ i ] || node.getAttribute && node.getAttribute( i );\n\t\t\t\tif ( val ) {\n\t\t\t\t\tscript.setAttribute( i, val );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n/* global Symbol */\n// Defining this global in .eslintrc.json would create a danger of using the global\n// unguarded in another place, it seems safer to define global only for this module\n\n\n\nvar version = \"3.7.1\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t}\n\t\tif ( nodeType === 1 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t}\n\t\tif ( nodeType === 9 ) {\n\t\t\treturn elem.documentElement.textContent;\n\t\t}\n\t\tif ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\n\nfunction nodeName( elem, name ) {\n\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n}\nvar pop = arr.pop;\n\n\nvar sort = arr.sort;\n\n\nvar splice = arr.splice;\n\n\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n\n\n\n// Note: an element does not contain itself\njQuery.contains = function( a, b ) {\n\tvar bup = b && b.parentNode;\n\n\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE doesn't have `contains` on SVG.\n\t\ta.contains ?\n\t\t\ta.contains( bup ) :\n\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t) );\n};\n\n\n\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\n\n\n\nvar preferredDoc = document,\n\tpushNative = push;\n\n( function() {\n\nvar i,\n\tExpr,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\tpush = pushNative,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\tmatches,\n\n\t// Instance-specific data\n\texpando = jQuery.expando,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|\" +\n\t\t\"loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" +\n\t\twhitespace + \"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\t\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\tATTR: new RegExp( \"^\" + attributes ),\n\t\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\t\tCHILD: new RegExp(\n\t\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\tbool: new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE/Edge.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Support: IE <=9 only\n// Accessing document.activeElement can throw unexpectedly\n// https://bugs.jquery.com/ticket/13393\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android <=4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = {\n\t\tapply: function( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t},\n\t\tcall: function( target ) {\n\t\t\tpushNative.apply( target, slice.call( arguments, 1 ) );\n\t\t}\n\t};\n}\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE 9 only\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tfind.contains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when\n\t\t\t\t\t// strict-comparing two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: iOS 7 only, IE 9 - 11+\n\t// Older browsers didn't support unprefixed `matches`.\n\tmatches = documentElement.matches ||\n\t\tdocumentElement.webkitMatchesSelector ||\n\t\tdocumentElement.msMatchesSelector;\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors\n\t// (see trac-13936).\n\t// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,\n\t// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.\n\tif ( documentElement.msMatchesSelector &&\n\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tpreferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n\n\t// Support: IE <10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocumentElement.appendChild( el ).id = jQuery.expando;\n\t\treturn !document.getElementsByName ||\n\t\t\t!document.getElementsByName( jQuery.expando ).length;\n\t} );\n\n\t// Support: IE 9 only\n\t// Check to see if it's possible to do matchesSelector\n\t// on a disconnected node.\n\tsupport.disconnectedMatch = assert( function( el ) {\n\t\treturn matches.call( el, \"*\" );\n\t} );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// IE/Edge don't support the :scope pseudo-class.\n\tsupport.scope = assert( function() {\n\t\treturn document.querySelectorAll( \":scope\" );\n\t} );\n\n\t// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only\n\t// Make sure the `:has()` argument is parsed unforgivingly.\n\t// We include `*` in the test to detect buggy implementations that are\n\t// _selectively_ forgiving (specifically when the list includes at least\n\t// one valid selector).\n\t// Note that we treat complete lack of support for `:has()` as if it were\n\t// spec-compliant support, which is fine because use of `:has()` in such\n\t// environments will fail in the qSA path and fall back to jQuery traversal\n\t// anyway.\n\tsupport.cssHas = assert( function() {\n\t\ttry {\n\t\t\tdocument.querySelector( \":has(*,:jqfake)\" );\n\t\t\treturn false;\n\t\t} catch ( e ) {\n\t\t\treturn true;\n\t\t}\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter.ID = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter.ID =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find.ID = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find.TAG = function( tag, context ) {\n\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t// DocumentFragment nodes don't have gEBTN\n\t\t} else {\n\t\t\treturn context.querySelectorAll( tag );\n\t\t}\n\t};\n\n\t// Class\n\tExpr.find.CLASS = function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\trbuggyQSA = [];\n\n\t// Build QSA regex\n\t// Regex strategy adopted from Diego Perini\n\tassert( function( el ) {\n\n\t\tvar input;\n\n\t\tdocumentElement.appendChild( el ).innerHTML =\n\t\t\t\"<a id='\" + expando + \"' href='' disabled='disabled'></a>\" +\n\t\t\t\"<select id='\" + expando + \"-\\r\\\\' disabled='disabled'>\" +\n\t\t\t\"<option selected=''></option></select>\";\n\n\t\t// Support: iOS <=7 - 8 only\n\t\t// Boolean attributes and \"value\" are not treated correctly in some XML documents\n\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t}\n\n\t\t// Support: iOS <=7 - 8 only\n\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\trbuggyQSA.push( \"~=\" );\n\t\t}\n\n\t\t// Support: iOS 8 only\n\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t}\n\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\trbuggyQSA.push( \":checked\" );\n\t\t}\n\n\t\t// Support: Windows 8 Native Apps\n\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t// Support: IE 9 - 11+\n\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+\n\t\t// In some of the document kinds, these selectors wouldn't work natively.\n\t\t// This is probably OK but for backwards compatibility we want to maintain\n\t\t// handling them through jQuery traversal in jQuery 3.x.\n\t\tdocumentElement.appendChild( el ).disabled = true;\n\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t}\n\n\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t// Adding a temporary attribute to the document before the selection works\n\t\t// around the issue.\n\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\tinput = document.createElement( \"input\" );\n\t\tinput.setAttribute( \"name\", \"\" );\n\t\tel.appendChild( input );\n\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t}\n\t} );\n\n\tif ( !support.cssHas ) {\n\n\t\t// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+\n\t\t// Our regular `try-catch` mechanism fails to detect natively-unsupported\n\t\t// pseudo-classes inside `:has()` (such as `:has(:contains(\"Foo\"))`)\n\t\t// in browsers that parse the `:has()` argument as a forgiving selector list.\n\t\t// https://drafts.csswg.org/selectors/#relational now requires the argument\n\t\t// to be parsed unforgivingly, but browsers have not yet fully adjusted.\n\t\trbuggyQSA.push( \":has\" );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = function( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a === document || a.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b === document || b.ownerDocument == preferredDoc &&\n\t\t\t\tfind.contains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t};\n\n\treturn document;\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\nfind.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn jQuery.contains( context, elem );\n};\n\n\nfind.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (see trac-13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\tif ( val !== undefined ) {\n\t\treturn val;\n\t}\n\n\treturn elem.getAttribute( name );\n};\n\nfind.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\t//\n\t// Support: Android <=4.0+\n\t// Testing for detecting duplicates is unpredictable so instead assume we can't\n\t// depend on duplicate detection in all browsers without a stable sort.\n\thasDuplicate = !support.sortStable;\n\tsortInput = !support.sortStable && slice.call( results, 0 );\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nExpr = jQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\tATTR: function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" )\n\t\t\t\t.replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\tCHILD: function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t\t);\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tfind.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\tPSEUDO: function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = find.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ expando ] || ( parent[ expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tfind.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf.call( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tfind.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === safeActiveElement() &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !Expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\" &&\n\n\t\t\t\t// Support: IE <10 only\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear\n\t\t\t\t// with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos.nth = Expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tfind.error( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: iOS <=7 - 9 only\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching\n\t\t\t// elements by id. (see trac-14142)\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find.ID(\n\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// One-time assignments\n\n// Support: Android <=4.0 - 4.1+\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Android <=4.0 - 4.1+\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\njQuery.find = find;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.unique = jQuery.uniqueSort;\n\n// These have always been private, but they used to be documented as part of\n// Sizzle so let's maintain them for now for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\nfind.tokenize = tokenize;\n\nfind.escape = jQuery.escapeSelector;\nfind.getText = jQuery.text;\nfind.isXML = jQuery.isXMLDoc;\nfind.selectors = jQuery.expr;\nfind.support = jQuery.support;\nfind.uniqueSort = jQuery.uniqueSort;\n\n\t/* eslint-enable */\n\n} )();\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// <object> elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\n\t\t\t\t\t\t\t\t// The deprecated alias of the above. While the name suggests\n\t\t\t\t\t\t\t\t// returning the stack, not an error instance, jQuery just passes\n\t\t\t\t\t\t\t\t// it directly to `console.warn` so both will work; an instance\n\t\t\t\t\t\t\t\t// just better cooperates with source maps.\n\t\t\t\t\t\t\t\t} else if ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message,\n\t\t\terror.stack, asyncError );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\n// Support: IE <=9 - 10 only\n// Older IE sometimes signals \"interactive\" too soon\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase; used by the css and data modules\n// Support: IE <=9 - 11, Edge 12 - 15\n// Microsoft forgot to hump their vendor prefix (trac-9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar documentElement = document.documentElement;\n\n\n\n\tvar isAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t\t},\n\t\tcomposed = { composed: true };\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n\t// Check attachment across shadow DOM boundaries when possible (gh-3504)\n\t// Support: iOS 10.0-10.2 only\n\t// Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n\t// leading to errors. We need to check for `getRootNode`.\n\tif ( documentElement.getRootNode ) {\n\t\tisAttached = function( elem ) {\n\t\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t\t};\n\t}\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tisAttached( elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (trac-11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (trac-14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// Support: IE <=9 only\n\t// IE <=9 replaces <option> tags with their contents when inserted outside of\n\t// the select element.\n\tdiv.innerHTML = \"<option></option>\";\n\tsupport.option = !!div.lastChild;\n} )();\n\n\n// We have to close these tags to support XHTML (trac-13200)\nvar wrapMap = {\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n// Support: IE <=9 only\nif ( !support.option ) {\n\twrapMap.optgroup = wrapMap.option = [ 1, \"<select multiple='multiple'>\", \"</select>\" ];\n}\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object), so this array\n\t\t\t\t\t// will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling surrogate\n\t\t\t\t// (focus or blur), assume that the surrogate already propagated from triggering\n\t\t\t\t// the native event and prevent that from happening again here.\n\t\t\t\t// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n\t\t\t\t// bubbling surrogate propagates *after* the non-bubbling base), but that seems\n\t\t\t\t// less bad than duplication.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order\n\t\t\t// Fire an inner synthetic event with the original arguments\n\t\t\t} else if ( saved ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, jQuery.event.trigger(\n\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\tthis\n\t\t\t\t) );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (trac-504, trac-13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\tfunction focusMappedHandler( nativeEvent ) {\n\t\tif ( document.documentMode ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// Attach a single focusin/focusout handler on the document while someone wants\n\t\t\t// focus/blur. This is because the former are synchronous in IE while the latter\n\t\t\t// are async. In other browsers, all those handlers are invoked synchronously.\n\n\t\t\t// `handle` from private data would already wrap the event, but we need\n\t\t\t// to change the `type` here.\n\t\t\tvar handle = dataPriv.get( this, \"handle\" ),\n\t\t\t\tevent = jQuery.event.fix( nativeEvent );\n\t\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\t\tevent.isSimulated = true;\n\n\t\t\t// First, handle focusin/focusout\n\t\t\thandle( nativeEvent );\n\n\t\t\t// ...then, handle focus/blur\n\t\t\t//\n\t\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t\t// invoking the handler at the lower level.\n\t\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t\t// by this point.\n\t\t\t\thandle( event );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// For non-IE browsers, attach a single capturing handler on the document\n\t\t\t// while someone wants focusin/focusout.\n\t\t\tjQuery.event.simulate( delegateType, nativeEvent.target,\n\t\t\t\tjQuery.event.fix( nativeEvent ) );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\tvar attaches;\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( document.documentMode ) {\n\n\t\t\t\t// Support: IE 9 - 11+\n\t\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\t\tattaches = dataPriv.get( this, delegateType );\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t}\n\t\t\t\tdataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tvar attaches;\n\n\t\t\tif ( document.documentMode ) {\n\t\t\t\tattaches = dataPriv.get( this, delegateType ) - 1;\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t\tdataPriv.remove( this, delegateType );\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.set( this, delegateType, attaches );\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n\n\t// Support: Firefox <=44\n\t// Firefox doesn't have focus(in | out) events\n\t// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n\t//\n\t// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n\t// focus(in | out) events fire after focus & blur events,\n\t// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n\t// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\t//\n\t// Support: IE 9 - 11+\n\t// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,\n\t// attach a single handler for both events in IE.\n\tjQuery.event.special[ delegateType ] = {\n\t\tsetup: function() {\n\n\t\t\t// Handle: regular nodes (via `this.ownerDocument`), window\n\t\t\t// (via `this.document`) & document (via `this`).\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType );\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// We use the same native handler for focusin & focus (and focusout & blur)\n\t\t\t// so we need to coordinate setup & teardown parts between those events.\n\t\t\t// Use `delegateType` as the key as `type` is already used by `leverageNative`.\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.addEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t}\n\t\t\tdataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );\n\t\t},\n\t\tteardown: function() {\n\t\t\tvar doc = this.ownerDocument || this.document || this,\n\t\t\t\tdataHolder = document.documentMode ? this : doc,\n\t\t\t\tattaches = dataPriv.get( dataHolder, delegateType ) - 1;\n\n\t\t\tif ( !attaches ) {\n\t\t\t\tif ( document.documentMode ) {\n\t\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t\t} else {\n\t\t\t\t\tdoc.removeEventListener( type, focusMappedHandler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( dataHolder, delegateType );\n\t\t\t} else {\n\t\t\t\tdataPriv.set( dataHolder, delegateType, attaches );\n\t\t\t}\n\t\t}\n\t};\n} );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\n\trcleanScript = /^\\s*<!\\[CDATA\\[|\\]\\]>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.get( src );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdataPriv.remove( dest, \"handle events\" );\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Re-enable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce || node.getAttribute( \"nonce\" )\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Unwrap a CDATA section containing script contents. This shouldn't be\n\t\t\t\t\t\t\t// needed as in XML documents they're already not visible when\n\t\t\t\t\t\t\t// inspecting element contents and in HTML documents they have no\n\t\t\t\t\t\t\t// meaning but we're preserving that logic for backwards compatibility.\n\t\t\t\t\t\t\t// This will be removed completely in 4.0. See gh-4904.\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && isAttached( node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html;\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = isAttached( elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew jQuery#find here for performance reasons:\n\t\t\t// https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\t// Support: Chrome <=64\n\t\t// Don't get tricked when zoom affects offsetWidth (gh-4029)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableTrDimensionsVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (trac-8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t},\n\n\t\t// Support: IE 9 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Behavior in IE 9 is more subtle than in newer versions & it passes\n\t\t// some versions of this test; make sure not to make it pass there!\n\t\t//\n\t\t// Support: Firefox 70+\n\t\t// Only Firefox includes border widths\n\t\t// in computed dimensions. (gh-4529)\n\t\treliableTrDimensions: function() {\n\t\t\tvar table, tr, trChild, trStyle;\n\t\t\tif ( reliableTrDimensionsVal == null ) {\n\t\t\t\ttable = document.createElement( \"table\" );\n\t\t\t\ttr = document.createElement( \"tr\" );\n\t\t\t\ttrChild = document.createElement( \"div\" );\n\n\t\t\t\ttable.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n\t\t\t\ttr.style.cssText = \"box-sizing:content-box;border:1px solid\";\n\n\t\t\t\t// Support: Chrome 86+\n\t\t\t\t// Height set through cssText does not get applied.\n\t\t\t\t// Computed height then comes back as 0.\n\t\t\t\ttr.style.height = \"1px\";\n\t\t\t\ttrChild.style.height = \"9px\";\n\n\t\t\t\t// Support: Android 8 Chrome 86+\n\t\t\t\t// In our bodyBackground.html iframe,\n\t\t\t\t// display for all div elements is set to \"inline\",\n\t\t\t\t// which causes a problem only in Android 8 Chrome 86.\n\t\t\t\t// Ensuring the div is `display: block`\n\t\t\t\t// gets around this issue.\n\t\t\t\ttrChild.style.display = \"block\";\n\n\t\t\t\tdocumentElement\n\t\t\t\t\t.appendChild( table )\n\t\t\t\t\t.appendChild( tr )\n\t\t\t\t\t.appendChild( trChild );\n\n\t\t\t\ttrStyle = window.getComputedStyle( tr );\n\t\t\t\treliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderTopWidth, 10 ) +\n\t\t\t\t\tparseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;\n\n\t\t\t\tdocumentElement.removeChild( table );\n\t\t\t}\n\t\t\treturn reliableTrDimensionsVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tisCustomProp = rcustomProp.test( name ),\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, trac-12537)\n\t//   .css('--customProperty) (gh-3144)\n\tif ( computed ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105+, Chrome <=105+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace. Chrome just collapses\n\t\t\t// both leading & trailing whitespace to a single space.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style,\n\tvendorProps = {};\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped jQuery.cssProps or vendor prefixed property\nfunction finalPropName( name ) {\n\tvar final = jQuery.cssProps[ name ] || vendorProps[ name ];\n\n\tif ( final ) {\n\t\treturn final;\n\t}\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorProps[ name ] = vendorPropName( name ) || name;\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = !support.boxSizingReliable() || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\t// Support: IE 9 - 11 only\n\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t// In those cases, the computed value can be trusted to be border-box.\n\tif ( ( !support.boxSizingReliable() && isBorderBox ||\n\n\t\t// Support: IE 10 - 11+, Edge 15 - 18+\n\t\t// IE/Edge misreport `getComputedStyle` of table rows with width/height\n\t\t// set in CSS while `offset*` properties report correct values.\n\t\t// Interestingly, in some cases IE 9 doesn't suffer from this issue.\n\t\t!support.reliableTrDimensions() && nodeName( elem, \"tr\" ) ||\n\n\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\tval === \"auto\" ||\n\n\t\t// Support: Android <=4.1 - 4.3 only\n\t\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\tanimationIterationCount: true,\n\t\taspectRatio: true,\n\t\tborderImageSlice: true,\n\t\tcolumnCount: true,\n\t\tflexGrow: true,\n\t\tflexShrink: true,\n\t\tfontWeight: true,\n\t\tgridArea: true,\n\t\tgridColumn: true,\n\t\tgridColumnEnd: true,\n\t\tgridColumnStart: true,\n\t\tgridRow: true,\n\t\tgridRowEnd: true,\n\t\tgridRowStart: true,\n\t\tlineHeight: true,\n\t\topacity: true,\n\t\torder: true,\n\t\torphans: true,\n\t\tscale: true,\n\t\twidows: true,\n\t\tzIndex: true,\n\t\tzoom: true,\n\n\t\t// SVG-related\n\t\tfillOpacity: true,\n\t\tfloodOpacity: true,\n\t\tstopOpacity: true,\n\t\tstrokeMiterlimit: true,\n\t\tstrokeOpacity: true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\t// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n\t\t\t// \"px\" to a few hardcoded values.\n\t\t\tif ( type === \"number\" && !isCustomProp ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// Only read styles.position if the test has a chance to fail\n\t\t\t\t// to avoid forcing a reflow.\n\t\t\t\tscrollboxSizeBuggy = !support.scrollboxSize() &&\n\t\t\t\t\tstyles.position === \"absolute\",\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tboxSizingNeeded = scrollboxSizeBuggy || extra,\n\t\t\t\tisBorderBox = boxSizingNeeded &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && scrollboxSizeBuggy ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( _i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\n// eslint rule \"no-unused-expressions\" is disabled for this code\n// since it considers such accessions noop\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self,\n\t\t\ttype = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\treturn this.each( function() {\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (trac-2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce.guid++ ) +\n\t\t\t\t\tuncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// trac-1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" )\n\t\t\t\t\t.attr( s.scriptAttrs || {} )\n\t\t\t\t\t.prop( { charset: s.scriptCharset, src: s.url } )\n\t\t\t\t\t.on( \"load error\", callback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce.guid++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Support: Safari 8 only\n// In Safari 8 documents created via document.implementation.createHTMLDocument\n// collapse sibling forms: the second one becomes a child of the first one.\n// Because of that, this security measure has to be disabled in Safari 8.\n// https://bugs.webkit.org/show_bug.cgi?id=137337\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( _i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( {\n\t\tpadding: \"inner\" + name,\n\t\tcontent: type,\n\t\t\"\": \"outer\" + name\n\t}, function( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( _i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\n\thover: function( fnOver, fnOut ) {\n\t\treturn this\n\t\t\t.on( \"mouseenter\", fnOver )\n\t\t\t.on( \"mouseleave\", fnOut || fnOver );\n\t}\n} );\n\njQuery.each(\n\t( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( _i, name ) {\n\n\t\t// Handle event binding\n\t\tjQuery.fn[ name ] = function( data, fn ) {\n\t\t\treturn arguments.length > 0 ?\n\t\t\t\tthis.on( name, null, data, fn ) :\n\t\t\t\tthis.trigger( name );\n\t\t};\n\t}\n);\n\n\n\n\n// Support: Android <=4.0 only\n// Make sure we trim BOM and NBSP\n// Require that the \"whitespace run\" starts from a non-whitespace\n// to avoid O(N^2) behavior when the engine would try matching \"\\s+$\" at each space position.\nvar rtrim = /^[\\s\\uFEFF\\xA0]+|([^\\s\\uFEFF\\xA0])[\\s\\uFEFF\\xA0]+$/g;\n\n// Bind a function to a context, optionally partially applying any\n// arguments.\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n// However, it is not slated for removal any time soon\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\njQuery.trim = function( text ) {\n\treturn text == null ?\n\t\t\"\" :\n\t\t( text + \"\" ).replace( rtrim, \"$1\" );\n};\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( true ) {\n\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {\n\t\treturn jQuery;\n\t}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (trac-13566)\nif ( typeof noGlobal === \"undefined\" ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n\n\n/***/ }),\n\n/***/ 2814:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\nvar uc_micro = __webpack_require__(3492);\n\nfunction reFactory (opts) {\n  const re = {};\n  opts = opts || {};\n\n  re.src_Any = uc_micro.Any.source;\n  re.src_Cc = uc_micro.Cc.source;\n  re.src_Z = uc_micro.Z.source;\n  re.src_P = uc_micro.P.source;\n\n  // \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\n  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join('|');\n\n  // \\p{\\Z\\Cc} (white spaces + control)\n  re.src_ZCc = [re.src_Z, re.src_Cc].join('|');\n\n  // Experimental. List of chars, completely prohibited in links\n  // because can separate it from other part of text\n  const text_separators = '[><\\uff5c]';\n\n  // All possible word characters (everything without punctuation, spaces & controls)\n  // Defined via punctuation & spaces to save space\n  // Should be something like \\p{\\L\\N\\S\\M} (\\w but without `_`)\n  re.src_pseudo_letter = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';\n  // The same as abothe but without [0-9]\n  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';\n\n  re.src_ip4 =\n\n    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';\n\n  // Prohibit any of \"@/[]()\" in user/pass to avoid wrong domain fetch.\n  re.src_auth = '(?:(?:(?!' + re.src_ZCc + '|[@/\\\\[\\\\]()]).)+@)?';\n\n  re.src_port =\n\n    '(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?';\n\n  re.src_host_terminator =\n\n    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')' +\n    '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\\\d|\\\\.-|\\\\.(?!$|' + re.src_ZPCc + '))';\n\n  re.src_path =\n\n    '(?:' +\n      '[/?#]' +\n        '(?:' +\n          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\\\]{}.,\"\\'?!\\\\-;]).|' +\n          '\\\\[(?:(?!' + re.src_ZCc + '|\\\\]).)*\\\\]|' +\n          '\\\\((?:(?!' + re.src_ZCc + '|[)]).)*\\\\)|' +\n          '\\\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\\\}|' +\n          '\\\\\"(?:(?!' + re.src_ZCc + '|[\"]).)+\\\\\"|' +\n          \"\\\\'(?:(?!\" + re.src_ZCc + \"|[']).)+\\\\'|\" +\n\n          // allow `I'm_king` if no pair found\n          \"\\\\'(?=\" + re.src_pseudo_letter + '|[-])|' +\n\n          // google has many dots in \"google search\" links (#66, #81).\n          // github has ... in commit range links,\n          // Restrict to\n          // - english\n          // - percent-encoded\n          // - parts of file path\n          // - params separator\n          // until more examples found.\n          '\\\\.{2,}[a-zA-Z0-9%/&]|' +\n\n          '\\\\.(?!' + re.src_ZCc + '|[.]|$)|' +\n          (opts['---']\n            ? '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n            : '\\\\-+|'\n          ) +\n          // allow `,,,` in paths\n          ',(?!' + re.src_ZCc + '|$)|' +\n\n          // allow `;` if not followed by space-like char\n          ';(?!' + re.src_ZCc + '|$)|' +\n\n          // allow `!!!` in paths, but not at the end\n          '\\\\!+(?!' + re.src_ZCc + '|[!]|$)|' +\n\n          '\\\\?(?!' + re.src_ZCc + '|[?]|$)' +\n        ')+' +\n      '|\\\\/' +\n    ')?';\n\n  // Allow anything in markdown spec, forbid quote (\") at the first position\n  // because emails enclosed in quotes are far more common\n  re.src_email_name =\n\n    '[\\\\-;:&=\\\\+\\\\$,\\\\.a-zA-Z0-9_][\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]*';\n\n  re.src_xn =\n\n    'xn--[a-z0-9\\\\-]{1,59}';\n\n  // More to read about domain names\n  // http://serverfault.com/questions/638260/\n\n  re.src_domain_root =\n\n    // Allow letters & digits (http://test1)\n    '(?:' +\n      re.src_xn +\n      '|' +\n      re.src_pseudo_letter + '{1,63}' +\n    ')';\n\n  re.src_domain =\n\n    '(?:' +\n      re.src_xn +\n      '|' +\n      '(?:' + re.src_pseudo_letter + ')' +\n      '|' +\n      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +\n    ')';\n\n  re.src_host =\n\n    '(?:' +\n    // Don't need IP check, because digits are already allowed in normal domain names\n    //   src_ip4 +\n    // '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)*' + re.src_domain/* _root */ + ')' +\n    ')';\n\n  re.tpl_host_fuzzy =\n\n    '(?:' +\n      re.src_ip4 +\n    '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))' +\n    ')';\n\n  re.tpl_host_no_ip_fuzzy =\n\n    '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))';\n\n  re.src_host_strict =\n\n    re.src_host + re.src_host_terminator;\n\n  re.tpl_host_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_host_terminator;\n\n  re.src_host_port_strict =\n\n    re.src_host + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_no_ip_fuzzy_strict =\n\n    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;\n\n  //\n  // Main rules\n  //\n\n  // Rude test fuzzy links by host, for quick deny\n  re.tpl_host_fuzzy_test =\n\n    'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';\n\n  re.tpl_email_fuzzy =\n\n      '(^|' + text_separators + '|\"|\\\\(|' + re.src_ZCc + ')' +\n      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';\n\n  re.tpl_link_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';\n\n  re.tpl_link_no_ip_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';\n\n  return re\n}\n\n//\n// Helpers\n//\n\n// Merge objects\n//\nfunction assign (obj /* from1, from2, from3, ... */) {\n  const sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj\n}\n\nfunction _class (obj) { return Object.prototype.toString.call(obj) }\nfunction isString (obj) { return _class(obj) === '[object String]' }\nfunction isObject (obj) { return _class(obj) === '[object Object]' }\nfunction isRegExp (obj) { return _class(obj) === '[object RegExp]' }\nfunction isFunction (obj) { return _class(obj) === '[object Function]' }\n\nfunction escapeRE (str) { return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&') }\n\n//\n\nconst defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n};\n\nfunction isOptionsObj (obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    /* eslint-disable-next-line no-prototype-builtins */\n    return acc || defaultOptions.hasOwnProperty(k)\n  }, false)\n}\n\nconst defaultSchemas = {\n  'http:': {\n    validate: function (text, pos, self) {\n      const tail = text.slice(pos);\n\n      if (!self.re.http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.http = new RegExp(\n          '^\\\\/\\\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i'\n        );\n      }\n      if (self.re.http.test(tail)) {\n        return tail.match(self.re.http)[0].length\n      }\n      return 0\n    }\n  },\n  'https:': 'http:',\n  'ftp:': 'http:',\n  '//': {\n    validate: function (text, pos, self) {\n      const tail = text.slice(pos);\n\n      if (!self.re.no_http) {\n      // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.no_http = new RegExp(\n          '^' +\n          self.re.src_auth +\n          // Don't allow single-level domains, because of false positives like '//test'\n          // with code comments\n          '(?:localhost|(?:(?:' + self.re.src_domain + ')\\\\.)+' + self.re.src_domain_root + ')' +\n          self.re.src_port +\n          self.re.src_host_terminator +\n          self.re.src_path,\n\n          'i'\n        );\n      }\n\n      if (self.re.no_http.test(tail)) {\n        // should not be `://` & `///`, that protects from errors in protocol name\n        if (pos >= 3 && text[pos - 3] === ':') { return 0 }\n        if (pos >= 3 && text[pos - 3] === '/') { return 0 }\n        return tail.match(self.re.no_http)[0].length\n      }\n      return 0\n    }\n  },\n  'mailto:': {\n    validate: function (text, pos, self) {\n      const tail = text.slice(pos);\n\n      if (!self.re.mailto) {\n        self.re.mailto = new RegExp(\n          '^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i'\n        );\n      }\n      if (self.re.mailto.test(tail)) {\n        return tail.match(self.re.mailto)[0].length\n      }\n      return 0\n    }\n  }\n};\n\n// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\n/* eslint-disable-next-line max-len */\nconst tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';\n\n// DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead\nconst tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');\n\nfunction resetScanCache (self) {\n  self.__index__ = -1;\n  self.__text_cache__ = '';\n}\n\nfunction createValidator (re) {\n  return function (text, pos) {\n    const tail = text.slice(pos);\n\n    if (re.test(tail)) {\n      return tail.match(re)[0].length\n    }\n    return 0\n  }\n}\n\nfunction createNormalizer () {\n  return function (match, self) {\n    self.normalize(match);\n  }\n}\n\n// Schemas compiler. Build regexps.\n//\nfunction compile (self) {\n  // Load & clone RE patterns.\n  const re = self.re = reFactory(self.__opts__);\n\n  // Define dynamic patterns\n  const tlds = self.__tlds__.slice();\n\n  self.onCompile();\n\n  if (!self.__tlds_replaced__) {\n    tlds.push(tlds_2ch_src_re);\n  }\n  tlds.push(re.src_xn);\n\n  re.src_tlds = tlds.join('|');\n\n  function untpl (tpl) { return tpl.replace('%TLDS%', re.src_tlds) }\n\n  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), 'i');\n  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), 'i');\n  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');\n  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');\n\n  //\n  // Compile each schema\n  //\n\n  const aliases = [];\n\n  self.__compiled__ = {}; // Reset compiled data\n\n  function schemaError (name, val) {\n    throw new Error('(LinkifyIt) Invalid schema \"' + name + '\": ' + val)\n  }\n\n  Object.keys(self.__schemas__).forEach(function (name) {\n    const val = self.__schemas__[name];\n\n    // skip disabled methods\n    if (val === null) { return }\n\n    const compiled = { validate: null, link: null };\n\n    self.__compiled__[name] = compiled;\n\n    if (isObject(val)) {\n      if (isRegExp(val.validate)) {\n        compiled.validate = createValidator(val.validate);\n      } else if (isFunction(val.validate)) {\n        compiled.validate = val.validate;\n      } else {\n        schemaError(name, val);\n      }\n\n      if (isFunction(val.normalize)) {\n        compiled.normalize = val.normalize;\n      } else if (!val.normalize) {\n        compiled.normalize = createNormalizer();\n      } else {\n        schemaError(name, val);\n      }\n\n      return\n    }\n\n    if (isString(val)) {\n      aliases.push(name);\n      return\n    }\n\n    schemaError(name, val);\n  });\n\n  //\n  // Compile postponed aliases\n  //\n\n  aliases.forEach(function (alias) {\n    if (!self.__compiled__[self.__schemas__[alias]]) {\n      // Silently fail on missed schemas to avoid errons on disable.\n      // schemaError(alias, self.__schemas__[alias]);\n      return\n    }\n\n    self.__compiled__[alias].validate =\n      self.__compiled__[self.__schemas__[alias]].validate;\n    self.__compiled__[alias].normalize =\n      self.__compiled__[self.__schemas__[alias]].normalize;\n  });\n\n  //\n  // Fake record for guessed links\n  //\n  self.__compiled__[''] = { validate: null, normalize: createNormalizer() };\n\n  //\n  // Build schema condition\n  //\n  const slist = Object.keys(self.__compiled__)\n    .filter(function (name) {\n      // Filter disabled & fake schemas\n      return name.length > 0 && self.__compiled__[name]\n    })\n    .map(escapeRE)\n    .join('|');\n  // (?!_) cause 1.5x slowdown\n  self.re.schema_test = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');\n  self.re.schema_at_start = RegExp('^' + self.re.schema_search.source, 'i');\n\n  self.re.pretest = RegExp(\n    '(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@',\n    'i'\n  );\n\n  //\n  // Cleanup\n  //\n\n  resetScanCache(self);\n}\n\n/**\n * class Match\n *\n * Match result. Single element of array, returned by [[LinkifyIt#match]]\n **/\nfunction Match (self, shift) {\n  const start = self.__index__;\n  const end = self.__last_index__;\n  const text = self.__text_cache__.slice(start, end);\n\n  /**\n   * Match#schema -> String\n   *\n   * Prefix (protocol) for matched string.\n   **/\n  this.schema = self.__schema__.toLowerCase();\n  /**\n   * Match#index -> Number\n   *\n   * First position of matched string.\n   **/\n  this.index = start + shift;\n  /**\n   * Match#lastIndex -> Number\n   *\n   * Next position after matched string.\n   **/\n  this.lastIndex = end + shift;\n  /**\n   * Match#raw -> String\n   *\n   * Matched string.\n   **/\n  this.raw = text;\n  /**\n   * Match#text -> String\n   *\n   * Notmalized text of matched string.\n   **/\n  this.text = text;\n  /**\n   * Match#url -> String\n   *\n   * Normalized url of matched string.\n   **/\n  this.url = text;\n}\n\nfunction createMatch (self, shift) {\n  const match = new Match(self, shift);\n\n  self.__compiled__[match.schema].normalize(match, self);\n\n  return match\n}\n\n/**\n * class LinkifyIt\n **/\n\n/**\n * new LinkifyIt(schemas, options)\n * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Creates new linkifier instance with optional additional schemas.\n * Can be called without `new` keyword for convenience.\n *\n * By default understands:\n *\n * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n * - \"fuzzy\" links and emails (example.com, foo@bar.com).\n *\n * `schemas` is an object, where each key/value describes protocol/rule:\n *\n * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`\n *   for example). `linkify-it` makes shure that prefix is not preceeded with\n *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.\n * - __value__ - rule to check tail after link prefix\n *   - _String_ - just alias to existing rule\n *   - _Object_\n *     - _validate_ - validator function (should return matched length on success),\n *       or `RegExp`.\n *     - _normalize_ - optional function to normalize text & url of matched result\n *       (for example, for @twitter mentions).\n *\n * `options`:\n *\n * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.\n * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts\n *   like version numbers. Default `false`.\n * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.\n *\n **/\nfunction LinkifyIt (schemas, options) {\n  if (!(this instanceof LinkifyIt)) {\n    return new LinkifyIt(schemas, options)\n  }\n\n  if (!options) {\n    if (isOptionsObj(schemas)) {\n      options = schemas;\n      schemas = {};\n    }\n  }\n\n  this.__opts__ = assign({}, defaultOptions, options);\n\n  // Cache last tested result. Used to skip repeating steps on next `match` call.\n  this.__index__ = -1;\n  this.__last_index__ = -1; // Next scan position\n  this.__schema__ = '';\n  this.__text_cache__ = '';\n\n  this.__schemas__ = assign({}, defaultSchemas, schemas);\n  this.__compiled__ = {};\n\n  this.__tlds__ = tlds_default;\n  this.__tlds_replaced__ = false;\n\n  this.re = {};\n\n  compile(this);\n}\n\n/** chainable\n * LinkifyIt#add(schema, definition)\n * - schema (String): rule name (fixed pattern prefix)\n * - definition (String|RegExp|Object): schema definition\n *\n * Add new rule definition. See constructor description for details.\n **/\nLinkifyIt.prototype.add = function add (schema, definition) {\n  this.__schemas__[schema] = definition;\n  compile(this);\n  return this\n};\n\n/** chainable\n * LinkifyIt#set(options)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Set recognition options for links without schema.\n **/\nLinkifyIt.prototype.set = function set (options) {\n  this.__opts__ = assign(this.__opts__, options);\n  return this\n};\n\n/**\n * LinkifyIt#test(text) -> Boolean\n *\n * Searches linkifiable pattern and returns `true` on success or `false` on fail.\n **/\nLinkifyIt.prototype.test = function test (text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__ = -1;\n\n  if (!text.length) { return false }\n\n  let m, ml, me, len, shift, next, re, tld_pos, at_pos;\n\n  // try to scan for link with schema - that's the most simple rule\n  if (this.re.schema_test.test(text)) {\n    re = this.re.schema_search;\n    re.lastIndex = 0;\n    while ((m = re.exec(text)) !== null) {\n      len = this.testSchemaAt(text, m[2], re.lastIndex);\n      if (len) {\n        this.__schema__ = m[2];\n        this.__index__ = m.index + m[1].length;\n        this.__last_index__ = m.index + m[0].length + len;\n        break\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {\n    // guess schemaless links\n    tld_pos = text.search(this.re.host_fuzzy_test);\n    if (tld_pos >= 0) {\n      // if tld is located after found link - no need to check fuzzy pattern\n      if (this.__index__ < 0 || tld_pos < this.__index__) {\n        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {\n          shift = ml.index + ml[1].length;\n\n          if (this.__index__ < 0 || shift < this.__index__) {\n            this.__schema__ = '';\n            this.__index__ = shift;\n            this.__last_index__ = ml.index + ml[0].length;\n          }\n        }\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {\n    // guess schemaless emails\n    at_pos = text.indexOf('@');\n    if (at_pos >= 0) {\n      // We can't skip this check, because this cases are possible:\n      // 192.168.1.1@gmail.com, my.in@example.com\n      if ((me = text.match(this.re.email_fuzzy)) !== null) {\n        shift = me.index + me[1].length;\n        next = me.index + me[0].length;\n\n        if (this.__index__ < 0 || shift < this.__index__ ||\n            (shift === this.__index__ && next > this.__last_index__)) {\n          this.__schema__ = 'mailto:';\n          this.__index__ = shift;\n          this.__last_index__ = next;\n        }\n      }\n    }\n  }\n\n  return this.__index__ >= 0\n};\n\n/**\n * LinkifyIt#pretest(text) -> Boolean\n *\n * Very quick check, that can give false positives. Returns true if link MAY BE\n * can exists. Can be used for speed optimization, when you need to check that\n * link NOT exists.\n **/\nLinkifyIt.prototype.pretest = function pretest (text) {\n  return this.re.pretest.test(text)\n};\n\n/**\n * LinkifyIt#testSchemaAt(text, name, position) -> Number\n * - text (String): text to scan\n * - name (String): rule (schema) name\n * - position (Number): text offset to check from\n *\n * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly\n * at given position. Returns length of found pattern (0 on fail).\n **/\nLinkifyIt.prototype.testSchemaAt = function testSchemaAt (text, schema, pos) {\n  // If not supported schema check requested - terminate\n  if (!this.__compiled__[schema.toLowerCase()]) {\n    return 0\n  }\n  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this)\n};\n\n/**\n * LinkifyIt#match(text) -> Array|null\n *\n * Returns array of found link descriptions or `null` on fail. We strongly\n * recommend to use [[LinkifyIt#test]] first, for best speed.\n *\n * ##### Result match description\n *\n * - __schema__ - link schema, can be empty for fuzzy links, or `//` for\n *   protocol-neutral  links.\n * - __index__ - offset of matched text\n * - __lastIndex__ - index of next char after mathch end\n * - __raw__ - matched text\n * - __text__ - normalized text\n * - __url__ - link, generated from matched text\n **/\nLinkifyIt.prototype.match = function match (text) {\n  const result = [];\n  let shift = 0;\n\n  // Try to take previous element from cache, if .test() called before\n  if (this.__index__ >= 0 && this.__text_cache__ === text) {\n    result.push(createMatch(this, shift));\n    shift = this.__last_index__;\n  }\n\n  // Cut head if cache was used\n  let tail = shift ? text.slice(shift) : text;\n\n  // Scan string until end reached\n  while (this.test(tail)) {\n    result.push(createMatch(this, shift));\n\n    tail = tail.slice(this.__last_index__);\n    shift += this.__last_index__;\n  }\n\n  if (result.length) {\n    return result\n  }\n\n  return null\n};\n\n/**\n * LinkifyIt#matchAtStart(text) -> Match|null\n *\n * Returns fully-formed (not fuzzy) link if it starts at the beginning\n * of the string, and null otherwise.\n **/\nLinkifyIt.prototype.matchAtStart = function matchAtStart (text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__ = -1;\n\n  if (!text.length) return null\n\n  const m = this.re.schema_at_start.exec(text);\n  if (!m) return null\n\n  const len = this.testSchemaAt(text, m[2], m[0].length);\n  if (!len) return null\n\n  this.__schema__ = m[2];\n  this.__index__ = m.index + m[1].length;\n  this.__last_index__ = m.index + m[0].length + len;\n\n  return createMatch(this, 0)\n};\n\n/** chainable\n * LinkifyIt#tlds(list [, keepOld]) -> this\n * - list (Array): list of tlds\n * - keepOld (Boolean): merge with current list if `true` (`false` by default)\n *\n * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)\n * to avoid false positives. By default this algorythm used:\n *\n * - hostname with any 2-letter root zones are ok.\n * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n *   are ok.\n * - encoded (`xn--...`) root zones are ok.\n *\n * If list is replaced, then exact match for 2-chars root zones will be checked.\n **/\nLinkifyIt.prototype.tlds = function tlds (list, keepOld) {\n  list = Array.isArray(list) ? list : [list];\n\n  if (!keepOld) {\n    this.__tlds__ = list.slice();\n    this.__tlds_replaced__ = true;\n    compile(this);\n    return this\n  }\n\n  this.__tlds__ = this.__tlds__.concat(list)\n    .sort()\n    .filter(function (el, idx, arr) {\n      return el !== arr[idx - 1]\n    })\n    .reverse();\n\n  compile(this);\n  return this\n};\n\n/**\n * LinkifyIt#normalize(match)\n *\n * Default normalizer (if schema does not define it's own).\n **/\nLinkifyIt.prototype.normalize = function normalize (match) {\n  // Do minimal possible changes by default. Need to collect feedback prior\n  // to move forward https://github.com/markdown-it/linkify-it/issues/1\n\n  if (!match.schema) { match.url = 'http://' + match.url; }\n\n  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {\n    match.url = 'mailto:' + match.url;\n  }\n};\n\n/**\n * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\nLinkifyIt.prototype.onCompile = function onCompile () {\n};\n\nmodule.exports = LinkifyIt;\n\n\n/***/ }),\n\n/***/ 383:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\n\n\nvar mdurl = __webpack_require__(5778);\nvar ucmicro = __webpack_require__(3492);\nvar entities = __webpack_require__(2730);\nvar LinkifyIt = __webpack_require__(2814);\nvar punycode = __webpack_require__(7444);\n\nfunction _interopNamespaceDefault(e) {\n  var n = Object.create(null);\n  if (e) {\n    Object.keys(e).forEach(function (k) {\n      if (k !== 'default') {\n        var d = Object.getOwnPropertyDescriptor(e, k);\n        Object.defineProperty(n, k, d.get ? d : {\n          enumerable: true,\n          get: function () { return e[k]; }\n        });\n      }\n    });\n  }\n  n.default = e;\n  return Object.freeze(n);\n}\n\nvar mdurl__namespace = /*#__PURE__*/_interopNamespaceDefault(mdurl);\nvar ucmicro__namespace = /*#__PURE__*/_interopNamespaceDefault(ucmicro);\n\n// Utilities\n//\n\nfunction _class(obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isString(obj) {\n  return _class(obj) === '[object String]';\n}\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction has(object, key) {\n  return _hasOwnProperty.call(object, key);\n}\n\n// Merge objects\n//\nfunction assign(obj /* from1, from2, from3, ... */) {\n  const sources = Array.prototype.slice.call(arguments, 1);\n  sources.forEach(function (source) {\n    if (!source) {\n      return;\n    }\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n  return obj;\n}\n\n// Remove element from array and put another array at those position.\n// Useful for some operations with tokens\nfunction arrayReplaceAt(src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));\n}\nfunction isValidEntityCode(c) {\n  /* eslint no-bitwise:0 */\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) {\n    return false;\n  }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) {\n    return false;\n  }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) {\n    return false;\n  }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) {\n    return false;\n  }\n  if (c === 0x0B) {\n    return false;\n  }\n  if (c >= 0x0E && c <= 0x1F) {\n    return false;\n  }\n  if (c >= 0x7F && c <= 0x9F) {\n    return false;\n  }\n  // out of range\n  if (c > 0x10FFFF) {\n    return false;\n  }\n  return true;\n}\nfunction fromCodePoint(c) {\n  /* eslint no-bitwise:0 */\n  if (c > 0xffff) {\n    c -= 0x10000;\n    const surrogate1 = 0xd800 + (c >> 10);\n    const surrogate2 = 0xdc00 + (c & 0x3ff);\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\nconst UNESCAPE_MD_RE = /\\\\([!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~])/g;\nconst ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;\nconst UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\nconst DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;\nfunction replaceEntityPattern(match, name) {\n  if (name.charCodeAt(0) === 0x23 /* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    const code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n    return match;\n  }\n  const decoded = entities.decodeHTML(match);\n  if (decoded !== match) {\n    return decoded;\n  }\n  return match;\n}\n\n/* function replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n} */\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) {\n    return str;\n  }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) {\n    return str;\n  }\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) {\n      return escaped;\n    }\n    return replaceEntityPattern(match, entity);\n  });\n}\nconst HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nconst HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nconst HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n}\nconst REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&');\n}\nfunction isSpace(code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true;\n  }\n  return false;\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace(code) {\n  if (code >= 0x2000 && code <= 0x200A) {\n    return true;\n  }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true;\n  }\n  return false;\n}\n\n/* eslint-disable max-len */\n\n// Currently without astral characters support.\nfunction isPunctChar(ch) {\n  return ucmicro__namespace.P.test(ch) || ucmicro__namespace.S.test(ch);\n}\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\nfunction isMdAsciiPunct(ch) {\n  switch (ch) {\n    case 0x21 /* ! */:\n    case 0x22 /* \" */:\n    case 0x23 /* # */:\n    case 0x24 /* $ */:\n    case 0x25 /* % */:\n    case 0x26 /* & */:\n    case 0x27 /* ' */:\n    case 0x28 /* ( */:\n    case 0x29 /* ) */:\n    case 0x2A /* * */:\n    case 0x2B /* + */:\n    case 0x2C /* , */:\n    case 0x2D /* - */:\n    case 0x2E /* . */:\n    case 0x2F /* / */:\n    case 0x3A /* : */:\n    case 0x3B /* ; */:\n    case 0x3C /* < */:\n    case 0x3D /* = */:\n    case 0x3E /* > */:\n    case 0x3F /* ? */:\n    case 0x40 /* @ */:\n    case 0x5B /* [ */:\n    case 0x5C /* \\ */:\n    case 0x5D /* ] */:\n    case 0x5E /* ^ */:\n    case 0x5F /* _ */:\n    case 0x60 /* ` */:\n    case 0x7B /* { */:\n    case 0x7C /* | */:\n    case 0x7D /* } */:\n    case 0x7E /* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference(str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ');\n\n  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß');\n  }\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase();\n}\n\n// Re-export libraries commonly used in both markdown-it and its plugins,\n// so plugins won't have to depend on them explicitly, which reduces their\n// bundled size (e.g. a browser build).\n//\nconst lib = {\n  mdurl: mdurl__namespace,\n  ucmicro: ucmicro__namespace\n};\n\nvar utils = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  arrayReplaceAt: arrayReplaceAt,\n  assign: assign,\n  escapeHtml: escapeHtml,\n  escapeRE: escapeRE,\n  fromCodePoint: fromCodePoint,\n  has: has,\n  isMdAsciiPunct: isMdAsciiPunct,\n  isPunctChar: isPunctChar,\n  isSpace: isSpace,\n  isString: isString,\n  isValidEntityCode: isValidEntityCode,\n  isWhiteSpace: isWhiteSpace,\n  lib: lib,\n  normalizeReference: normalizeReference,\n  unescapeAll: unescapeAll,\n  unescapeMd: unescapeMd\n});\n\n// Parse link label\n//\n// this function assumes that first character (\"[\") already matches;\n// returns the end of the label\n//\n\nfunction parseLinkLabel(state, start, disableNested) {\n  let level, found, marker, prevPos;\n  const max = state.posMax;\n  const oldPos = state.pos;\n  state.pos = start + 1;\n  level = 1;\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n    prevPos = state.pos;\n    state.md.inline.skipToken(state);\n    if (marker === 0x5B /* [ */) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++;\n      } else if (disableNested) {\n        state.pos = oldPos;\n        return -1;\n      }\n    }\n  }\n  let labelEnd = -1;\n  if (found) {\n    labelEnd = state.pos;\n  }\n\n  // restore old state\n  state.pos = oldPos;\n  return labelEnd;\n}\n\n// Parse link destination\n//\n\nfunction parseLinkDestination(str, start, max) {\n  let code;\n  let pos = start;\n  const result = {\n    ok: false,\n    pos: 0,\n    str: ''\n  };\n  if (str.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = str.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) {\n        return result;\n      }\n      if (code === 0x3C /* < */) {\n        return result;\n      }\n      if (code === 0x3E /* > */) {\n        result.pos = pos + 1;\n        result.str = unescapeAll(str.slice(start + 1, pos));\n        result.ok = true;\n        return result;\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n      pos++;\n    }\n\n    // no closing '>'\n    return result;\n  }\n\n  // this should be ... } else { ... branch\n\n  let level = 0;\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n    if (code === 0x20) {\n      break;\n    }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) {\n      break;\n    }\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      if (str.charCodeAt(pos + 1) === 0x20) {\n        break;\n      }\n      pos += 2;\n      continue;\n    }\n    if (code === 0x28 /* ( */) {\n      level++;\n      if (level > 32) {\n        return result;\n      }\n    }\n    if (code === 0x29 /* ) */) {\n      if (level === 0) {\n        break;\n      }\n      level--;\n    }\n    pos++;\n  }\n  if (start === pos) {\n    return result;\n  }\n  if (level !== 0) {\n    return result;\n  }\n  result.str = unescapeAll(str.slice(start, pos));\n  result.pos = pos;\n  result.ok = true;\n  return result;\n}\n\n// Parse link title\n//\n\n\n// Parse link title within `str` in [start, max] range,\n// or continue previous parsing if `prev_state` is defined (equal to result of last execution).\n//\nfunction parseLinkTitle(str, start, max, prev_state) {\n  let code;\n  let pos = start;\n  const state = {\n    // if `true`, this is a valid link title\n    ok: false,\n    // if `true`, this link can be continued on the next line\n    can_continue: false,\n    // if `ok`, it's the position of the first character after the closing marker\n    pos: 0,\n    // if `ok`, it's the unescaped title\n    str: '',\n    // expected closing marker character code\n    marker: 0\n  };\n  if (prev_state) {\n    // this is a continuation of a previous parseLinkTitle call on the next line,\n    // used in reference links only\n    state.str = prev_state.str;\n    state.marker = prev_state.marker;\n  } else {\n    if (pos >= max) {\n      return state;\n    }\n    let marker = str.charCodeAt(pos);\n    if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) {\n      return state;\n    }\n    start++;\n    pos++;\n\n    // if opening marker is \"(\", switch it to closing marker \")\"\n    if (marker === 0x28) {\n      marker = 0x29;\n    }\n    state.marker = marker;\n  }\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n    if (code === state.marker) {\n      state.pos = pos + 1;\n      state.str += unescapeAll(str.slice(start, pos));\n      state.ok = true;\n      return state;\n    } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {\n      return state;\n    } else if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos++;\n    }\n    pos++;\n  }\n\n  // no closing marker found, but this link title may continue on the next line (for references)\n  state.can_continue = true;\n  state.str += unescapeAll(str.slice(start, pos));\n  return state;\n}\n\n// Just a shortcut for bulk export\n\nvar helpers = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  parseLinkDestination: parseLinkDestination,\n  parseLinkLabel: parseLinkLabel,\n  parseLinkTitle: parseLinkTitle\n});\n\n/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n\nconst default_rules = {};\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx];\n  return '<code' + slf.renderAttrs(token) + '>' + escapeHtml(token.content) + '</code>';\n};\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx];\n  return '<pre' + slf.renderAttrs(token) + '><code>' + escapeHtml(tokens[idx].content) + '</code></pre>\\n';\n};\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx];\n  const info = token.info ? unescapeAll(token.info).trim() : '';\n  let langName = '';\n  let langAttrs = '';\n  if (info) {\n    const arr = info.split(/(\\s+)/g);\n    langName = arr[0];\n    langAttrs = arr.slice(2).join('');\n  }\n  let highlighted;\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .deepClone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    const i = token.attrIndex('class');\n    const tmpAttrs = token.attrs ? token.attrs.slice() : [];\n    if (i < 0) {\n      tmpAttrs.push(['class', options.langPrefix + langName]);\n    } else {\n      tmpAttrs[i] = tmpAttrs[i].slice();\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    const tmpToken = {\n      attrs: tmpAttrs\n    };\n    return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\\n`;\n  }\n  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\\n`;\n};\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] = slf.renderInlineAsText(token.children, options, env);\n  return slf.renderToken(tokens, idx, options);\n};\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? options.xhtmlOut ? '<br />\\n' : '<br>\\n' : '\\n';\n};\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n  /**\n   * Renderer#rules -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independent static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules);\n}\n\n/**\n * Renderer.renderAttrs(token) -> String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  let i, l, result;\n  if (!token.attrs) {\n    return '';\n  }\n  result = '';\n  for (i = 0, l = token.attrs.length; i < l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n  return result;\n};\n\n/**\n * Renderer.renderToken(tokens, idx, options) -> String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  const token = tokens[idx];\n  let result = '';\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag;\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  let needLf = false;\n  if (token.block) {\n    needLf = true;\n    if (token.nesting === 1) {\n      if (idx + 1 < tokens.length) {\n        const nextToken = tokens[idx + 1];\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n  result += needLf ? '>\\n' : '>';\n  return result;\n};\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  let result = '';\n  const rules = this.rules;\n  for (let i = 0, len = tokens.length; i < len; i++) {\n    const type = tokens[i].type;\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n  return result;\n};\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  let result = '';\n  for (let i = 0, len = tokens.length; i < len; i++) {\n    switch (tokens[i].type) {\n      case 'text':\n        result += tokens[i].content;\n        break;\n      case 'image':\n        result += this.renderInlineAsText(tokens[i].children, options, env);\n        break;\n      case 'html_inline':\n      case 'html_block':\n        result += tokens[i].content;\n        break;\n      case 'softbreak':\n      case 'hardbreak':\n        result += '\\n';\n        break;\n      // all other tokens are skipped\n    }\n  }\n  return result;\n};\n\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  let result = '';\n  const rules = this.rules;\n  for (let i = 0, len = tokens.length; i < len; i++) {\n    const type = tokens[i].type;\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n  return result;\n};\n\n/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n// Helper methods, should not be used directly\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (let i = 0; i < this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  const self = this;\n  const chains = [''];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) {\n      return;\n    }\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n  self.__cache__ = {};\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) {\n        return;\n      }\n      if (chain && rule.alt.indexOf(chain) < 0) {\n        return;\n      }\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  const index = this.__find__(name);\n  const opt = options || {};\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + name);\n  }\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  const index = this.__find__(beforeName);\n  const opt = options || {};\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + beforeName);\n  }\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  });\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  const index = this.__find__(afterName);\n  const opt = options || {};\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + afterName);\n  }\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  });\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  const opt = options || {};\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  });\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n  const result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    const idx = this.__find__(name);\n    if (idx < 0) {\n      if (ignoreInvalid) {\n        return;\n      }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n  this.__cache__ = null;\n  return result;\n};\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n  this.__rules__.forEach(function (rule) {\n    rule.enabled = false;\n  });\n  this.enable(list, ignoreInvalid);\n};\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n  const result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    const idx = this.__find__(name);\n    if (idx < 0) {\n      if (ignoreInvalid) {\n        return;\n      }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n  this.__cache__ = null;\n  return result;\n};\n\n/**\n * Ruler.getRules(chainName) -> Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\n// Token class\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type = type;\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag = tag;\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs = null;\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map = null;\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting = nesting;\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level = 0;\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content = '';\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup = '';\n\n  /**\n   * Token#info -> String\n   *\n   * Additional information:\n   *\n   * - Info string for \"fence\" tokens\n   * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n   * - The string value of the item marker for ordered-list \"list_item_open\" tokens\n   **/\n  this.info = '';\n\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta = null;\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block = false;\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden = false;\n}\n\n/**\n * Token.attrIndex(name) -> Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex(name) {\n  if (!this.attrs) {\n    return -1;\n  }\n  const attrs = this.attrs;\n  for (let i = 0, len = attrs.length; i < len; i++) {\n    if (attrs[i][0] === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\nToken.prototype.attrPush = function attrPush(attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData);\n  } else {\n    this.attrs = [attrData];\n  }\n};\n\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet(name, value) {\n  const idx = this.attrIndex(name);\n  const attrData = [name, value];\n  if (idx < 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet(name) {\n  const idx = this.attrIndex(name);\n  let value = null;\n  if (idx >= 0) {\n    value = this.attrs[idx][1];\n  }\n  return value;\n};\n\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  const idx = this.attrIndex(name);\n  if (idx < 0) {\n    this.attrPush([name, value]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\n// Core state object\n//\n\nfunction StateCore(src, md, env) {\n  this.src = src;\n  this.env = env;\n  this.tokens = [];\n  this.inlineMode = false;\n  this.md = md; // link to parser instance\n}\n\n// re-export Token class to use in core rules\nStateCore.prototype.Token = Token;\n\n// Normalize input string\n\n// https://spec.commonmark.org/0.29/#line-ending\nconst NEWLINES_RE = /\\r\\n?|\\n/g;\nconst NULL_RE = /\\0/g;\nfunction normalize(state) {\n  let str;\n\n  // Normalize newlines\n  str = state.src.replace(NEWLINES_RE, '\\n');\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD');\n  state.src = str;\n}\n\nfunction block(state) {\n  let token;\n  if (state.inlineMode) {\n    token = new state.Token('inline', '', 0);\n    token.content = state.src;\n    token.map = [0, 1];\n    token.children = [];\n    state.tokens.push(token);\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens);\n  }\n}\n\nfunction inline(state) {\n  const tokens = state.tokens;\n\n  // Parse inlines\n  for (let i = 0, l = tokens.length; i < l; i++) {\n    const tok = tokens[i];\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children);\n    }\n  }\n}\n\n// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n\nfunction isLinkOpen$1(str) {\n  return /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose$1(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\nfunction linkify$1(state) {\n  const blockTokens = state.tokens;\n  if (!state.md.options.linkify) {\n    return;\n  }\n  for (let j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline' || !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue;\n    }\n    let tokens = blockTokens[j].children;\n    let htmlLinkLevel = 0;\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (let i = tokens.length - 1; i >= 0; i--) {\n      const currentToken = tokens[i];\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--;\n        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {\n          i--;\n        }\n        continue;\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen$1(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n        if (isLinkClose$1(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n      if (htmlLinkLevel > 0) {\n        continue;\n      }\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n        const text = currentToken.content;\n        let links = state.md.linkify.match(text);\n\n        // Now split string to nodes\n        const nodes = [];\n        let level = currentToken.level;\n        let lastPos = 0;\n\n        // forbid escape sequence at the start of the string,\n        // this avoids http\\://example.com/ from being linkified as\n        // http:<a href=\"//example.com/\">//example.com/</a>\n        if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === 'text_special') {\n          links = links.slice(1);\n        }\n        for (let ln = 0; ln < links.length; ln++) {\n          const url = links[ln].url;\n          const fullUrl = state.md.normalizeLink(url);\n          if (!state.md.validateLink(fullUrl)) {\n            continue;\n          }\n          let urlText = links[ln].text;\n\n          // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '');\n          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');\n          } else {\n            urlText = state.md.normalizeLinkText(urlText);\n          }\n          const pos = links[ln].index;\n          if (pos > lastPos) {\n            const token = new state.Token('text', '', 0);\n            token.content = text.slice(lastPos, pos);\n            token.level = level;\n            nodes.push(token);\n          }\n          const token_o = new state.Token('link_open', 'a', 1);\n          token_o.attrs = [['href', fullUrl]];\n          token_o.level = level++;\n          token_o.markup = 'linkify';\n          token_o.info = 'auto';\n          nodes.push(token_o);\n          const token_t = new state.Token('text', '', 0);\n          token_t.content = urlText;\n          token_t.level = level;\n          nodes.push(token_t);\n          const token_c = new state.Token('link_close', 'a', -1);\n          token_c.level = --level;\n          token_c.markup = 'linkify';\n          token_c.info = 'auto';\n          nodes.push(token_c);\n          lastPos = links[ln].lastIndex;\n        }\n        if (lastPos < text.length) {\n          const token = new state.Token('text', '', 0);\n          token.content = text.slice(lastPos);\n          token.level = level;\n          nodes.push(token);\n        }\n\n        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);\n      }\n    }\n  }\n}\n\n// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - multiplications 2 x 4 -> 2 × 4\n\nconst RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nconst SCOPED_ABBR_TEST_RE = /\\((c|tm|r)\\)/i;\nconst SCOPED_ABBR_RE = /\\((c|tm|r)\\)/ig;\nconst SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  tm: '™'\n};\nfunction replaceFn(match, name) {\n  return SCOPED_ABBR[name.toLowerCase()];\n}\nfunction replace_scoped(inlineTokens) {\n  let inside_autolink = 0;\n  for (let i = inlineTokens.length - 1; i >= 0; i--) {\n    const token = inlineTokens[i];\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\nfunction replace_rare(inlineTokens) {\n  let inside_autolink = 0;\n  for (let i = inlineTokens.length - 1; i >= 0; i--) {\n    const token = inlineTokens[i];\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content.replace(/\\+-/g, '±')\n        // .., ..., ....... -> …\n        // but ?..... & !..... -> ?.. & !..\n        .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..').replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n        // em-dash\n        .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n        // en-dash\n        .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013').replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013');\n      }\n    }\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\nfunction replace(state) {\n  let blkIdx;\n  if (!state.md.options.typographer) {\n    return;\n  }\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') {\n      continue;\n    }\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children);\n    }\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children);\n    }\n  }\n}\n\n// Convert straight quotation marks to typographic ones\n//\n\nconst QUOTE_TEST_RE = /['\"]/;\nconst QUOTE_RE = /['\"]/g;\nconst APOSTROPHE = '\\u2019'; /* ’ */\n\nfunction replaceAt(str, index, ch) {\n  return str.slice(0, index) + ch + str.slice(index + 1);\n}\nfunction process_inlines(tokens, state) {\n  let j;\n  const stack = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    const thisLevel = tokens[i].level;\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) {\n        break;\n      }\n    }\n    stack.length = j + 1;\n    if (token.type !== 'text') {\n      continue;\n    }\n    let text = token.content;\n    let pos = 0;\n    let max = text.length;\n\n    /* eslint no-labels:0,block-scoped-var:0 */\n    OUTER: while (pos < max) {\n      QUOTE_RE.lastIndex = pos;\n      const t = QUOTE_RE.exec(text);\n      if (!t) {\n        break;\n      }\n      let canOpen = true;\n      let canClose = true;\n      pos = t.index + 1;\n      const isSingle = t[0] === \"'\";\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      let lastChar = 0x20;\n      if (t.index - 1 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\n          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);\n          break;\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      let nextChar = 0x20;\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\n          if (!tokens[j].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          nextChar = tokens[j].content.charCodeAt(0);\n          break;\n        }\n      }\n      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n      const isLastWhiteSpace = isWhiteSpace(lastChar);\n      const isNextWhiteSpace = isWhiteSpace(nextChar);\n      if (isNextWhiteSpace) {\n        canOpen = false;\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false;\n        }\n      }\n      if (isLastWhiteSpace) {\n        canClose = false;\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false;\n        }\n      }\n      if (nextChar === 0x22 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n      if (canOpen && canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar;\n        canClose = isNextPunctChar;\n      }\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n        continue;\n      }\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          let item = stack[j];\n          if (stack[j].level < thisLevel) {\n            break;\n          }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j];\n            let openQuote;\n            let closeQuote;\n            if (isSingle) {\n              openQuote = state.md.options.quotes[2];\n              closeQuote = state.md.options.quotes[3];\n            } else {\n              openQuote = state.md.options.quotes[0];\n              closeQuote = state.md.options.quotes[1];\n            }\n\n            // replace token.content *before* tokens[item.token].content,\n            // because, if they are pointing at the same token, replaceAt\n            // could mess up indices when quote length != 1\n            token.content = replaceAt(token.content, t.index, closeQuote);\n            tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);\n            pos += closeQuote.length - 1;\n            if (item.token === i) {\n              pos += openQuote.length - 1;\n            }\n            text = token.content;\n            max = text.length;\n            stack.length = j;\n            continue OUTER;\n          }\n        }\n      }\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\n        });\n      } else if (canClose && isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE);\n      }\n    }\n  }\n}\nfunction smartquotes(state) {\n  /* eslint max-depth:0 */\n  if (!state.md.options.typographer) {\n    return;\n  }\n  for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline' || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue;\n    }\n    process_inlines(state.tokens[blkIdx].children, state);\n  }\n}\n\n// Join raw text tokens with the rest of the text\n//\n// This is set as a separate rule to provide an opportunity for plugins\n// to run text replacements after text join, but before escape join.\n//\n// For example, `\\:)` shouldn't be replaced with an emoji.\n//\n\nfunction text_join(state) {\n  let curr, last;\n  const blockTokens = state.tokens;\n  const l = blockTokens.length;\n  for (let j = 0; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') continue;\n    const tokens = blockTokens[j].children;\n    const max = tokens.length;\n    for (curr = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text_special') {\n        tokens[curr].type = 'text';\n      }\n    }\n    for (curr = last = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {\n        // collapse two adjacent text nodes\n        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n      } else {\n        if (curr !== last) {\n          tokens[last] = tokens[curr];\n        }\n        last++;\n      }\n    }\n    if (curr !== last) {\n      tokens.length = last;\n    }\n  }\n}\n\n/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n\nconst _rules$2 = [['normalize', normalize], ['block', block], ['inline', inline], ['linkify', linkify$1], ['replacements', replace], ['smartquotes', smartquotes],\n// `text_join` finds `text_special` tokens (for escape sequences)\n// and joins them with the rest of the text\n['text_join', text_join]];\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n  for (let i = 0; i < _rules$2.length; i++) {\n    this.ruler.push(_rules$2[i][0], _rules$2[i][1]);\n  }\n}\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  const rules = this.ruler.getRules('');\n  for (let i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\nCore.prototype.State = StateCore;\n\n// Parser state class\n\nfunction StateBlock(src, md, env, tokens) {\n  this.src = src;\n\n  // link to parser instance\n  this.md = md;\n  this.env = env;\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n  this.bMarks = []; // line begin offsets for fast jumps\n  this.eMarks = []; // line end offsets for fast jumps\n  this.tShift = []; // offsets of the first non-space characters (tabs not expanded)\n  this.sCount = []; // indents for each line (tabs expanded)\n\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n  this.bsCount = [];\n\n  // block parser variables\n\n  // required block content indent (for example, if we are\n  // inside a list, it would be positioned after list marker)\n  this.blkIndent = 0;\n  this.line = 0; // line index in src\n  this.lineMax = 0; // lines count\n  this.tight = false; // loose/tight mode for lists\n  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)\n  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  this.parentType = 'root';\n  this.level = 0;\n\n  // Create caches\n  // Generate markers.\n  const s = this.src;\n  for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {\n    const ch = s.charCodeAt(pos);\n    if (!indent_found) {\n      if (isSpace(ch)) {\n        indent++;\n        if (ch === 0x09) {\n          offset += 4 - offset % 4;\n        } else {\n          offset++;\n        }\n        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) {\n        pos++;\n      }\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n      this.sCount.push(offset);\n      this.bsCount.push(0);\n      indent_found = false;\n      indent = 0;\n      offset = 0;\n      start = pos + 1;\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n  this.sCount.push(0);\n  this.bsCount.push(0);\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\n// Push new token to \"stream\".\n//\nStateBlock.prototype.push = function (type, tag, nesting) {\n  const token = new Token(type, tag, nesting);\n  token.block = true;\n  if (nesting < 0) this.level--; // closing tag\n  token.level = this.level;\n  if (nesting > 0) this.level++; // opening tag\n\n  this.tokens.push(token);\n  return token;\n};\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (let max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n  return from;\n};\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  for (let max = this.src.length; pos < max; pos++) {\n    const ch = this.src.charCodeAt(pos);\n    if (!isSpace(ch)) {\n      break;\n    }\n  }\n  return pos;\n};\n\n// Skip spaces from given position in reverse.\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {\n  if (pos <= min) {\n    return pos;\n  }\n  while (pos > min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) {\n      return pos + 1;\n    }\n  }\n  return pos;\n};\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (let max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) {\n      break;\n    }\n  }\n  return pos;\n};\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) {\n    return pos;\n  }\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) {\n      return pos + 1;\n    }\n  }\n  return pos;\n};\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  if (begin >= end) {\n    return '';\n  }\n  const queue = new Array(end - begin);\n  for (let i = 0, line = begin; line < end; line++, i++) {\n    let lineIndent = 0;\n    const lineStart = this.bMarks[line];\n    let first = lineStart;\n    let last;\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n    while (first < last && lineIndent < indent) {\n      const ch = this.src.charCodeAt(first);\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;\n        } else {\n          lineIndent++;\n        }\n      } else if (first - lineStart < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++;\n      } else {\n        break;\n      }\n      first++;\n    }\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);\n    } else {\n      queue[i] = this.src.slice(first, last);\n    }\n  }\n  return queue.join('');\n};\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token;\n\n// GFM table, https://github.github.com/gfm/#tables-extension-\n\n\n// Limit the amount of empty autocompleted cells in a table,\n// see https://github.com/markdown-it/markdown-it/issues/1000,\n//\n// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.\n// We set it to 65k, which can expand user input by a factor of x370\n// (256x256 square is 1.8kB expanded into 650kB).\nconst MAX_AUTOCOMPLETED_CELLS = 0x10000;\nfunction getLine(state, line) {\n  const pos = state.bMarks[line] + state.tShift[line];\n  const max = state.eMarks[line];\n  return state.src.slice(pos, max);\n}\nfunction escapedSplit(str) {\n  const result = [];\n  const max = str.length;\n  let pos = 0;\n  let ch = str.charCodeAt(pos);\n  let isEscaped = false;\n  let lastPos = 0;\n  let current = '';\n  while (pos < max) {\n    if (ch === 0x7c /* | */) {\n      if (!isEscaped) {\n        // pipe separating cells, '|'\n        result.push(current + str.substring(lastPos, pos));\n        current = '';\n        lastPos = pos + 1;\n      } else {\n        // escaped pipe, '\\|'\n        current += str.substring(lastPos, pos - 1);\n        lastPos = pos;\n      }\n    }\n    isEscaped = ch === 0x5c /* \\ */;\n    pos++;\n    ch = str.charCodeAt(pos);\n  }\n  result.push(current + str.substring(lastPos));\n  return result;\n}\nfunction table(state, startLine, endLine, silent) {\n  // should have at least two lines\n  if (startLine + 2 > endLine) {\n    return false;\n  }\n  let nextLine = startLine + 1;\n  if (state.sCount[nextLine] < state.blkIndent) {\n    return false;\n  }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  let pos = state.bMarks[nextLine] + state.tShift[nextLine];\n  if (pos >= state.eMarks[nextLine]) {\n    return false;\n  }\n  const firstCh = state.src.charCodeAt(pos++);\n  if (firstCh !== 0x7C /* | */ && firstCh !== 0x2D /* - */ && firstCh !== 0x3A /* : */) {\n    return false;\n  }\n  if (pos >= state.eMarks[nextLine]) {\n    return false;\n  }\n  const secondCh = state.src.charCodeAt(pos++);\n  if (secondCh !== 0x7C /* | */ && secondCh !== 0x2D /* - */ && secondCh !== 0x3A /* : */ && !isSpace(secondCh)) {\n    return false;\n  }\n\n  // if first character is '-', then second character must not be a space\n  // (due to parsing ambiguity with list)\n  if (firstCh === 0x2D /* - */ && isSpace(secondCh)) {\n    return false;\n  }\n  while (pos < state.eMarks[nextLine]) {\n    const ch = state.src.charCodeAt(pos);\n    if (ch !== 0x7C /* | */ && ch !== 0x2D /* - */ && ch !== 0x3A /* : */ && !isSpace(ch)) {\n      return false;\n    }\n    pos++;\n  }\n  let lineText = getLine(state, startLine + 1);\n  let columns = lineText.split('|');\n  const aligns = [];\n  for (let i = 0; i < columns.length; i++) {\n    const t = columns[i].trim();\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n    if (!/^:?-+:?$/.test(t)) {\n      return false;\n    }\n    if (t.charCodeAt(t.length - 1) === 0x3A /* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A /* : */ ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A /* : */) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n  lineText = getLine(state, startLine).trim();\n  if (lineText.indexOf('|') === -1) {\n    return false;\n  }\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  columns = escapedSplit(lineText);\n  if (columns.length && columns[0] === '') columns.shift();\n  if (columns.length && columns[columns.length - 1] === '') columns.pop();\n\n  // header row will define an amount of columns in the entire table,\n  // and align row should be exactly the same (the rest of the rows can differ)\n  const columnCount = columns.length;\n  if (columnCount === 0 || columnCount !== aligns.length) {\n    return false;\n  }\n  if (silent) {\n    return true;\n  }\n  const oldParentType = state.parentType;\n  state.parentType = 'table';\n\n  // use 'blockquote' lists for termination because it's\n  // the most similar to tables\n  const terminatorRules = state.md.block.ruler.getRules('blockquote');\n  const token_to = state.push('table_open', 'table', 1);\n  const tableLines = [startLine, 0];\n  token_to.map = tableLines;\n  const token_tho = state.push('thead_open', 'thead', 1);\n  token_tho.map = [startLine, startLine + 1];\n  const token_htro = state.push('tr_open', 'tr', 1);\n  token_htro.map = [startLine, startLine + 1];\n  for (let i = 0; i < columns.length; i++) {\n    const token_ho = state.push('th_open', 'th', 1);\n    if (aligns[i]) {\n      token_ho.attrs = [['style', 'text-align:' + aligns[i]]];\n    }\n    const token_il = state.push('inline', '', 0);\n    token_il.content = columns[i].trim();\n    token_il.children = [];\n    state.push('th_close', 'th', -1);\n  }\n  state.push('tr_close', 'tr', -1);\n  state.push('thead_close', 'thead', -1);\n  let tbodyLines;\n  let autocompletedCells = 0;\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) {\n      break;\n    }\n    let terminate = false;\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) {\n      break;\n    }\n    lineText = getLine(state, nextLine).trim();\n    if (!lineText) {\n      break;\n    }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      break;\n    }\n    columns = escapedSplit(lineText);\n    if (columns.length && columns[0] === '') columns.shift();\n    if (columns.length && columns[columns.length - 1] === '') columns.pop();\n\n    // note: autocomplete count can be negative if user specifies more columns than header,\n    // but that does not affect intended use (which is limiting expansion)\n    autocompletedCells += columnCount - columns.length;\n    if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) {\n      break;\n    }\n    if (nextLine === startLine + 2) {\n      const token_tbo = state.push('tbody_open', 'tbody', 1);\n      token_tbo.map = tbodyLines = [startLine + 2, 0];\n    }\n    const token_tro = state.push('tr_open', 'tr', 1);\n    token_tro.map = [nextLine, nextLine + 1];\n    for (let i = 0; i < columnCount; i++) {\n      const token_tdo = state.push('td_open', 'td', 1);\n      if (aligns[i]) {\n        token_tdo.attrs = [['style', 'text-align:' + aligns[i]]];\n      }\n      const token_il = state.push('inline', '', 0);\n      token_il.content = columns[i] ? columns[i].trim() : '';\n      token_il.children = [];\n      state.push('td_close', 'td', -1);\n    }\n    state.push('tr_close', 'tr', -1);\n  }\n  if (tbodyLines) {\n    state.push('tbody_close', 'tbody', -1);\n    tbodyLines[1] = nextLine;\n  }\n  state.push('table_close', 'table', -1);\n  tableLines[1] = nextLine;\n  state.parentType = oldParentType;\n  state.line = nextLine;\n  return true;\n}\n\n// Code block (4 spaces padded)\n\nfunction code(state, startLine, endLine /*, silent */) {\n  if (state.sCount[startLine] - state.blkIndent < 4) {\n    return false;\n  }\n  let nextLine = startLine + 1;\n  let last = nextLine;\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n  state.line = last;\n  const token = state.push('code_block', 'code', 0);\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\\n';\n  token.map = [startLine, state.line];\n  return true;\n}\n\n// fences (``` lang, ~~~ lang)\n\nfunction fence(state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  let max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  if (pos + 3 > max) {\n    return false;\n  }\n  const marker = state.src.charCodeAt(pos);\n  if (marker !== 0x7E /* ~ */ && marker !== 0x60 /* ` */) {\n    return false;\n  }\n\n  // scan marker length\n  let mem = pos;\n  pos = state.skipChars(pos, marker);\n  let len = pos - mem;\n  if (len < 3) {\n    return false;\n  }\n  const markup = state.src.slice(mem, pos);\n  const params = state.src.slice(pos, max);\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) >= 0) {\n      return false;\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) {\n    return true;\n  }\n\n  // search end of block\n  let nextLine = startLine;\n  let haveEndMarker = false;\n  for (;;) {\n    nextLine++;\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n    if (state.src.charCodeAt(pos) !== marker) {\n      continue;\n    }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) {\n      continue;\n    }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n    if (pos < max) {\n      continue;\n    }\n    haveEndMarker = true;\n    // found!\n    break;\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine];\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n  const token = state.push('fence', 'code', 0);\n  token.info = params;\n  token.content = state.getLines(startLine + 1, nextLine, len, true);\n  token.markup = markup;\n  token.map = [startLine, state.line];\n  return true;\n}\n\n// Block quotes\n\nfunction blockquote(state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  let max = state.eMarks[startLine];\n  const oldLineMax = state.lineMax;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos) !== 0x3E /* > */) {\n    return false;\n  }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) {\n    return true;\n  }\n  const oldBMarks = [];\n  const oldBSCount = [];\n  const oldSCount = [];\n  const oldTShift = [];\n  const terminatorRules = state.md.block.ruler.getRules('blockquote');\n  const oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  let lastLineEmpty = false;\n  let nextLine;\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    const isOutdented = state.sCount[nextLine] < state.blkIndent;\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n    if (state.src.charCodeAt(pos++) === 0x3E /* > */ && !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \">\"\n      let initial = state.sCount[nextLine] + 1;\n      let spaceAfterMarker;\n      let adjustTab;\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true;\n        if ((state.bsCount[nextLine] + initial) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          adjustTab = false;\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true;\n        }\n      } else {\n        spaceAfterMarker = false;\n      }\n      let offset = initial;\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n      while (pos < max) {\n        const ch = state.src.charCodeAt(pos);\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;\n          } else {\n            offset++;\n          }\n        } else {\n          break;\n        }\n        pos++;\n      }\n      lastLineEmpty = pos >= max;\n      oldBSCount.push(state.bsCount[nextLine]);\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);\n      oldSCount.push(state.sCount[nextLine]);\n      state.sCount[nextLine] = offset - initial;\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) {\n      break;\n    }\n\n    // Case 3: another tag found.\n    let terminate = false;\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine;\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine]);\n        oldBSCount.push(state.bsCount[nextLine]);\n        oldTShift.push(state.tShift[nextLine]);\n        oldSCount.push(state.sCount[nextLine]);\n        state.sCount[nextLine] -= state.blkIndent;\n      }\n      break;\n    }\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldBSCount.push(state.bsCount[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n    oldSCount.push(state.sCount[nextLine]);\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1;\n  }\n  const oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n  const token_o = state.push('blockquote_open', 'blockquote', 1);\n  token_o.markup = '>';\n  const lines = [startLine, 0];\n  token_o.map = lines;\n  state.md.block.tokenize(state, startLine, nextLine);\n  const token_c = state.push('blockquote_close', 'blockquote', -1);\n  token_c.markup = '>';\n  state.lineMax = oldLineMax;\n  state.parentType = oldParentType;\n  lines[1] = state.line;\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (let i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n    state.sCount[i + startLine] = oldSCount[i];\n    state.bsCount[i + startLine] = oldBSCount[i];\n  }\n  state.blkIndent = oldIndent;\n  return true;\n}\n\n// Horizontal rule\n\nfunction hr(state, startLine, endLine, silent) {\n  const max = state.eMarks[startLine];\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  const marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A /* * */ && marker !== 0x2D /* - */ && marker !== 0x5F /* _ */) {\n    return false;\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  let cnt = 1;\n  while (pos < max) {\n    const ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && !isSpace(ch)) {\n      return false;\n    }\n    if (ch === marker) {\n      cnt++;\n    }\n  }\n  if (cnt < 3) {\n    return false;\n  }\n  if (silent) {\n    return true;\n  }\n  state.line = startLine + 1;\n  const token = state.push('hr', 'hr', 0);\n  token.map = [startLine, state.line];\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));\n  return true;\n}\n\n// Lists\n\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  const max = state.eMarks[startLine];\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  const marker = state.src.charCodeAt(pos++);\n  // Check bullet\n  if (marker !== 0x2A /* * */ && marker !== 0x2D /* - */ && marker !== 0x2B /* + */) {\n    return -1;\n  }\n  if (pos < max) {\n    const ch = state.src.charCodeAt(pos);\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1;\n    }\n  }\n  return pos;\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  const start = state.bMarks[startLine] + state.tShift[startLine];\n  const max = state.eMarks[startLine];\n  let pos = start;\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 >= max) {\n    return -1;\n  }\n  let ch = state.src.charCodeAt(pos++);\n  if (ch < 0x30 /* 0 */ || ch > 0x39 /* 9 */) {\n    return -1;\n  }\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) {\n      return -1;\n    }\n    ch = state.src.charCodeAt(pos++);\n    if (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) {\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) {\n        return -1;\n      }\n      continue;\n    }\n\n    // found valid marker\n    if (ch === 0x29 /* ) */ || ch === 0x2e /* . */) {\n      break;\n    }\n    return -1;\n  }\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1;\n    }\n  }\n  return pos;\n}\nfunction markTightParagraphs(state, idx) {\n  const level = state.level + 2;\n  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true;\n      state.tokens[i].hidden = true;\n      i += 2;\n    }\n  }\n}\nfunction list(state, startLine, endLine, silent) {\n  let max, pos, start, token;\n  let nextLine = startLine;\n  let tight = true;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent >= 0 && state.sCount[nextLine] - state.listIndent >= 4 && state.sCount[nextLine] < state.blkIndent) {\n    return false;\n  }\n  let isTerminatingParagraph = false;\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  }\n\n  // Detect list type and position after marker\n  let isOrdered;\n  let markerValue;\n  let posAfterMarker;\n  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {\n    isOrdered = true;\n    start = state.bMarks[nextLine] + state.tShift[nextLine];\n    markerValue = Number(state.src.slice(start, posAfterMarker - 1));\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph && markerValue !== 1) return false;\n  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {\n    isOrdered = false;\n  } else {\n    return false;\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false;\n  }\n\n  // For validation mode we can terminate immediately\n  if (silent) {\n    return true;\n  }\n\n  // We should terminate list on style change. Remember first one to compare.\n  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // Start list\n  const listTokIdx = state.tokens.length;\n  if (isOrdered) {\n    token = state.push('ordered_list_open', 'ol', 1);\n    if (markerValue !== 1) {\n      token.attrs = [['start', markerValue]];\n    }\n  } else {\n    token = state.push('bullet_list_open', 'ul', 1);\n  }\n  const listLines = [nextLine, 0];\n  token.map = listLines;\n  token.markup = String.fromCharCode(markerCharCode);\n\n  //\n  // Iterate list items\n  //\n\n  let prevEmptyEnd = false;\n  const terminatorRules = state.md.block.ruler.getRules('list');\n  const oldParentType = state.parentType;\n  state.parentType = 'list';\n  while (nextLine < endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);\n    let offset = initial;\n    while (pos < max) {\n      const ch = state.src.charCodeAt(pos);\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4;\n      } else if (ch === 0x20) {\n        offset++;\n      } else {\n        break;\n      }\n      pos++;\n    }\n    const contentStart = pos;\n    let indentAfterMarker;\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) {\n      indentAfterMarker = 1;\n    }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    const indent = initial + indentAfterMarker;\n\n    // Run subparser & write tokens\n    token = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    const itemLines = [nextLine, 0];\n    token.map = itemLines;\n    if (isOrdered) {\n      token.info = state.src.slice(start, posAfterMarker - 1);\n    }\n\n    // change current state, then restore it after parser subcall\n    const oldTight = state.tight;\n    const oldTShift = state.tShift[nextLine];\n    const oldSCount = state.sCount[nextLine];\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    const oldListIndent = state.listIndent;\n    state.listIndent = state.blkIndent;\n    state.blkIndent = indent;\n    state.tight = true;\n    state.tShift[nextLine] = contentStart - state.bMarks[nextLine];\n    state.sCount[nextLine] = offset;\n    if (contentStart >= max && state.isEmpty(nextLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine);\n    } else {\n      state.md.block.tokenize(state, nextLine, endLine, true);\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[nextLine] = oldTShift;\n    state.sCount[nextLine] = oldSCount;\n    state.tight = oldTight;\n    token = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n    nextLine = state.line;\n    itemLines[1] = nextLine;\n    if (nextLine >= endLine) {\n      break;\n    }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) {\n      break;\n    }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      break;\n    }\n\n    // fail if terminating block found\n    let terminate = false;\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) {\n      break;\n    }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker < 0) {\n        break;\n      }\n      start = state.bMarks[nextLine] + state.tShift[nextLine];\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker < 0) {\n        break;\n      }\n    }\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {\n      break;\n    }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1);\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1);\n  }\n  token.markup = String.fromCharCode(markerCharCode);\n  listLines[1] = nextLine;\n  state.line = nextLine;\n  state.parentType = oldParentType;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n  return true;\n}\n\nfunction reference(state, startLine, _endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  let max = state.eMarks[startLine];\n  let nextLine = startLine + 1;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  if (state.src.charCodeAt(pos) !== 0x5B /* [ */) {\n    return false;\n  }\n  function getNextLine(nextLine) {\n    const endLine = state.lineMax;\n    if (nextLine >= endLine || state.isEmpty(nextLine)) {\n      // empty line or end of input\n      return null;\n    }\n    let isContinuation = false;\n\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      isContinuation = true;\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) {\n      isContinuation = true;\n    }\n    if (!isContinuation) {\n      const terminatorRules = state.md.block.ruler.getRules('reference');\n      const oldParentType = state.parentType;\n      state.parentType = 'reference';\n\n      // Some tags can terminate paragraph without empty line.\n      let terminate = false;\n      for (let i = 0, l = terminatorRules.length; i < l; i++) {\n        if (terminatorRules[i](state, nextLine, endLine, true)) {\n          terminate = true;\n          break;\n        }\n      }\n      state.parentType = oldParentType;\n      if (terminate) {\n        // terminated by another block\n        return null;\n      }\n    }\n    const pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    const max = state.eMarks[nextLine];\n\n    // max + 1 explicitly includes the newline\n    return state.src.slice(pos, max + 1);\n  }\n  let str = state.src.slice(pos, max + 1);\n  max = str.length;\n  let labelEnd = -1;\n  for (pos = 1; pos < max; pos++) {\n    const ch = str.charCodeAt(pos);\n    if (ch === 0x5B /* [ */) {\n      return false;\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos;\n      break;\n    } else if (ch === 0x0A /* \\n */) {\n      const lineContent = getNextLine(nextLine);\n      if (lineContent !== null) {\n        str += lineContent;\n        max = str.length;\n        nextLine++;\n      }\n    } else if (ch === 0x5C /* \\ */) {\n      pos++;\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        const lineContent = getNextLine(nextLine);\n        if (lineContent !== null) {\n          str += lineContent;\n          max = str.length;\n          nextLine++;\n        }\n      }\n    }\n  }\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A /* : */) {\n    return false;\n  }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    const ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine);\n      if (lineContent !== null) {\n        str += lineContent;\n        max = str.length;\n        nextLine++;\n      }\n    } else if (isSpace(ch)) ; else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  const destRes = state.md.helpers.parseLinkDestination(str, pos, max);\n  if (!destRes.ok) {\n    return false;\n  }\n  const href = state.md.normalizeLink(destRes.str);\n  if (!state.md.validateLink(href)) {\n    return false;\n  }\n  pos = destRes.pos;\n\n  // save cursor state, we could require to rollback later\n  const destEndPos = pos;\n  const destEndLineNo = nextLine;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  const start = pos;\n  for (; pos < max; pos++) {\n    const ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine);\n      if (lineContent !== null) {\n        str += lineContent;\n        max = str.length;\n        nextLine++;\n      }\n    } else if (isSpace(ch)) ; else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);\n  while (titleRes.can_continue) {\n    const lineContent = getNextLine(nextLine);\n    if (lineContent === null) break;\n    str += lineContent;\n    pos = max;\n    max = str.length;\n    nextLine++;\n    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);\n  }\n  let title;\n  if (pos < max && start !== pos && titleRes.ok) {\n    title = titleRes.str;\n    pos = titleRes.pos;\n  } else {\n    title = '';\n    pos = destEndPos;\n    nextLine = destEndLineNo;\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    const ch = str.charCodeAt(pos);\n    if (!isSpace(ch)) {\n      break;\n    }\n    pos++;\n  }\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = '';\n      pos = destEndPos;\n      nextLine = destEndLineNo;\n      while (pos < max) {\n        const ch = str.charCodeAt(pos);\n        if (!isSpace(ch)) {\n          break;\n        }\n        pos++;\n      }\n    }\n  }\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false;\n  }\n  const label = normalizeReference(str.slice(1, labelEnd));\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false;\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /* istanbul ignore if */\n  if (silent) {\n    return true;\n  }\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {};\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = {\n      title,\n      href\n    };\n  }\n  state.line = nextLine;\n  return true;\n}\n\n// List of valid html blocks names, according to commonmark spec\n// https://spec.commonmark.org/0.30/#html-blocks\n\nvar block_names = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'search', 'section', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\n\n// Regexps to match html elements\n\nconst attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\nconst unquoted = '[^\"\\'=<>`\\\\x00-\\\\x20]+';\nconst single_quoted = \"'[^']*'\";\nconst double_quoted = '\"[^\"]*\"';\nconst attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';\nconst attribute = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)';\nconst open_tag = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\nconst close_tag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nconst comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';\nconst processing = '<[?][\\\\s\\\\S]*?[?]>';\nconst declaration = '<![A-Za-z][^>]*>';\nconst cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\nconst HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');\nconst HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');\n\n// HTML block\n\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nconst HTML_SEQUENCES = [[/^<(script|pre|style|textarea)(?=(\\s|>|$))/i, /<\\/(script|pre|style|textarea)>/i, true], [/^<!--/, /-->/, true], [/^<\\?/, /\\?>/, true], [/^<![A-Z]/, />/, true], [/^<!\\[CDATA\\[/, /\\]\\]>/, true], [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'), /^$/, false]];\nfunction html_block(state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  let max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  if (!state.md.options.html) {\n    return false;\n  }\n  if (state.src.charCodeAt(pos) !== 0x3C /* < */) {\n    return false;\n  }\n  let lineText = state.src.slice(pos, max);\n  let i = 0;\n  for (; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) {\n      break;\n    }\n  }\n  if (i === HTML_SEQUENCES.length) {\n    return false;\n  }\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2];\n  }\n  let nextLine = startLine + 1;\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) {\n        break;\n      }\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n      lineText = state.src.slice(pos, max);\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) {\n          nextLine++;\n        }\n        break;\n      }\n    }\n  }\n  state.line = nextLine;\n  const token = state.push('html_block', '', 0);\n  token.map = [startLine, nextLine];\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);\n  return true;\n}\n\n// heading (#, ##, ...)\n\nfunction heading(state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine];\n  let max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  let ch = state.src.charCodeAt(pos);\n  if (ch !== 0x23 /* # */ || pos >= max) {\n    return false;\n  }\n\n  // count heading level\n  let level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23 /* # */ && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n  if (level > 6 || pos < max && !isSpace(ch)) {\n    return false;\n  }\n  if (silent) {\n    return true;\n  }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos);\n  const tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp;\n  }\n  state.line = startLine + 1;\n  const token_o = state.push('heading_open', 'h' + String(level), 1);\n  token_o.markup = '########'.slice(0, level);\n  token_o.map = [startLine, state.line];\n  const token_i = state.push('inline', '', 0);\n  token_i.content = state.src.slice(pos, max).trim();\n  token_i.map = [startLine, state.line];\n  token_i.children = [];\n  const token_c = state.push('heading_close', 'h' + String(level), -1);\n  token_c.markup = '########'.slice(0, level);\n  return true;\n}\n\n// lheading (---, ===)\n\nfunction lheading(state, startLine, endLine /*, silent */) {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph');\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n  const oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  let level = 0;\n  let marker;\n  let nextLine = startLine + 1;\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      continue;\n    }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      let pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      const max = state.eMarks[nextLine];\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos);\n        if (marker === 0x2D /* - */ || marker === 0x3D /* = */) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n          if (pos >= max) {\n            level = marker === 0x3D /* = */ ? 1 : 2;\n            break;\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) {\n      continue;\n    }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false;\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) {\n      break;\n    }\n  }\n  if (!level) {\n    // Didn't find valid underline\n    return false;\n  }\n  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  state.line = nextLine + 1;\n  const token_o = state.push('heading_open', 'h' + String(level), 1);\n  token_o.markup = String.fromCharCode(marker);\n  token_o.map = [startLine, state.line];\n  const token_i = state.push('inline', '', 0);\n  token_i.content = content;\n  token_i.map = [startLine, state.line - 1];\n  token_i.children = [];\n  const token_c = state.push('heading_close', 'h' + String(level), -1);\n  token_c.markup = String.fromCharCode(marker);\n  state.parentType = oldParentType;\n  return true;\n}\n\n// Paragraph\n\nfunction paragraph(state, startLine, endLine) {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph');\n  const oldParentType = state.parentType;\n  let nextLine = startLine + 1;\n  state.parentType = 'paragraph';\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      continue;\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) {\n      continue;\n    }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false;\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) {\n      break;\n    }\n  }\n  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  state.line = nextLine;\n  const token_o = state.push('paragraph_open', 'p', 1);\n  token_o.map = [startLine, state.line];\n  const token_i = state.push('inline', '', 0);\n  token_i.content = content;\n  token_i.map = [startLine, state.line];\n  token_i.children = [];\n  state.push('paragraph_close', 'p', -1);\n  state.parentType = oldParentType;\n  return true;\n}\n\n/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n\nconst _rules$1 = [\n// First 2 params - rule name & source. Secondary array - list of rules,\n// which can be terminated by this one.\n['table', table, ['paragraph', 'reference']], ['code', code], ['fence', fence, ['paragraph', 'reference', 'blockquote', 'list']], ['blockquote', blockquote, ['paragraph', 'reference', 'blockquote', 'list']], ['hr', hr, ['paragraph', 'reference', 'blockquote', 'list']], ['list', list, ['paragraph', 'reference', 'blockquote']], ['reference', reference], ['html_block', html_block, ['paragraph', 'reference', 'blockquote']], ['heading', heading, ['paragraph', 'reference', 'blockquote']], ['lheading', lheading], ['paragraph', paragraph]];\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n  for (let i = 0; i < _rules$1.length; i++) {\n    this.ruler.push(_rules$1[i][0], _rules$1[i][1], {\n      alt: (_rules$1[i][2] || []).slice()\n    });\n  }\n}\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  const rules = this.ruler.getRules('');\n  const len = rules.length;\n  const maxNesting = state.md.options.maxNesting;\n  let line = startLine;\n  let hasEmptyLines = false;\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) {\n      break;\n    }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) {\n      break;\n    }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n    const prevLine = state.line;\n    let ok = false;\n    for (let i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) {\n        if (prevLine >= state.line) {\n          throw new Error(\"block rule didn't increment state.line\");\n        }\n        break;\n      }\n    }\n\n    // this can only happen if user disables paragraph rule\n    if (!ok) throw new Error('none of the block rules matched');\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n    line = state.line;\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n      state.line = line;\n    }\n  }\n};\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  if (!src) {\n    return;\n  }\n  const state = new this.State(src, md, env, outTokens);\n  this.tokenize(state, state.line, state.lineMax);\n};\nParserBlock.prototype.State = StateBlock;\n\n// Inline parser state\n\nfunction StateInline(src, md, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.md = md;\n  this.tokens = outTokens;\n  this.tokens_meta = Array(outTokens.length);\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  this.cache = {};\n\n  // List of emphasis-like delimiters for current tag\n  this.delimiters = [];\n\n  // Stack of delimiter lists for upper level tags\n  this._prev_delimiters = [];\n\n  // backtick length => last seen position\n  this.backticks = {};\n  this.backticksScanned = false;\n\n  // Counter used to disable inline linkify-it execution\n  // inside <a> and markdown links\n  this.linkLevel = 0;\n}\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  const token = new Token('text', '', 0);\n  token.content = this.pending;\n  token.level = this.pendingLevel;\n  this.tokens.push(token);\n  this.pending = '';\n  return token;\n};\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (type, tag, nesting) {\n  if (this.pending) {\n    this.pushPending();\n  }\n  const token = new Token(type, tag, nesting);\n  let token_meta = null;\n  if (nesting < 0) {\n    // closing tag\n    this.level--;\n    this.delimiters = this._prev_delimiters.pop();\n  }\n  token.level = this.level;\n  if (nesting > 0) {\n    // opening tag\n    this.level++;\n    this._prev_delimiters.push(this.delimiters);\n    this.delimiters = [];\n    token_meta = {\n      delimiters: this.delimiters\n    };\n  }\n  this.pendingLevel = this.level;\n  this.tokens.push(token);\n  this.tokens_meta.push(token_meta);\n  return token;\n};\n\n// Scan a sequence of emphasis-like markers, and determine whether\n// it can start an emphasis sequence or end an emphasis sequence.\n//\n//  - start - position to scan from (it should point at a valid marker);\n//  - canSplitWord - determine if these markers can be found inside a word\n//\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  const max = this.posMax;\n  const marker = this.src.charCodeAt(start);\n\n  // treat beginning of the line as a whitespace\n  const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;\n  let pos = start;\n  while (pos < max && this.src.charCodeAt(pos) === marker) {\n    pos++;\n  }\n  const count = pos - start;\n\n  // treat end of the line as a whitespace\n  const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;\n  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n  const isLastWhiteSpace = isWhiteSpace(lastChar);\n  const isNextWhiteSpace = isWhiteSpace(nextChar);\n  const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);\n  const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);\n  const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar);\n  const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar);\n  return {\n    can_open,\n    can_close,\n    length: count\n  };\n};\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token;\n\n// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A /* \\n */:\n    case 0x21 /* ! */:\n    case 0x23 /* # */:\n    case 0x24 /* $ */:\n    case 0x25 /* % */:\n    case 0x26 /* & */:\n    case 0x2A /* * */:\n    case 0x2B /* + */:\n    case 0x2D /* - */:\n    case 0x3A /* : */:\n    case 0x3C /* < */:\n    case 0x3D /* = */:\n    case 0x3E /* > */:\n    case 0x40 /* @ */:\n    case 0x5B /* [ */:\n    case 0x5C /* \\ */:\n    case 0x5D /* ] */:\n    case 0x5E /* ^ */:\n    case 0x5F /* _ */:\n    case 0x60 /* ` */:\n    case 0x7B /* { */:\n    case 0x7D /* } */:\n    case 0x7E /* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\nfunction text(state, silent) {\n  let pos = state.pos;\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n  if (pos === state.pos) {\n    return false;\n  }\n  if (!silent) {\n    state.pending += state.src.slice(state.pos, pos);\n  }\n  state.pos = pos;\n  return true;\n}\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParserInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n}; */\n\n// Process links like https://example.org/\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nconst SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;\nfunction linkify(state, silent) {\n  if (!state.md.options.linkify) return false;\n  if (state.linkLevel > 0) return false;\n  const pos = state.pos;\n  const max = state.posMax;\n  if (pos + 3 > max) return false;\n  if (state.src.charCodeAt(pos) !== 0x3A /* : */) return false;\n  if (state.src.charCodeAt(pos + 1) !== 0x2F /* / */) return false;\n  if (state.src.charCodeAt(pos + 2) !== 0x2F /* / */) return false;\n  const match = state.pending.match(SCHEME_RE);\n  if (!match) return false;\n  const proto = match[1];\n  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));\n  if (!link) return false;\n  let url = link.url;\n\n  // invalid link, but still detected by linkify somehow;\n  // need to check to prevent infinite loop below\n  if (url.length <= proto.length) return false;\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  url = url.replace(/\\*+$/, '');\n  const fullUrl = state.md.normalizeLink(url);\n  if (!state.md.validateLink(fullUrl)) return false;\n  if (!silent) {\n    state.pending = state.pending.slice(0, -proto.length);\n    const token_o = state.push('link_open', 'a', 1);\n    token_o.attrs = [['href', fullUrl]];\n    token_o.markup = 'linkify';\n    token_o.info = 'auto';\n    const token_t = state.push('text', '', 0);\n    token_t.content = state.md.normalizeLinkText(url);\n    const token_c = state.push('link_close', 'a', -1);\n    token_c.markup = 'linkify';\n    token_c.info = 'auto';\n  }\n  state.pos += url.length - proto.length;\n  return true;\n}\n\n// Proceess '\\n'\n\nfunction newline(state, silent) {\n  let pos = state.pos;\n  if (state.src.charCodeAt(pos) !== 0x0A /* \\n */) {\n    return false;\n  }\n  const pmax = state.pending.length - 1;\n  const max = state.posMax;\n\n  // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        let ws = pmax - 1;\n        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--;\n        state.pending = state.pending.slice(0, ws);\n        state.push('hardbreak', 'br', 0);\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push('softbreak', 'br', 0);\n      }\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n  state.pos = pos;\n  return true;\n}\n\n// Process escaped chars and hardbreaks\n\nconst ESCAPED = [];\nfor (let i = 0; i < 256; i++) {\n  ESCAPED.push(0);\n}\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'.split('').forEach(function (ch) {\n  ESCAPED[ch.charCodeAt(0)] = 1;\n});\nfunction escape(state, silent) {\n  let pos = state.pos;\n  const max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x5C /* \\ */) return false;\n  pos++;\n\n  // '\\' at the end of the inline block\n  if (pos >= max) return false;\n  let ch1 = state.src.charCodeAt(pos);\n  if (ch1 === 0x0A) {\n    if (!silent) {\n      state.push('hardbreak', 'br', 0);\n    }\n    pos++;\n    // skip leading whitespaces from next line\n    while (pos < max) {\n      ch1 = state.src.charCodeAt(pos);\n      if (!isSpace(ch1)) break;\n      pos++;\n    }\n    state.pos = pos;\n    return true;\n  }\n  let escapedStr = state.src[pos];\n  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {\n    const ch2 = state.src.charCodeAt(pos + 1);\n    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\n      escapedStr += state.src[pos + 1];\n      pos++;\n    }\n  }\n  const origStr = '\\\\' + escapedStr;\n  if (!silent) {\n    const token = state.push('text_special', '', 0);\n    if (ch1 < 256 && ESCAPED[ch1] !== 0) {\n      token.content = escapedStr;\n    } else {\n      token.content = origStr;\n    }\n    token.markup = origStr;\n    token.info = 'escape';\n  }\n  state.pos = pos + 1;\n  return true;\n}\n\n// Parse backticks\n\nfunction backtick(state, silent) {\n  let pos = state.pos;\n  const ch = state.src.charCodeAt(pos);\n  if (ch !== 0x60 /* ` */) {\n    return false;\n  }\n  const start = pos;\n  pos++;\n  const max = state.posMax;\n\n  // scan marker length\n  while (pos < max && state.src.charCodeAt(pos) === 0x60 /* ` */) {\n    pos++;\n  }\n  const marker = state.src.slice(start, pos);\n  const openerLength = marker.length;\n  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {\n    if (!silent) state.pending += marker;\n    state.pos += openerLength;\n    return true;\n  }\n  let matchEnd = pos;\n  let matchStart;\n\n  // Nothing found in the cache, scan until the end of the line (or until marker is found)\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    // scan marker length\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60 /* ` */) {\n      matchEnd++;\n    }\n    const closerLength = matchEnd - matchStart;\n    if (closerLength === openerLength) {\n      // Found matching closer length.\n      if (!silent) {\n        const token = state.push('code_inline', 'code', 0);\n        token.markup = marker;\n        token.content = state.src.slice(pos, matchStart).replace(/\\n/g, ' ').replace(/^ (.+) $/, '$1');\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n\n    // Some different length found, put it in cache as upper limit of where closer can be found\n    state.backticks[closerLength] = matchStart;\n  }\n\n  // Scanned through the end, didn't find anything\n  state.backticksScanned = true;\n  if (!silent) state.pending += marker;\n  state.pos += openerLength;\n  return true;\n}\n\n// ~~strike through~~\n//\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction strikethrough_tokenize(state, silent) {\n  const start = state.pos;\n  const marker = state.src.charCodeAt(start);\n  if (silent) {\n    return false;\n  }\n  if (marker !== 0x7E /* ~ */) {\n    return false;\n  }\n  const scanned = state.scanDelims(state.pos, true);\n  let len = scanned.length;\n  const ch = String.fromCharCode(marker);\n  if (len < 2) {\n    return false;\n  }\n  let token;\n  if (len % 2) {\n    token = state.push('text', '', 0);\n    token.content = ch;\n    len--;\n  }\n  for (let i = 0; i < len; i += 2) {\n    token = state.push('text', '', 0);\n    token.content = ch + ch;\n    state.delimiters.push({\n      marker,\n      length: 0,\n      // disable \"rule of 3\" length checks meant for emphasis\n      token: state.tokens.length - 1,\n      end: -1,\n      open: scanned.can_open,\n      close: scanned.can_close\n    });\n  }\n  state.pos += scanned.length;\n  return true;\n}\nfunction postProcess$1(state, delimiters) {\n  let token;\n  const loneMarkers = [];\n  const max = delimiters.length;\n  for (let i = 0; i < max; i++) {\n    const startDelim = delimiters[i];\n    if (startDelim.marker !== 0x7E /* ~ */) {\n      continue;\n    }\n    if (startDelim.end === -1) {\n      continue;\n    }\n    const endDelim = delimiters[startDelim.end];\n    token = state.tokens[startDelim.token];\n    token.type = 's_open';\n    token.tag = 's';\n    token.nesting = 1;\n    token.markup = '~~';\n    token.content = '';\n    token = state.tokens[endDelim.token];\n    token.type = 's_close';\n    token.tag = 's';\n    token.nesting = -1;\n    token.markup = '~~';\n    token.content = '';\n    if (state.tokens[endDelim.token - 1].type === 'text' && state.tokens[endDelim.token - 1].content === '~') {\n      loneMarkers.push(endDelim.token - 1);\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n  while (loneMarkers.length) {\n    const i = loneMarkers.pop();\n    let j = i + 1;\n    while (j < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++;\n    }\n    j--;\n    if (i !== j) {\n      token = state.tokens[j];\n      state.tokens[j] = state.tokens[i];\n      state.tokens[i] = token;\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction strikethrough_postProcess(state) {\n  const tokens_meta = state.tokens_meta;\n  const max = state.tokens_meta.length;\n  postProcess$1(state, state.delimiters);\n  for (let curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess$1(state, tokens_meta[curr].delimiters);\n    }\n  }\n}\nvar r_strikethrough = {\n  tokenize: strikethrough_tokenize,\n  postProcess: strikethrough_postProcess\n};\n\n// Process *this* and _that_\n//\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction emphasis_tokenize(state, silent) {\n  const start = state.pos;\n  const marker = state.src.charCodeAt(start);\n  if (silent) {\n    return false;\n  }\n  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) {\n    return false;\n  }\n  const scanned = state.scanDelims(state.pos, marker === 0x2A);\n  for (let i = 0; i < scanned.length; i++) {\n    const token = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker,\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n      // A position of the token this delimiter corresponds to.\n      //\n      token: state.tokens.length - 1,\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end: -1,\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open: scanned.can_open,\n      close: scanned.can_close\n    });\n  }\n  state.pos += scanned.length;\n  return true;\n}\nfunction postProcess(state, delimiters) {\n  const max = delimiters.length;\n  for (let i = max - 1; i >= 0; i--) {\n    const startDelim = delimiters[i];\n    if (startDelim.marker !== 0x5F /* _ */ && startDelim.marker !== 0x2A /* * */) {\n      continue;\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue;\n    }\n    const endDelim = delimiters[startDelim.end];\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    const isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 &&\n    // check that first two markers match and adjacent\n    delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 &&\n    // check that last two markers are adjacent (we can safely assume they match)\n    delimiters[startDelim.end + 1].token === endDelim.token + 1;\n    const ch = String.fromCharCode(startDelim.marker);\n    const token_o = state.tokens[startDelim.token];\n    token_o.type = isStrong ? 'strong_open' : 'em_open';\n    token_o.tag = isStrong ? 'strong' : 'em';\n    token_o.nesting = 1;\n    token_o.markup = isStrong ? ch + ch : ch;\n    token_o.content = '';\n    const token_c = state.tokens[endDelim.token];\n    token_c.type = isStrong ? 'strong_close' : 'em_close';\n    token_c.tag = isStrong ? 'strong' : 'em';\n    token_c.nesting = -1;\n    token_c.markup = isStrong ? ch + ch : ch;\n    token_c.content = '';\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = '';\n      state.tokens[delimiters[startDelim.end + 1].token].content = '';\n      i--;\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction emphasis_post_process(state) {\n  const tokens_meta = state.tokens_meta;\n  const max = state.tokens_meta.length;\n  postProcess(state, state.delimiters);\n  for (let curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n}\nvar r_emphasis = {\n  tokenize: emphasis_tokenize,\n  postProcess: emphasis_post_process\n};\n\n// Process [link](<to> \"stuff\")\n\nfunction link(state, silent) {\n  let code, label, res, ref;\n  let href = '';\n  let title = '';\n  let start = state.pos;\n  let parseReference = true;\n  if (state.src.charCodeAt(state.pos) !== 0x5B /* [ */) {\n    return false;\n  }\n  const oldPos = state.pos;\n  const max = state.posMax;\n  const labelStart = state.pos + 1;\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) {\n    return false;\n  }\n  let pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28 /* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false;\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    }\n    if (pos >= max) {\n      return false;\n    }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos;\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) {\n          break;\n        }\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n      if (pos < max && start !== pos && res.ok) {\n        title = res.str;\n        pos = res.pos;\n\n        // [link](  <href>  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos < max; pos++) {\n          code = state.src.charCodeAt(pos);\n          if (!isSpace(code) && code !== 0x0A) {\n            break;\n          }\n        }\n      }\n    }\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29 /* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true;\n    }\n    pos++;\n  }\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') {\n      return false;\n    }\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B /* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) {\n      label = state.src.slice(labelStart, labelEnd);\n    }\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n    const token_o = state.push('link_open', 'a', 1);\n    const attrs = [['href', href]];\n    token_o.attrs = attrs;\n    if (title) {\n      attrs.push(['title', title]);\n    }\n    state.linkLevel++;\n    state.md.inline.tokenize(state);\n    state.linkLevel--;\n    state.push('link_close', 'a', -1);\n  }\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// Process ![image](<src> \"title\")\n\nfunction image(state, silent) {\n  let code, content, label, pos, ref, res, title, start;\n  let href = '';\n  const oldPos = state.pos;\n  const max = state.posMax;\n  if (state.src.charCodeAt(state.pos) !== 0x21 /* ! */) {\n    return false;\n  }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B /* [ */) {\n    return false;\n  }\n  const labelStart = state.pos + 2;\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) {\n    return false;\n  }\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28 /* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    }\n    if (pos >= max) {\n      return false;\n    }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) {\n          break;\n        }\n      }\n    } else {\n      title = '';\n    }\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29 /* ) */) {\n      state.pos = oldPos;\n      return false;\n    }\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') {\n      return false;\n    }\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B /* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) {\n      label = state.src.slice(labelStart, labelEnd);\n    }\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd);\n    const tokens = [];\n    state.md.inline.parse(content, state.md, state.env, tokens);\n    const token = state.push('image', 'img', 0);\n    const attrs = [['src', href], ['alt', '']];\n    token.attrs = attrs;\n    token.children = tokens;\n    token.content = content;\n    if (title) {\n      attrs.push(['title', title]);\n    }\n  }\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// Process autolinks '<protocol:...>'\n\n/* eslint max-len:0 */\nconst EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;\n/* eslint-disable-next-line no-control-regex */\nconst AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\\x00-\\x20]*)$/;\nfunction autolink(state, silent) {\n  let pos = state.pos;\n  if (state.src.charCodeAt(pos) !== 0x3C /* < */) {\n    return false;\n  }\n  const start = state.pos;\n  const max = state.posMax;\n  for (;;) {\n    if (++pos >= max) return false;\n    const ch = state.src.charCodeAt(pos);\n    if (ch === 0x3C /* < */) return false;\n    if (ch === 0x3E /* > */) break;\n  }\n  const url = state.src.slice(start + 1, pos);\n  if (AUTOLINK_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink(url);\n    if (!state.md.validateLink(fullUrl)) {\n      return false;\n    }\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1);\n      token_o.attrs = [['href', fullUrl]];\n      token_o.markup = 'autolink';\n      token_o.info = 'auto';\n      const token_t = state.push('text', '', 0);\n      token_t.content = state.md.normalizeLinkText(url);\n      const token_c = state.push('link_close', 'a', -1);\n      token_c.markup = 'autolink';\n      token_c.info = 'auto';\n    }\n    state.pos += url.length + 2;\n    return true;\n  }\n  if (EMAIL_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink('mailto:' + url);\n    if (!state.md.validateLink(fullUrl)) {\n      return false;\n    }\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1);\n      token_o.attrs = [['href', fullUrl]];\n      token_o.markup = 'autolink';\n      token_o.info = 'auto';\n      const token_t = state.push('text', '', 0);\n      token_t.content = state.md.normalizeLinkText(url);\n      const token_c = state.push('link_close', 'a', -1);\n      token_c.markup = 'autolink';\n      token_c.info = 'auto';\n    }\n    state.pos += url.length + 2;\n    return true;\n  }\n  return false;\n}\n\n// Process html tags\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\nfunction isLetter(ch) {\n  /* eslint no-bitwise:0 */\n  const lc = ch | 0x20; // to lower case\n  return lc >= 0x61 /* a */ && lc <= 0x7a /* z */;\n}\nfunction html_inline(state, silent) {\n  if (!state.md.options.html) {\n    return false;\n  }\n\n  // Check start\n  const max = state.posMax;\n  const pos = state.pos;\n  if (state.src.charCodeAt(pos) !== 0x3C /* < */ || pos + 2 >= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  const ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21 /* ! */ && ch !== 0x3F /* ? */ && ch !== 0x2F /* / */ && !isLetter(ch)) {\n    return false;\n  }\n  const match = state.src.slice(pos).match(HTML_TAG_RE);\n  if (!match) {\n    return false;\n  }\n  if (!silent) {\n    const token = state.push('html_inline', '', 0);\n    token.content = match[0];\n    if (isLinkOpen(token.content)) state.linkLevel++;\n    if (isLinkClose(token.content)) state.linkLevel--;\n  }\n  state.pos += match[0].length;\n  return true;\n}\n\n// Process html entity - &#123;, &#xAF;, &quot;, ...\n\nconst DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nconst NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;\nfunction entity(state, silent) {\n  const pos = state.pos;\n  const max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x26 /* & */) return false;\n  if (pos + 1 >= max) return false;\n  const ch = state.src.charCodeAt(pos + 1);\n  if (ch === 0x23 /* # */) {\n    const match = state.src.slice(pos).match(DIGITAL_RE);\n    if (match) {\n      if (!silent) {\n        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n        const token = state.push('text_special', '', 0);\n        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n        token.markup = match[0];\n        token.info = 'entity';\n      }\n      state.pos += match[0].length;\n      return true;\n    }\n  } else {\n    const match = state.src.slice(pos).match(NAMED_RE);\n    if (match) {\n      const decoded = entities.decodeHTML(match[0]);\n      if (decoded !== match[0]) {\n        if (!silent) {\n          const token = state.push('text_special', '', 0);\n          token.content = decoded;\n          token.markup = match[0];\n          token.info = 'entity';\n        }\n        state.pos += match[0].length;\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n// For each opening emphasis-like marker find a matching closing one\n//\n\nfunction processDelimiters(delimiters) {\n  const openersBottom = {};\n  const max = delimiters.length;\n  if (!max) return;\n\n  // headerIdx is the first delimiter of the current (where closer is) delimiter run\n  let headerIdx = 0;\n  let lastTokenIdx = -2; // needs any value lower than -1\n  const jumps = [];\n  for (let closerIdx = 0; closerIdx < max; closerIdx++) {\n    const closer = delimiters[closerIdx];\n    jumps.push(0);\n\n    // markers belong to same delimiter run if:\n    //  - they have adjacent tokens\n    //  - AND markers are the same\n    //\n    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n      headerIdx = closerIdx;\n    }\n    lastTokenIdx = closer.token;\n\n    // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n    closer.length = closer.length || 0;\n    if (!closer.close) continue;\n\n    // Previously calculated lower bounds (previous fails)\n    // for each marker, each delimiter length modulo 3,\n    // and for whether this closer can be an opener;\n    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460\n    /* eslint-disable-next-line no-prototype-builtins */\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];\n    }\n    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];\n    let openerIdx = headerIdx - jumps[headerIdx] - 1;\n    let newMinOpenerIdx = openerIdx;\n    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      const opener = delimiters[openerIdx];\n      if (opener.marker !== closer.marker) continue;\n      if (opener.open && opener.end < 0) {\n        let isOddMatch = false;\n\n        // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n        if (opener.close || closer.open) {\n          if ((opener.length + closer.length) % 3 === 0) {\n            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true;\n            }\n          }\n        }\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;\n          jumps[closerIdx] = closerIdx - openerIdx + lastJump;\n          jumps[openerIdx] = lastJump;\n          closer.open = false;\n          opener.end = closerIdx;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          // treat next token as start of run,\n          // it optimizes skips in **<...>**a**<...>** pathological case\n          lastTokenIdx = -2;\n          break;\n        }\n      }\n    }\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;\n    }\n  }\n}\nfunction link_pairs(state) {\n  const tokens_meta = state.tokens_meta;\n  const max = state.tokens_meta.length;\n  processDelimiters(state.delimiters);\n  for (let curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      processDelimiters(tokens_meta[curr].delimiters);\n    }\n  }\n}\n\n// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n\nfunction fragments_join(state) {\n  let curr, last;\n  let level = 0;\n  const tokens = state.tokens;\n  const max = state.tokens.length;\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level--; // closing tag\n    tokens[curr].level = level;\n    if (tokens[curr].nesting > 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n    } else {\n      if (curr !== last) {\n        tokens[last] = tokens[curr];\n      }\n      last++;\n    }\n  }\n  if (curr !== last) {\n    tokens.length = last;\n  }\n}\n\n/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n\n\n// Parser rules\n\nconst _rules = [['text', text], ['linkify', linkify], ['newline', newline], ['escape', escape], ['backticks', backtick], ['strikethrough', r_strikethrough.tokenize], ['emphasis', r_emphasis.tokenize], ['link', link], ['image', image], ['autolink', autolink], ['html_inline', html_inline], ['entity', entity]];\n\n// `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\nconst _rules2 = [['balance_pairs', link_pairs], ['strikethrough', r_strikethrough.postProcess], ['emphasis', r_emphasis.postProcess],\n// rules for pairs separate '**' into its own text tokens, which may be left unused,\n// rule below merges unused segments back with the rest of the text\n['fragments_join', fragments_join]];\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n  for (let i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  const pos = state.pos;\n  const rules = this.ruler.getRules('');\n  const len = rules.length;\n  const maxNesting = state.md.options.maxNesting;\n  const cache = state.cache;\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n  let ok = false;\n  if (state.level < maxNesting) {\n    for (let i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++;\n      ok = rules[i](state, true);\n      state.level--;\n      if (ok) {\n        if (pos >= state.pos) {\n          throw new Error(\"inline rule didn't increment state.pos\");\n        }\n        break;\n      }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax;\n  }\n  if (!ok) {\n    state.pos++;\n  }\n  cache[pos] = state.pos;\n};\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  const rules = this.ruler.getRules('');\n  const len = rules.length;\n  const end = state.posMax;\n  const maxNesting = state.md.options.maxNesting;\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    const prevPos = state.pos;\n    let ok = false;\n    if (state.level < maxNesting) {\n      for (let i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n        if (ok) {\n          if (prevPos >= state.pos) {\n            throw new Error(\"inline rule didn't increment state.pos\");\n          }\n          break;\n        }\n      }\n    }\n    if (ok) {\n      if (state.pos >= end) {\n        break;\n      }\n      continue;\n    }\n    state.pending += state.src[state.pos++];\n  }\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  const state = new this.State(str, md, env, outTokens);\n  this.tokenize(state);\n  const rules = this.ruler2.getRules('');\n  const len = rules.length;\n  for (let i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\nParserInline.prototype.State = StateInline;\n\n// markdown-it default options\n\nvar cfg_default = {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: false,\n    // Convert '\\n' in paragraphs into <br>\n    breaks: false,\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n    // autoconvert URL-like texts to links\n    linkify: false,\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019',\n    /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    // Internal protection, recursion limit\n    maxNesting: 100\n  },\n  components: {\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n\n// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\nvar cfg_zero = {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: false,\n    // Convert '\\n' in paragraphs into <br>\n    breaks: false,\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n    // autoconvert URL-like texts to links\n    linkify: false,\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019',\n    /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    // Internal protection, recursion limit\n    maxNesting: 20\n  },\n  components: {\n    core: {\n      rules: ['normalize', 'block', 'inline', 'text_join']\n    },\n    block: {\n      rules: ['paragraph']\n    },\n    inline: {\n      rules: ['text'],\n      rules2: ['balance_pairs', 'fragments_join']\n    }\n  }\n};\n\n// Commonmark default options\n\nvar cfg_commonmark = {\n  options: {\n    // Enable HTML tags in source\n    html: true,\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: true,\n    // Convert '\\n' in paragraphs into <br>\n    breaks: false,\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n    // autoconvert URL-like texts to links\n    linkify: false,\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019',\n    /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    // Internal protection, recursion limit\n    maxNesting: 20\n  },\n  components: {\n    core: {\n      rules: ['normalize', 'block', 'inline', 'text_join']\n    },\n    block: {\n      rules: ['blockquote', 'code', 'fence', 'heading', 'hr', 'html_block', 'lheading', 'list', 'reference', 'paragraph']\n    },\n    inline: {\n      rules: ['autolink', 'backticks', 'emphasis', 'entity', 'escape', 'html_inline', 'image', 'link', 'newline', 'text'],\n      rules2: ['balance_pairs', 'emphasis', 'fragments_join']\n    }\n  }\n};\n\n// Main parser class\n\nconst config = {\n  default: cfg_default,\n  zero: cfg_zero,\n  commonmark: cfg_commonmark\n};\n\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nconst BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;\nconst GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/;\nfunction validateLink(url) {\n  // url should be normalized at this point, and existing entities are decoded\n  const str = url.trim().toLowerCase();\n  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;\n}\nconst RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:'];\nfunction normalizeLink(url) {\n  const parsed = mdurl__namespace.parse(url, true);\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname);\n      } catch (er) {/**/}\n    }\n  }\n  return mdurl__namespace.encode(mdurl__namespace.format(parsed));\n}\nfunction normalizeLinkText(url) {\n  const parsed = mdurl__namespace.parse(url, true);\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname);\n      } catch (er) {/**/}\n    }\n  }\n\n  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n  return mdurl__namespace.decode(mdurl__namespace.format(parsed), mdurl__namespace.decode.defaultChars + '%');\n}\n\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre><code class=\"hljs\">' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre><code class=\"hljs\">' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt(presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options);\n  }\n  if (!options) {\n    if (!isString(presetName)) {\n      options = presetName || {};\n      presetName = 'default';\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline();\n\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock();\n\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new Core();\n\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).\n   **/\n  this.renderer = new Renderer();\n\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt();\n\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink;\n\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink;\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText;\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).\n   **/\n  this.utils = utils;\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = assign({}, helpers);\n  this.options = {};\n  this.configure(presetName);\n  if (options) {\n    this.set(options);\n  }\n}\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n  assign(this.options, options);\n  return this;\n};\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you will - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n  const self = this;\n  if (isString(presets)) {\n    const presetName = presets;\n    presets = config[presetName];\n    if (!presets) {\n      throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name');\n    }\n  }\n  if (!presets) {\n    throw new Error('Wrong `markdown-it` preset, can\\'t be empty');\n  }\n  if (presets.options) {\n    self.set(presets.options);\n  }\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules);\n      }\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2);\n      }\n    });\n  }\n  return this;\n};\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  let result = [];\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true));\n  }, this);\n  result = result.concat(this.inline.ruler2.enable(list, true));\n  const missed = list.filter(function (name) {\n    return result.indexOf(name) < 0;\n  });\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n  return this;\n};\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  let result = [];\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true));\n  }, this);\n  result = result.concat(this.inline.ruler2.disable(list, true));\n  const missed = list.filter(function (name) {\n    return result.indexOf(name) < 0;\n  });\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);\n  }\n  return this;\n};\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  const args = [this].concat(Array.prototype.slice.call(arguments, 1));\n  plugin.apply(plugin, args);\n  return this;\n};\n\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and return list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String');\n  }\n  const state = new this.core.State(src, this, env);\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {};\n  return this.renderer.render(this.parse(src, env), this.options, env);\n};\n\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  const state = new this.core.State(src, this, env);\n  state.inlineMode = true;\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {};\n  return this.renderer.render(this.parseInline(src, env), this.options, env);\n};\n\nmodule.exports = MarkdownIt;\n\n\n/***/ }),\n\n/***/ 5778:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n\n/* eslint-disable no-bitwise */\n\nconst decodeCache = {};\n\nfunction getDecodeCache (exclude) {\n  let cache = decodeCache[exclude];\n  if (cache) { return cache }\n\n  cache = decodeCache[exclude] = [];\n\n  for (let i = 0; i < 128; i++) {\n    const ch = String.fromCharCode(i);\n    cache.push(ch);\n  }\n\n  for (let i = 0; i < exclude.length; i++) {\n    const ch = exclude.charCodeAt(i);\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);\n  }\n\n  return cache\n}\n\n// Decode percent-encoded string.\n//\nfunction decode (string, exclude) {\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars;\n  }\n\n  const cache = getDecodeCache(exclude);\n\n  return string.replace(/(%[a-f0-9]{2})+/gi, function (seq) {\n    let result = '';\n\n    for (let i = 0, l = seq.length; i < l; i += 3) {\n      const b1 = parseInt(seq.slice(i + 1, i + 3), 16);\n\n      if (b1 < 0x80) {\n        result += cache[b1];\n        continue\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {\n        // 110xxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n\n        if ((b2 & 0xC0) === 0x80) {\n          const chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);\n\n          if (chr < 0x80) {\n            result += '\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 3;\n          continue\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          const chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);\n\n          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {\n            result += '\\ufffd\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 6;\n          continue\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n        const b4 = parseInt(seq.slice(i + 10, i + 12), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          let chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += '\\ufffd\\ufffd\\ufffd\\ufffd';\n          } else {\n            chr -= 0x10000;\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));\n          }\n\n          i += 9;\n          continue\n        }\n      }\n\n      result += '\\ufffd';\n    }\n\n    return result\n  })\n}\n\ndecode.defaultChars = ';/?:@&=+$,#';\ndecode.componentChars = '';\n\nconst encodeCache = {};\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache (exclude) {\n  let cache = encodeCache[exclude];\n  if (cache) { return cache }\n\n  cache = encodeCache[exclude] = [];\n\n  for (let i = 0; i < 128; i++) {\n    const ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (let i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache\n}\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode (string, exclude, keepEscaped) {\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  const cache = getEncodeCache(exclude);\n  let result = '';\n\n  for (let i = 0, l = string.length; i < l; i++) {\n    const code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        const nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue\n        }\n      }\n      result += '%EF%BF%BD';\n      continue\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result\n}\n\nencode.defaultChars = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\nfunction format (url) {\n  let result = '';\n\n  result += url.protocol || '';\n  result += url.slashes ? '//' : '';\n  result += url.auth ? url.auth + '@' : '';\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']';\n  } else {\n    result += url.hostname || '';\n  }\n\n  result += url.port ? ':' + url.port : '';\n  result += url.pathname || '';\n  result += url.search || '';\n  result += url.hash || '';\n\n  return result\n}\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n//\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\nfunction Url () {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.pathname = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nconst protocolPattern = /^([a-z0-9.+-]+:)/i;\nconst portPattern = /:[0-9]*$/;\n\n// Special case for a simple path URL\n/* eslint-disable-next-line no-useless-escape */\nconst simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/;\n\n// RFC 2396: characters reserved for delimiting URLs.\n// We actually just auto-escape these.\nconst delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'];\n\n// RFC 2396: characters not allowed for various reasons.\nconst unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims);\n\n// Allowed by RFCs, but cause of XSS attacks.  Always escape these.\nconst autoEscape = ['\\''].concat(unwise);\n// Characters that are never ever allowed in a hostname.\n// Note that any invalid chars are also handled, but these\n// are the ones that are *expected* to be seen, so we fast-path\n// them.\nconst nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape);\nconst hostEndingChars = ['/', '?', '#'];\nconst hostnameMaxLen = 255;\nconst hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;\nconst hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;\n// protocols that can allow \"unsafe\" and \"unwise\" chars.\n// protocols that never have a hostname.\nconst hostlessProtocol = {\n  javascript: true,\n  'javascript:': true\n};\n// protocols that always contain a // bit.\nconst slashedProtocol = {\n  http: true,\n  https: true,\n  ftp: true,\n  gopher: true,\n  file: true,\n  'http:': true,\n  'https:': true,\n  'ftp:': true,\n  'gopher:': true,\n  'file:': true\n};\n\nfunction urlParse (url, slashesDenoteHost) {\n  if (url && url instanceof Url) return url\n\n  const u = new Url();\n  u.parse(url, slashesDenoteHost);\n  return u\n}\n\nUrl.prototype.parse = function (url, slashesDenoteHost) {\n  let lowerProto, hec, slashes;\n  let rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    const simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n      }\n      return this\n    }\n  }\n\n  let proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    lowerProto = proto.toLowerCase();\n    this.protocol = proto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  /* eslint-disable-next-line no-useless-escape */\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    let hostEnd = -1;\n    for (let i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    let auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = auth;\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (let i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) {\n      hostEnd = rest.length;\n    }\n\n    if (rest[hostEnd - 1] === ':') { hostEnd--; }\n    const host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost(host);\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    const ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      const hostparts = this.hostname.split(/\\./);\n      for (let i = 0, l = hostparts.length; i < l; i++) {\n        const part = hostparts[i];\n        if (!part) { continue }\n        if (!part.match(hostnamePartPattern)) {\n          let newpart = '';\n          for (let j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            const validParts = hostparts.slice(0, i);\n            const notHost = hostparts.slice(i + 1);\n            const bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    }\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n    }\n  }\n\n  // chop off from the tail first.\n  const hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  const qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    rest = rest.slice(0, qm);\n  }\n  if (rest) { this.pathname = rest; }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '';\n  }\n\n  return this\n};\n\nUrl.prototype.parseHost = function (host) {\n  let port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) { this.hostname = host; }\n};\n\nexports.decode = decode;\nexports.encode = encode;\nexports.format = format;\nexports.parse = urlParse;\n\n\n/***/ }),\n\n/***/ 6878:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar aggregator_exports = {};\n__export(aggregator_exports, {\n  Aggregator: () => Aggregator\n});\nmodule.exports = __toCommonJS(aggregator_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nclass Aggregator {\n  #pipeline;\n  #options;\n  constructor(pipeline, options) {\n    this.#pipeline = pipeline;\n    this.#options = (0, import_core.initOptions)(options);\n  }\n  /**\n   * Returns an {@link Iterator} for lazy evaluation of the pipeline.\n   *\n   * @param {*} collection An array or iterator object\n   * @returns {Iterator} an iterator object\n   */\n  stream(collection, options) {\n    let iterator = (0, import_lazy.Lazy)(collection);\n    const opts = options ?? this.#options;\n    const mode = opts.processingMode;\n    if (mode == import_core.ProcessingMode.CLONE_ALL || mode == import_core.ProcessingMode.CLONE_INPUT) {\n      iterator.map(import_util.cloneDeep);\n    }\n    const stages = new Array();\n    if (!(0, import_util.isEmpty)(this.#pipeline)) {\n      for (const operator of this.#pipeline) {\n        const operatorKeys = Object.keys(operator);\n        const opName = operatorKeys[0];\n        const call = (0, import_core.getOperator)(\"pipeline\", opName, opts);\n        (0, import_util.assert)(\n          operatorKeys.length === 1 && !!call,\n          `invalid pipeline operator ${opName}`\n        );\n        stages.push(opName);\n        iterator = call(iterator, operator[opName], opts);\n      }\n    }\n    if (mode == import_core.ProcessingMode.CLONE_OUTPUT || mode == import_core.ProcessingMode.CLONE_ALL && !!(0, import_util.intersection)([[\"$group\", \"$unwind\"], stages]).length) {\n      iterator.map(import_util.cloneDeep);\n    }\n    return iterator;\n  }\n  /**\n   * Return the results of the aggregation as an array.\n   *\n   * @param collection\n   */\n  run(collection, options) {\n    return this.stream(collection, options).value();\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2760:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar core_exports = {};\n__export(core_exports, {\n  ComputeOptions: () => ComputeOptions,\n  Context: () => Context,\n  OperatorType: () => OperatorType,\n  ProcessingMode: () => ProcessingMode,\n  computeValue: () => computeValue,\n  getOperator: () => getOperator,\n  initOptions: () => initOptions,\n  redact: () => redact,\n  useOperators: () => useOperators\n});\nmodule.exports = __toCommonJS(core_exports);\nvar import_util = __webpack_require__(7839);\nvar ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {\n  ProcessingMode2[\"CLONE_ALL\"] = \"CLONE_ALL\";\n  ProcessingMode2[\"CLONE_INPUT\"] = \"CLONE_INPUT\";\n  ProcessingMode2[\"CLONE_OUTPUT\"] = \"CLONE_OUTPUT\";\n  ProcessingMode2[\"CLONE_OFF\"] = \"CLONE_OFF\";\n  return ProcessingMode2;\n})(ProcessingMode || {});\nclass ComputeOptions {\n  #options;\n  /** Reference to the root object when processing subgraphs of the object. */\n  #root;\n  #local;\n  constructor(options, root, local) {\n    this.#options = options;\n    this.update(root, local);\n  }\n  /**\n   * Initialize new ComputeOptions.\n   *\n   * @param options\n   * @param root\n   * @param local\n   * @returns {ComputeOptions}\n   */\n  static init(options, root, local) {\n    return options instanceof ComputeOptions ? new ComputeOptions(options.#options, options.root ?? root, {\n      ...options.#local,\n      ...local,\n      // retain existing variables\n      variables: Object.assign(\n        {},\n        options.#local?.variables,\n        local?.variables\n      )\n    }) : new ComputeOptions(options, root, local);\n  }\n  /**\n   * Updates the internal state.\n   *\n   * @param root The new root context for this object.\n   * @param local The new local state to merge into current if it exists.\n   * @returns\n   */\n  update(root, local) {\n    this.#root = root;\n    const variables = Object.assign(\n      {},\n      this.#local?.variables,\n      local?.variables\n    );\n    if (Object.keys(variables).length) {\n      this.#local = { ...local, variables };\n    } else {\n      this.#local = local ?? {};\n    }\n    return this;\n  }\n  getOptions() {\n    return Object.freeze({\n      ...this.#options,\n      context: Context.from(this.#options.context)\n    });\n  }\n  get root() {\n    return this.#root;\n  }\n  get local() {\n    return this.#local;\n  }\n  get idKey() {\n    return this.#options.idKey;\n  }\n  get collation() {\n    return this.#options?.collation;\n  }\n  get processingMode() {\n    return this.#options?.processingMode || \"CLONE_OFF\" /* CLONE_OFF */;\n  }\n  get useStrictMode() {\n    return this.#options?.useStrictMode;\n  }\n  get scriptEnabled() {\n    return this.#options?.scriptEnabled;\n  }\n  get useGlobalContext() {\n    return this.#options?.useGlobalContext;\n  }\n  get hashFunction() {\n    return this.#options?.hashFunction;\n  }\n  get collectionResolver() {\n    return this.#options?.collectionResolver;\n  }\n  get jsonSchemaValidator() {\n    return this.#options?.jsonSchemaValidator;\n  }\n  get variables() {\n    return this.#options?.variables;\n  }\n  get context() {\n    return this.#options?.context;\n  }\n}\nfunction initOptions(options) {\n  return options instanceof ComputeOptions ? options.getOptions() : Object.freeze({\n    idKey: \"_id\",\n    scriptEnabled: true,\n    useStrictMode: true,\n    useGlobalContext: true,\n    processingMode: \"CLONE_OFF\" /* CLONE_OFF */,\n    ...options,\n    context: options?.context ? Context.from(options?.context) : Context.init()\n  });\n}\nvar OperatorType = /* @__PURE__ */ ((OperatorType2) => {\n  OperatorType2[\"ACCUMULATOR\"] = \"accumulator\";\n  OperatorType2[\"EXPRESSION\"] = \"expression\";\n  OperatorType2[\"PIPELINE\"] = \"pipeline\";\n  OperatorType2[\"PROJECTION\"] = \"projection\";\n  OperatorType2[\"QUERY\"] = \"query\";\n  OperatorType2[\"WINDOW\"] = \"window\";\n  return OperatorType2;\n})(OperatorType || {});\nclass Context {\n  #operators = /* @__PURE__ */ new Map();\n  constructor() {\n  }\n  static init() {\n    return new Context();\n  }\n  static from(ctx) {\n    const instance = Context.init();\n    if ((0, import_util.isNil)(ctx)) return instance;\n    ctx.#operators.forEach((v, k) => instance.addOperators(k, v));\n    return instance;\n  }\n  addOperators(type, operators) {\n    if (!this.#operators.has(type)) this.#operators.set(type, {});\n    for (const [name, fn] of Object.entries(operators)) {\n      if (!this.getOperator(type, name)) {\n        this.#operators.get(type)[name] = fn;\n      }\n    }\n    return this;\n  }\n  getOperator(type, name) {\n    const ops = this.#operators.get(type) ?? {};\n    return ops[name] ?? null;\n  }\n  addAccumulatorOps(ops) {\n    return this.addOperators(\"accumulator\", ops);\n  }\n  addExpressionOps(ops) {\n    return this.addOperators(\"expression\", ops);\n  }\n  addQueryOps(ops) {\n    return this.addOperators(\"query\", ops);\n  }\n  addPipelineOps(ops) {\n    return this.addOperators(\"pipeline\", ops);\n  }\n  addProjectionOps(ops) {\n    return this.addOperators(\"projection\", ops);\n  }\n  addWindowOps(ops) {\n    return this.addOperators(\"window\", ops);\n  }\n}\nconst GLOBAL_CONTEXT = Context.init();\nfunction useOperators(type, operators) {\n  for (const [name, fn] of Object.entries(operators)) {\n    (0, import_util.assert)(\n      (0, import_util.isFunction)(fn) && (0, import_util.isOperator)(name),\n      `'${name}' is not a valid operator`\n    );\n    const currentFn = getOperator(type, name, null);\n    (0, import_util.assert)(\n      !currentFn || fn === currentFn,\n      `${name} already exists for '${type}' operators. Cannot change operator function once registered.`\n    );\n  }\n  switch (type) {\n    case \"accumulator\":\n      GLOBAL_CONTEXT.addAccumulatorOps(operators);\n      break;\n    case \"expression\":\n      GLOBAL_CONTEXT.addExpressionOps(operators);\n      break;\n    case \"pipeline\":\n      GLOBAL_CONTEXT.addPipelineOps(operators);\n      break;\n    case \"projection\":\n      GLOBAL_CONTEXT.addProjectionOps(operators);\n      break;\n    case \"query\":\n      GLOBAL_CONTEXT.addQueryOps(operators);\n      break;\n    case \"window\":\n      GLOBAL_CONTEXT.addWindowOps(operators);\n      break;\n  }\n}\nfunction getOperator(type, name, options) {\n  const { context: ctx, useGlobalContext: fallback } = options || {};\n  const fn = ctx ? ctx.getOperator(type, name) : null;\n  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, name) : fn;\n}\nfunction computeValue(obj, expr, operator, options) {\n  const copts = ComputeOptions.init(options, obj);\n  return !!operator && (0, import_util.isOperator)(operator) ? computeOperator(obj, expr, operator, copts) : computeExpression(obj, expr, copts);\n}\nconst SYSTEM_VARS = [\"$$ROOT\", \"$$CURRENT\", \"$$REMOVE\", \"$$NOW\"];\nfunction computeExpression(obj, expr, options) {\n  if ((0, import_util.isString)(expr) && expr.length > 0 && expr[0] === \"$\") {\n    if (REDACT_ACTIONS.includes(expr)) return expr;\n    let ctx = options.root;\n    const arr = expr.split(\".\");\n    if (SYSTEM_VARS.includes(arr[0])) {\n      switch (arr[0]) {\n        case \"$$ROOT\":\n          break;\n        case \"$$CURRENT\":\n          ctx = obj;\n          break;\n        case \"$$REMOVE\":\n          ctx = void 0;\n          break;\n        case \"$$NOW\":\n          ctx = /* @__PURE__ */ new Date();\n          break;\n      }\n      expr = expr.slice(arr[0].length + 1);\n    } else if (arr[0].slice(0, 2) === \"$$\") {\n      ctx = Object.assign(\n        {},\n        // global vars\n        options.variables,\n        // current item is added before local variables because the binding may be changed.\n        { this: obj },\n        // local vars\n        options?.local?.variables\n      );\n      const name = arr[0].slice(2);\n      (0, import_util.assert)((0, import_util.has)(ctx, name), `Use of undefined variable: ${name}`);\n      expr = expr.slice(2);\n    } else {\n      expr = expr.slice(1);\n    }\n    return expr === \"\" ? ctx : (0, import_util.resolve)(ctx, expr);\n  }\n  if ((0, import_util.isArray)(expr)) {\n    return expr.map((item) => computeExpression(obj, item, options));\n  }\n  if ((0, import_util.isObject)(expr)) {\n    const result = {};\n    const elems = Object.entries(expr);\n    for (const [key, val] of elems) {\n      if ((0, import_util.isOperator)(key)) {\n        (0, import_util.assert)(elems.length == 1, \"expression must have single operator.\");\n        return computeOperator(obj, val, key, options);\n      }\n      result[key] = computeExpression(obj, val, options);\n    }\n    return result;\n  }\n  return expr;\n}\nfunction computeOperator(obj, expr, operator, options) {\n  const callExpression = getOperator(\n    \"expression\",\n    operator,\n    options\n  );\n  if (callExpression) return callExpression(obj, expr, options);\n  const callAccumulator = getOperator(\n    \"accumulator\",\n    operator,\n    options\n  );\n  (0, import_util.assert)(!!callAccumulator, `accumulator '${operator}' is not registered.`);\n  if (!(0, import_util.isArray)(obj)) {\n    obj = computeExpression(obj, expr, options);\n    expr = null;\n  }\n  (0, import_util.assert)((0, import_util.isArray)(obj), `arguments must resolve to array for ${operator}.`);\n  return callAccumulator(\n    obj,\n    expr,\n    options.update(null, options.local)\n    // reset the root object.\n  );\n}\nconst REDACT_ACTIONS = [\"$$KEEP\", \"$$PRUNE\", \"$$DESCEND\"];\nfunction redact(obj, expr, options) {\n  const action = computeValue(obj, expr, null, options);\n  switch (action) {\n    case \"$$KEEP\":\n      return obj;\n    case \"$$PRUNE\":\n      return void 0;\n    case \"$$DESCEND\": {\n      if (!(0, import_util.has)(expr, \"$cond\")) return obj;\n      const output = {};\n      for (const [key, value] of Object.entries(obj)) {\n        if ((0, import_util.isArray)(value)) {\n          const res = new Array();\n          for (let elem of value) {\n            if ((0, import_util.isObject)(elem)) {\n              elem = redact(elem, expr, options.update(elem));\n            }\n            if (!(0, import_util.isNil)(elem)) res.push(elem);\n          }\n          output[key] = res;\n        } else if ((0, import_util.isObject)(value)) {\n          const res = redact(\n            value,\n            expr,\n            options.update(value)\n          );\n          if (!(0, import_util.isNil)(res)) output[key] = res;\n        } else {\n          output[key] = value;\n        }\n      }\n      return output;\n    }\n    default:\n      return action;\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4529:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar cursor_exports = {};\n__export(cursor_exports, {\n  Cursor: () => Cursor\n});\nmodule.exports = __toCommonJS(cursor_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nclass Cursor {\n  #source;\n  #predicate;\n  #projection;\n  #options;\n  #operators = [];\n  #result = null;\n  #buffer = [];\n  constructor(source, predicate, projection, options) {\n    this.#source = source;\n    this.#predicate = predicate;\n    this.#projection = projection;\n    this.#options = options;\n  }\n  /** Returns the iterator from running the query */\n  fetch() {\n    if (this.#result) return this.#result;\n    if ((0, import_util.isObject)(this.#projection)) {\n      this.#operators.push({ $project: this.#projection });\n    }\n    this.#result = (0, import_lazy.Lazy)(this.#source).filter(this.#predicate);\n    if (this.#operators.length > 0) {\n      this.#result = new import_aggregator.Aggregator(this.#operators, this.#options).stream(\n        this.#result\n      );\n    }\n    return this.#result;\n  }\n  /** Returns an iterator with the buffered data included */\n  fetchAll() {\n    const buffered = (0, import_lazy.Lazy)([...this.#buffer]);\n    this.#buffer = [];\n    return (0, import_lazy.concat)(buffered, this.fetch());\n  }\n  /**\n   * Return remaining objects in the cursor as an array. This method exhausts the cursor\n   * @returns {Array}\n   */\n  all() {\n    return this.fetchAll().value();\n  }\n  /**\n   * Returns the number of objects return in the cursor. This method exhausts the cursor\n   * @returns {Number}\n   */\n  count() {\n    return this.all().length;\n  }\n  /**\n   * Returns a cursor that begins returning results only after passing or skipping a number of documents.\n   * @param {Number} n the number of results to skip.\n   * @return {Cursor} Returns the cursor, so you can chain this call.\n   */\n  skip(n) {\n    this.#operators.push({ $skip: n });\n    return this;\n  }\n  /**\n   * Constrains the size of a cursor's result set.\n   * @param {Number} n the number of results to limit to.\n   * @return {Cursor} Returns the cursor, so you can chain this call.\n   */\n  limit(n) {\n    this.#operators.push({ $limit: n });\n    return this;\n  }\n  /**\n   * Returns results ordered according to a sort specification.\n   * @param {AnyObject} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending\n   * @return {Cursor} Returns the cursor, so you can chain this call.\n   */\n  sort(modifier) {\n    this.#operators.push({ $sort: modifier });\n    return this;\n  }\n  /**\n   * Specifies the collation for the cursor returned by the `mingo.Query.find`\n   * @param {*} spec\n   */\n  collation(spec) {\n    this.#options = { ...this.#options, collation: spec };\n    return this;\n  }\n  /**\n   * Returns the next document in a cursor.\n   * @returns {AnyObject | Boolean}\n   */\n  next() {\n    if (this.#buffer.length > 0) {\n      return this.#buffer.pop();\n    }\n    const o = this.fetch().next();\n    if (o.done) return;\n    return o.value;\n  }\n  /**\n   * Returns true if the cursor has documents and can be iterated.\n   * @returns {boolean}\n   */\n  hasNext() {\n    if (this.#buffer.length > 0) return true;\n    const o = this.fetch().next();\n    if (o.done) return false;\n    this.#buffer.push(o.value);\n    return true;\n  }\n  /**\n   * Applies a function to each document in a cursor and collects the return values in an array.\n   * @param fn\n   * @returns {Array}\n   */\n  map(fn) {\n    return this.all().map(fn);\n  }\n  /**\n   * Applies a JavaScript function for every document in a cursor.\n   * @param fn\n   */\n  forEach(fn) {\n    this.all().forEach(fn);\n  }\n  [Symbol.iterator]() {\n    return this.fetchAll();\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8543:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar src_exports = {};\n__export(src_exports, {\n  Aggregator: () => import_aggregator2.Aggregator,\n  Query: () => import_query2.Query,\n  aggregate: () => aggregate,\n  createUpdater: () => import_updater2.createUpdater,\n  default: () => src_default,\n  find: () => find,\n  remove: () => remove,\n  update: () => import_updater2.update\n});\nmodule.exports = __toCommonJS(src_exports);\nvar import_basic = __webpack_require__(5864);\nvar import_aggregator = __webpack_require__(6878);\nvar import_query = __webpack_require__(6535);\nvar import_updater = __webpack_require__(3550);\nvar import_aggregator2 = __webpack_require__(6878);\nvar import_query2 = __webpack_require__(6535);\nvar import_updater2 = __webpack_require__(3550);\nfunction find(collection, criteria, projection, options) {\n  return new import_query.Query(criteria, options).find(collection, projection);\n}\nfunction remove(collection, criteria, options) {\n  return new import_query.Query(criteria, options).remove(collection);\n}\nfunction aggregate(collection, pipeline, options) {\n  return new import_aggregator.Aggregator(pipeline, options).run(collection);\n}\nvar src_default = {\n  Aggregator: import_aggregator.Aggregator,\n  Query: import_query.Query,\n  aggregate,\n  createUpdater: import_updater.createUpdater,\n  find,\n  remove,\n  update: import_updater.update\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5864:\n/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\nvar import_core = __webpack_require__(2760);\nvar booleanOperators = __toESM(__webpack_require__(1703));\nvar comparisonOperators = __toESM(__webpack_require__(3336));\nvar import_pipeline = __webpack_require__(6936);\nvar projectionOperators = __toESM(__webpack_require__(4487));\nvar queryOperators = __toESM(__webpack_require__(8510));\n(0, import_core.useOperators)(\"expression\", {\n  ...booleanOperators,\n  ...comparisonOperators\n});\n(0, import_core.useOperators)(\"pipeline\", {\n  $project: import_pipeline.$project,\n  $skip: import_pipeline.$skip,\n  $limit: import_pipeline.$limit,\n  $sort: import_pipeline.$sort\n});\n(0, import_core.useOperators)(\"projection\", projectionOperators);\n(0, import_core.useOperators)(\"query\", queryOperators);\n\n\n/***/ }),\n\n/***/ 8625:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lazy_exports = {};\n__export(lazy_exports, {\n  Iterator: () => Iterator,\n  Lazy: () => Lazy,\n  concat: () => concat\n});\nmodule.exports = __toCommonJS(lazy_exports);\nvar import_util = __webpack_require__(7839);\nfunction Lazy(source) {\n  return source instanceof Iterator ? source : new Iterator(source);\n}\nfunction concat(...iterators) {\n  let index = 0;\n  return Lazy(() => {\n    while (index < iterators.length) {\n      const o = iterators[index].next();\n      if (!o.done) return o;\n      index++;\n    }\n    return { done: true };\n  });\n}\nfunction isGenerator(o) {\n  return !!o && typeof o === \"object\" && o?.next instanceof Function;\n}\nfunction dropItem(array, i) {\n  const rest = array.slice(i + 1);\n  array.splice(i);\n  Array.prototype.push.apply(array, rest);\n}\nconst DONE = new Error();\nvar Action = /* @__PURE__ */ ((Action2) => {\n  Action2[Action2[\"MAP\"] = 0] = \"MAP\";\n  Action2[Action2[\"FILTER\"] = 1] = \"FILTER\";\n  Action2[Action2[\"TAKE\"] = 2] = \"TAKE\";\n  Action2[Action2[\"DROP\"] = 3] = \"DROP\";\n  return Action2;\n})(Action || {});\nfunction createCallback(nextFn, iteratees, buffer) {\n  let done = false;\n  let index = -1;\n  let bufferIndex = 0;\n  return function(storeResult) {\n    try {\n      outer: while (!done) {\n        let o = nextFn();\n        index++;\n        let i = -1;\n        const size = iteratees.length;\n        let innerDone = false;\n        while (++i < size) {\n          const r = iteratees[i];\n          switch (r.action) {\n            case 0 /* MAP */:\n              o = r.func(o, index);\n              break;\n            case 1 /* FILTER */:\n              if (!r.func(o, index)) continue outer;\n              break;\n            case 2 /* TAKE */:\n              --r.count;\n              if (!r.count) innerDone = true;\n              break;\n            case 3 /* DROP */:\n              --r.count;\n              if (!r.count) dropItem(iteratees, i);\n              continue outer;\n            default:\n              break outer;\n          }\n        }\n        done = innerDone;\n        if (storeResult) {\n          buffer[bufferIndex++] = o;\n        } else {\n          return { value: o, done: false };\n        }\n      }\n    } catch (e) {\n      if (e !== DONE) throw e;\n    }\n    done = true;\n    return { done };\n  };\n}\nclass Iterator {\n  /**\n   * @param {*} source An iterable object or function.\n   *    Array - return one element per cycle\n   *    Object{next:Function} - call next() for the next value (this also handles generator functions)\n   *    Function - call to return the next value\n   * @param {Function} fn An optional transformation function\n   */\n  constructor(source) {\n    this.#iteratees = [];\n    this.#yieldedValues = [];\n    this.isDone = false;\n    let nextVal;\n    if (source instanceof Function) {\n      source = { next: source };\n    }\n    if (isGenerator(source)) {\n      const src = source;\n      nextVal = () => {\n        const o = src.next();\n        if (o.done) throw DONE;\n        return o.value;\n      };\n    } else if ((0, import_util.isArray)(source)) {\n      const data = source;\n      const size = data.length;\n      let index = 0;\n      nextVal = () => {\n        if (index < size) return data[index++];\n        throw DONE;\n      };\n    } else if (!(source instanceof Function)) {\n      throw new import_util.MingoError(\n        `Lazy must be initialized with an array, generator, or function.`\n      );\n    }\n    this.#getNext = createCallback(\n      nextVal,\n      this.#iteratees,\n      this.#yieldedValues\n    );\n  }\n  #iteratees;\n  #yieldedValues;\n  #getNext;\n  /**\n   * Add an iteratee to this lazy sequence\n   */\n  push(action, value) {\n    if (typeof value === \"function\") {\n      this.#iteratees.push({ action, func: value });\n    } else if (typeof value === \"number\") {\n      this.#iteratees.push({ action, count: value });\n    }\n    return this;\n  }\n  next() {\n    return this.#getNext();\n  }\n  // Iteratees methods\n  /**\n   * Transform each item in the sequence to a new value\n   * @param {Function} f\n   */\n  map(f) {\n    return this.push(0 /* MAP */, f);\n  }\n  /**\n   * Select only items matching the given predicate\n   * @param {Function} pred\n   */\n  filter(predicate) {\n    return this.push(1 /* FILTER */, predicate);\n  }\n  /**\n   * Take given numbe for values from sequence\n   * @param {Number} n A number greater than 0\n   */\n  take(n) {\n    return n > 0 ? this.push(2 /* TAKE */, n) : this;\n  }\n  /**\n   * Drop a number of values from the sequence\n   * @param {Number} n Number of items to drop greater than 0\n   */\n  drop(n) {\n    return n > 0 ? this.push(3 /* DROP */, n) : this;\n  }\n  // Transformations\n  /**\n   * Returns a new lazy object with results of the transformation\n   * The entire sequence is realized.\n   *\n   * @param {Callback<Source, Any[]>} fn Tranform function of type (Array) => (Any)\n   */\n  transform(fn) {\n    const self = this;\n    let iter;\n    return Lazy(() => {\n      if (!iter) {\n        iter = Lazy(fn(self.value()));\n      }\n      return iter.next();\n    });\n  }\n  // Terminal methods\n  /**\n   * Returns the fully realized values of the iterators.\n   * The return value will be an array unless `lazy.first()` was used.\n   * The realized values are cached for subsequent calls.\n   */\n  value() {\n    if (!this.isDone) {\n      this.isDone = this.#getNext(true).done;\n    }\n    return this.#yieldedValues;\n  }\n  /**\n   * Execute the funcion for each value. Will stop when an execution returns false.\n   * @param {Function} f\n   * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true\n   */\n  each(f) {\n    for (; ; ) {\n      const o = this.next();\n      if (o.done) break;\n      if (f(o.value) === false) return false;\n    }\n    return true;\n  }\n  /**\n   * Returns the reduction of sequence according the reducing function\n   *\n   * @param {*} f a reducing function\n   * @param {*} initialValue\n   */\n  reduce(f, initialValue) {\n    let o = this.next();\n    if (initialValue === void 0 && !o.done) {\n      initialValue = o.value;\n      o = this.next();\n    }\n    while (!o.done) {\n      initialValue = f(initialValue, o.value);\n      o = this.next();\n    }\n    return initialValue;\n  }\n  /**\n   * Returns the number of matched items in the sequence\n   */\n  size() {\n    return this.reduce(\n      (acc, _) => ++acc,\n      0\n    );\n  }\n  [Symbol.iterator]() {\n    return this;\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4330:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar predicates_exports = {};\n__export(predicates_exports, {\n  $all: () => $all,\n  $elemMatch: () => $elemMatch,\n  $eq: () => $eq,\n  $exists: () => $exists,\n  $gt: () => $gt,\n  $gte: () => $gte,\n  $in: () => $in,\n  $lt: () => $lt,\n  $lte: () => $lte,\n  $mod: () => $mod,\n  $ne: () => $ne,\n  $nin: () => $nin,\n  $regex: () => $regex,\n  $size: () => $size,\n  $type: () => $type,\n  createExpressionOperator: () => createExpressionOperator,\n  createQueryOperator: () => createQueryOperator\n});\nmodule.exports = __toCommonJS(predicates_exports);\nvar import_core = __webpack_require__(2760);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nfunction createQueryOperator(predicate) {\n  const f = (selector, value, options) => {\n    const opts = { unwrapArray: true };\n    const depth = Math.max(1, selector.split(\".\").length - 1);\n    return (obj) => {\n      const lhs = (0, import_util.resolve)(obj, selector, opts);\n      return predicate(lhs, value, { ...options, depth });\n    };\n  };\n  f.op = \"query\";\n  return f;\n}\nfunction createExpressionOperator(predicate) {\n  return (obj, expr, options) => {\n    const args = (0, import_core.computeValue)(obj, expr, null, options);\n    return predicate(...args);\n  };\n}\nfunction $eq(a, b, options) {\n  if ((0, import_util.isEqual)(a, b)) return true;\n  if ((0, import_util.isNil)(a) && (0, import_util.isNil)(b)) return true;\n  if ((0, import_util.isArray)(a)) {\n    return a.some((v) => (0, import_util.isEqual)(v, b)) || (0, import_util.flatten)(a, options?.depth).some((v) => (0, import_util.isEqual)(v, b));\n  }\n  return false;\n}\nfunction $ne(a, b, options) {\n  return !$eq(a, b, options);\n}\nfunction $in(a, b, options) {\n  if ((0, import_util.isNil)(a)) return b.some((v) => v === null);\n  return (0, import_util.intersection)([(0, import_util.ensureArray)(a), b], options?.hashFunction).length > 0;\n}\nfunction $nin(a, b, options) {\n  return !$in(a, b, options);\n}\nfunction $lt(a, b, _options) {\n  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) < 0);\n}\nfunction $lte(a, b, _options) {\n  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) <= 0);\n}\nfunction $gt(a, b, _options) {\n  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) > 0);\n}\nfunction $gte(a, b, _options) {\n  return compare(a, b, (x, y) => (0, import_util.compare)(x, y) >= 0);\n}\nfunction $mod(a, b, _options) {\n  return (0, import_util.ensureArray)(a).some(\n    (x) => b.length === 2 && x % b[0] === b[1]\n  );\n}\nfunction $regex(a, b, options) {\n  const lhs = (0, import_util.ensureArray)(a);\n  const match = (x) => (0, import_util.isString)(x) && (0, import_util.truthy)(b.exec(x), options?.useStrictMode);\n  return lhs.some(match) || (0, import_util.flatten)(lhs, 1).some(match);\n}\nfunction $exists(a, b, _options) {\n  return (b === false || b === 0) && a === void 0 || (b === true || b === 1) && a !== void 0;\n}\nfunction $all(values, queries, options) {\n  if (!(0, import_util.isArray)(values) || !(0, import_util.isArray)(queries) || !values.length || !queries.length) {\n    return false;\n  }\n  let matched = true;\n  for (const query of queries) {\n    if (!matched) break;\n    if ((0, import_util.isObject)(query) && Object.keys(query).includes(\"$elemMatch\")) {\n      matched = $elemMatch(values, query[\"$elemMatch\"], options);\n    } else if ((0, import_util.isRegExp)(query)) {\n      matched = values.some((s) => typeof s === \"string\" && query.test(s));\n    } else {\n      matched = values.some((v) => (0, import_util.isEqual)(query, v));\n    }\n  }\n  return matched;\n}\nfunction $size(a, b, _options) {\n  return Array.isArray(a) && a.length === b;\n}\nfunction isNonBooleanOperator(name) {\n  return (0, import_util.isOperator)(name) && [\"$and\", \"$or\", \"$nor\"].indexOf(name) === -1;\n}\nfunction $elemMatch(a, b, options) {\n  if ((0, import_util.isArray)(a) && !(0, import_util.isEmpty)(a)) {\n    let format = (x) => x;\n    let criteria = b;\n    if (Object.keys(b).every(isNonBooleanOperator)) {\n      criteria = { temp: b };\n      format = (x) => ({ temp: x });\n    }\n    const query = new import_query.Query(criteria, options);\n    for (let i = 0, len = a.length; i < len; i++) {\n      if (query.test(format(a[i]))) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\nconst isNull = (a) => a === null;\nconst compareFuncs = {\n  array: import_util.isArray,\n  boolean: import_util.isBoolean,\n  date: import_util.isDate,\n  number: import_util.isNumber,\n  null: isNull,\n  object: import_util.isObject,\n  regex: import_util.isRegExp,\n  string: import_util.isString,\n  // added for completeness\n  undefined: import_util.isNil,\n  // deprecated\n  function: (_) => {\n    throw new import_util.MingoError(\"unsupported type key `function`.\");\n  },\n  // Mongo identifiers\n  1: import_util.isNumber,\n  //double\n  2: import_util.isString,\n  3: import_util.isObject,\n  4: import_util.isArray,\n  6: import_util.isNil,\n  // deprecated\n  8: import_util.isBoolean,\n  9: import_util.isDate,\n  10: isNull,\n  11: import_util.isRegExp,\n  16: import_util.isNumber,\n  18: import_util.isNumber,\n  19: import_util.isNumber\n  //decimal\n};\nfunction compareType(a, b, _) {\n  const f = compareFuncs[b];\n  return f ? f(a) : false;\n}\nfunction $type(a, b, options) {\n  return (0, import_util.isArray)(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);\n}\nfunction compare(a, b, f) {\n  return (0, import_util.ensureArray)(a).some((x) => (0, import_util.typeOf)(x) === (0, import_util.typeOf)(b) && f(x, b));\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1424:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  covariance: () => covariance,\n  stddev: () => stddev\n});\nmodule.exports = __toCommonJS(internal_exports);\nfunction stddev(data, sampled = true) {\n  const sum = data.reduce((acc, n) => acc + n, 0);\n  const N = data.length || 1;\n  const avg = sum / N;\n  return Math.sqrt(\n    data.reduce((acc, n) => acc + Math.pow(n - avg, 2), 0) / (N - Number(sampled))\n  );\n}\nfunction covariance(dataset, sampled = true) {\n  if (!dataset) return null;\n  if (dataset.length < 2) return sampled ? null : 0;\n  let meanX = 0;\n  let meanY = 0;\n  for (const [x, y] of dataset) {\n    meanX += x;\n    meanY += y;\n  }\n  meanX /= dataset.length;\n  meanY /= dataset.length;\n  let result = 0;\n  for (const [x, y] of dataset) {\n    result += (x - meanX) * (y - meanY);\n  }\n  return result / (dataset.length - Number(sampled));\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4426:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar accumulator_exports = {};\n__export(accumulator_exports, {\n  $accumulator: () => $accumulator\n});\nmodule.exports = __toCommonJS(accumulator_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $accumulator = (collection, expr, options) => {\n  (0, import_util.assert)(\n    !!options && options.scriptEnabled,\n    \"$accumulator operator requires 'scriptEnabled' option to be true\"\n  );\n  if (collection.length == 0) return expr.initArgs;\n  const copts = import_core.ComputeOptions.init(options);\n  const initArgs = (0, import_core.computeValue)(\n    {},\n    expr.initArgs || [],\n    null,\n    copts.update(copts?.local?.groupId || {})\n  );\n  let state = expr.init.call(null, ...initArgs);\n  for (const doc of collection) {\n    const args = (0, import_core.computeValue)(\n      doc,\n      expr.accumulateArgs,\n      null,\n      copts.update(doc)\n    );\n    state = expr.accumulate.call(null, ...[state, ...args]);\n  }\n  return expr.finalize ? expr.finalize.call(null, state) : state;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 320:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar addToSet_exports = {};\n__export(addToSet_exports, {\n  $addToSet: () => $addToSet\n});\nmodule.exports = __toCommonJS(addToSet_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $addToSet = (collection, expr, options) => {\n  return (0, import_util.unique)(\n    (0, import_push.$push)(collection, expr, options),\n    options?.hashFunction\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9000:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar avg_exports = {};\n__export(avg_exports, {\n  $avg: () => $avg\n});\nmodule.exports = __toCommonJS(avg_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $avg = (collection, expr, options) => {\n  const data = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);\n  const sum = data.reduce((acc, n) => acc + n, 0);\n  return sum / (data.length || 1);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5045:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bottom_exports = {};\n__export(bottom_exports, {\n  $bottom: () => $bottom\n});\nmodule.exports = __toCommonJS(bottom_exports);\nvar import_bottomN = __webpack_require__(4683);\nconst $bottom = (collection, expr, options) => (0, import_bottomN.$bottomN)(collection, { ...expr, n: 1 }, options);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4683:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bottomN_exports = {};\n__export(bottomN_exports, {\n  $bottomN: () => $bottomN\n});\nmodule.exports = __toCommonJS(bottomN_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nvar import_push = __webpack_require__(4518);\nconst $bottomN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const { n, sortBy } = (0, import_core.computeValue)(\n    copts.local.groupId,\n    expr,\n    null,\n    copts\n  );\n  const result = new import_aggregator.Aggregator([{ $sort: sortBy }], copts).run(collection);\n  const m = result.length;\n  const p = n;\n  return (0, import_push.$push)(m <= p ? result : result.slice(m - p), expr.output, copts);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6995:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar count_exports = {};\n__export(count_exports, {\n  $count: () => $count\n});\nmodule.exports = __toCommonJS(count_exports);\nconst $count = (collection, _expr, _options) => collection.length;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3516:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar covariancePop_exports = {};\n__export(covariancePop_exports, {\n  $covariancePop: () => $covariancePop\n});\nmodule.exports = __toCommonJS(covariancePop_exports);\nvar import_internal = __webpack_require__(1424);\nvar import_push = __webpack_require__(4518);\nconst $covariancePop = (collection, expr, options) => (0, import_internal.covariance)((0, import_push.$push)(collection, expr, options), false);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4862:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar covarianceSamp_exports = {};\n__export(covarianceSamp_exports, {\n  $covarianceSamp: () => $covarianceSamp\n});\nmodule.exports = __toCommonJS(covarianceSamp_exports);\nvar import_internal = __webpack_require__(1424);\nvar import_push = __webpack_require__(4518);\nconst $covarianceSamp = (collection, expr, options) => (0, import_internal.covariance)((0, import_push.$push)(collection, expr, options), true);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1058:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar first_exports = {};\n__export(first_exports, {\n  $first: () => $first\n});\nmodule.exports = __toCommonJS(first_exports);\nvar import_core = __webpack_require__(2760);\nconst $first = (collection, expr, options) => {\n  if (collection.length === 0) return void 0;\n  const copts = import_core.ComputeOptions.init(options).update(collection[0]);\n  return (0, import_core.computeValue)(collection[0], expr, null, copts);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6550:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar firstN_exports = {};\n__export(firstN_exports, {\n  $firstN: () => $firstN\n});\nmodule.exports = __toCommonJS(firstN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_push = __webpack_require__(4518);\nconst $firstN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const m = collection.length;\n  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);\n  return (0, import_push.$push)(\n    m <= n ? collection : collection.slice(0, n),\n    expr.input,\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1248:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar accumulator_exports = {};\nmodule.exports = __toCommonJS(accumulator_exports);\n__reExport(accumulator_exports, __webpack_require__(4426), module.exports);\n__reExport(accumulator_exports, __webpack_require__(320), module.exports);\n__reExport(accumulator_exports, __webpack_require__(9000), module.exports);\n__reExport(accumulator_exports, __webpack_require__(5045), module.exports);\n__reExport(accumulator_exports, __webpack_require__(4683), module.exports);\n__reExport(accumulator_exports, __webpack_require__(6995), module.exports);\n__reExport(accumulator_exports, __webpack_require__(3516), module.exports);\n__reExport(accumulator_exports, __webpack_require__(4862), module.exports);\n__reExport(accumulator_exports, __webpack_require__(1058), module.exports);\n__reExport(accumulator_exports, __webpack_require__(6550), module.exports);\n__reExport(accumulator_exports, __webpack_require__(9666), module.exports);\n__reExport(accumulator_exports, __webpack_require__(3830), module.exports);\n__reExport(accumulator_exports, __webpack_require__(4674), module.exports);\n__reExport(accumulator_exports, __webpack_require__(6870), module.exports);\n__reExport(accumulator_exports, __webpack_require__(9524), module.exports);\n__reExport(accumulator_exports, __webpack_require__(8702), module.exports);\n__reExport(accumulator_exports, __webpack_require__(2908), module.exports);\n__reExport(accumulator_exports, __webpack_require__(2184), module.exports);\n__reExport(accumulator_exports, __webpack_require__(6393), module.exports);\n__reExport(accumulator_exports, __webpack_require__(4518), module.exports);\n__reExport(accumulator_exports, __webpack_require__(1779), module.exports);\n__reExport(accumulator_exports, __webpack_require__(9388), module.exports);\n__reExport(accumulator_exports, __webpack_require__(3295), module.exports);\n__reExport(accumulator_exports, __webpack_require__(7995), module.exports);\n__reExport(accumulator_exports, __webpack_require__(1977), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9666:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar last_exports = {};\n__export(last_exports, {\n  $last: () => $last\n});\nmodule.exports = __toCommonJS(last_exports);\nvar import_core = __webpack_require__(2760);\nconst $last = (collection, expr, options) => {\n  if (collection.length === 0) return void 0;\n  const obj = collection[collection.length - 1];\n  const copts = import_core.ComputeOptions.init(options).update(obj);\n  return (0, import_core.computeValue)(obj, expr, null, copts);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3830:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lastN_exports = {};\n__export(lastN_exports, {\n  $lastN: () => $lastN\n});\nmodule.exports = __toCommonJS(lastN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_push = __webpack_require__(4518);\nconst $lastN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const m = collection.length;\n  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);\n  return (0, import_push.$push)(\n    m <= n ? collection : collection.slice(m - n),\n    expr.input,\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4674:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar max_exports = {};\n__export(max_exports, {\n  $max: () => $max\n});\nmodule.exports = __toCommonJS(max_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $max = (collection, expr, options) => {\n  const items = (0, import_push.$push)(collection, expr, options);\n  if ((0, import_util.isEmpty)(items)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(items), \"$max: input must resolve to array\");\n  let max = items[0];\n  for (const n of items) {\n    if ((0, import_util.isNil)(n) || isNaN(n)) continue;\n    if ((0, import_util.compare)(n, max) >= 0) max = n;\n  }\n  return max;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6870:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar maxN_exports = {};\n__export(maxN_exports, {\n  $maxN: () => $maxN\n});\nmodule.exports = __toCommonJS(maxN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $maxN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const m = collection.length;\n  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);\n  const arr = (0, import_push.$push)(collection, expr.input, options).filter((o) => !(0, import_util.isNil)(o));\n  arr.sort((a, b) => -1 * (0, import_util.compare)(a, b));\n  return m <= n ? arr : arr.slice(0, n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9524:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar median_exports = {};\n__export(median_exports, {\n  $median: () => $median\n});\nmodule.exports = __toCommonJS(median_exports);\nvar import_percentile = __webpack_require__(6393);\nconst $median = (collection, expr, options) => (0, import_percentile.$percentile)(collection, { ...expr, p: [0.5] }, options).pop();\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8702:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar mergeObjects_exports = {};\n__export(mergeObjects_exports, {\n  $mergeObjects: () => $mergeObjects\n});\nmodule.exports = __toCommonJS(mergeObjects_exports);\nvar import_core = __webpack_require__(2760);\nvar import_mergeObjects = __webpack_require__(4420);\nconst $mergeObjects = (collection, expr, options) => {\n  const arr = (0, import_core.computeValue)(collection, expr, null, options);\n  return (0, import_mergeObjects.$mergeObjects)(null, arr, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2908:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar min_exports = {};\n__export(min_exports, {\n  $min: () => $min\n});\nmodule.exports = __toCommonJS(min_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $min = (collection, expr, options) => {\n  const items = (0, import_push.$push)(collection, expr, options);\n  if ((0, import_util.isEmpty)(items)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(items), \"$min: input must resolve to array\");\n  let min = items[0];\n  for (const n of items) {\n    if ((0, import_util.isNil)(n) || isNaN(n)) continue;\n    if ((0, import_util.compare)(n, min) <= 0) min = n;\n  }\n  return min;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2184:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar minN_exports = {};\n__export(minN_exports, {\n  $minN: () => $minN\n});\nmodule.exports = __toCommonJS(minN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $minN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const m = collection.length;\n  const n = (0, import_core.computeValue)(copts?.local?.groupId, expr.n, null, copts);\n  const arr = (0, import_push.$push)(collection, expr.input, options).filter((o) => !(0, import_util.isNil)(o));\n  arr.sort(import_util.compare);\n  return m <= n ? arr : arr.slice(0, n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6393:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar percentile_exports = {};\n__export(percentile_exports, {\n  $percentile: () => $percentile\n});\nmodule.exports = __toCommonJS(percentile_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $percentile = (collection, expr, options) => {\n  const X = (0, import_push.$push)(collection, expr.input, options).filter(import_util.isNumber).sort();\n  const centiles = (0, import_push.$push)(expr.p, \"$$CURRENT\", options).filter(import_util.isNumber);\n  const method = expr.method || \"approximate\";\n  return centiles.map((p) => {\n    (0, import_util.assert)(\n      p > 0 && p <= 1,\n      `percentile value must be between 0 (exclusive) and 1 (inclusive): invalid '${p}'.`\n    );\n    const r = p * (X.length - 1) + 1;\n    const ri = Math.floor(r);\n    const result = r === ri ? X[r - 1] : X[ri - 1] + r % 1 * (X[ri] - X[ri - 1] || 0);\n    switch (method) {\n      case \"exact\":\n        return result;\n      case \"approximate\": {\n        const i = (0, import_util.findInsertIndex)(X, result);\n        return i / X.length >= p ? X[Math.max(i - 1, 0)] : X[i];\n      }\n    }\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4518:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar push_exports = {};\n__export(push_exports, {\n  $push: () => $push\n});\nmodule.exports = __toCommonJS(push_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $push = (collection, expr, options) => {\n  if ((0, import_util.isNil)(expr)) return collection;\n  const copts = import_core.ComputeOptions.init(options);\n  return collection.map(\n    (obj) => (0, import_core.computeValue)(obj, expr, null, copts.update(obj))\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1779:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar stdDevPop_exports = {};\n__export(stdDevPop_exports, {\n  $stdDevPop: () => $stdDevPop\n});\nmodule.exports = __toCommonJS(stdDevPop_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(1424);\nvar import_push = __webpack_require__(4518);\nconst $stdDevPop = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), false);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9388:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar stdDevSamp_exports = {};\n__export(stdDevSamp_exports, {\n  $stdDevSamp: () => $stdDevSamp\n});\nmodule.exports = __toCommonJS(stdDevSamp_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(1424);\nvar import_push = __webpack_require__(4518);\nconst $stdDevSamp = (collection, expr, options) => (0, import_internal.stddev)((0, import_push.$push)(collection, expr, options).filter(import_util.isNumber), true);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3295:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sum_exports = {};\n__export(sum_exports, {\n  $sum: () => $sum\n});\nmodule.exports = __toCommonJS(sum_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nconst $sum = (collection, expr, options) => {\n  if (!(0, import_util.isArray)(collection)) return 0;\n  if ((0, import_util.isNumber)(expr)) return collection.length * expr;\n  const nums = (0, import_push.$push)(collection, expr, options).filter(import_util.isNumber);\n  return nums.reduce((acc, n) => acc + n, 0);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7995:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar top_exports = {};\n__export(top_exports, {\n  $top: () => $top\n});\nmodule.exports = __toCommonJS(top_exports);\nvar import_topN = __webpack_require__(1977);\nconst $top = (collection, expr, options) => (0, import_topN.$topN)(collection, { ...expr, n: 1 }, options);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1977:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar topN_exports = {};\n__export(topN_exports, {\n  $topN: () => $topN\n});\nmodule.exports = __toCommonJS(topN_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nvar import_push = __webpack_require__(4518);\nconst $topN = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const { n, sortBy } = (0, import_core.computeValue)(\n    copts.local.groupId,\n    expr,\n    null,\n    copts\n  );\n  const result = new import_aggregator.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(\n    collection\n  );\n  return (0, import_push.$push)(result, expr.output, copts);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6405:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  truncate: () => truncate\n});\nmodule.exports = __toCommonJS(internal_exports);\nfunction truncate(num, places = 0, roundOff = false) {\n  const sign = Math.abs(num) === num ? 1 : -1;\n  num = Math.abs(num);\n  let result = Math.trunc(num);\n  const decimals = parseFloat((num - result).toFixed(places + 1));\n  if (places === 0) {\n    const firstDigit = Math.trunc(10 * decimals);\n    if (roundOff && ((result & 1) === 1 && firstDigit >= 5 || firstDigit > 5)) {\n      result++;\n    }\n  } else if (places > 0) {\n    const offset = Math.pow(10, places);\n    let remainder = Math.trunc(decimals * offset);\n    const lastDigit = Math.trunc(decimals * offset * 10) % 10;\n    if (roundOff && lastDigit > 5) {\n      remainder += 1;\n    }\n    result = (result * offset + remainder) / offset;\n  } else if (places < 0) {\n    const offset = Math.pow(10, -1 * places);\n    let excess = result % offset;\n    result = Math.max(0, result - excess);\n    if (roundOff && sign === -1) {\n      while (excess > 10) {\n        excess -= excess % 10;\n      }\n      if (result > 0 && excess >= 5) {\n        result += offset;\n      }\n    }\n  }\n  return result * sign;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9133:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar abs_exports = {};\n__export(abs_exports, {\n  $abs: () => $abs\n});\nmodule.exports = __toCommonJS(abs_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $abs = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.isNil)(n) ? null : Math.abs(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9566:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar add_exports = {};\n__export(add_exports, {\n  $add: () => $add\n});\nmodule.exports = __toCommonJS(add_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $add = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  let hasDate = false;\n  let sum = 0;\n  for (const n of args) {\n    if ((0, import_util.isDate)(n)) {\n      (0, import_util.assert)(!hasDate, \"'$add' can only have one date value\");\n      hasDate = true;\n    }\n    sum += +n;\n  }\n  return hasDate ? new Date(sum) : sum;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7888:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ceil_exports = {};\n__export(ceil_exports, {\n  $ceil: () => $ceil\n});\nmodule.exports = __toCommonJS(ceil_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $ceil = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), \"$ceil expression must resolve to a number.\");\n  return Math.ceil(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4424:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar divide_exports = {};\n__export(divide_exports, {\n  $divide: () => $divide\n});\nmodule.exports = __toCommonJS(divide_exports);\nvar import_core = __webpack_require__(2760);\nconst $divide = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  return args[0] / args[1];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9490:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar exp_exports = {};\n__export(exp_exports, {\n  $exp: () => $exp\n});\nmodule.exports = __toCommonJS(exp_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $exp = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), \"$exp expression must resolve to a number.\");\n  return Math.exp(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2175:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar floor_exports = {};\n__export(floor_exports, {\n  $floor: () => $floor\n});\nmodule.exports = __toCommonJS(floor_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $floor = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isNumber)(n) || isNaN(n),\n    \"$floor expression must resolve to a number.\"\n  );\n  return Math.floor(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4125:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar arithmetic_exports = {};\nmodule.exports = __toCommonJS(arithmetic_exports);\n__reExport(arithmetic_exports, __webpack_require__(9133), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(9566), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(7888), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(4424), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(9490), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(2175), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(3023), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(5571), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(7462), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(7229), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(353), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(9319), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(5057), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(6451), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(8413), module.exports);\n__reExport(arithmetic_exports, __webpack_require__(731), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3023:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ln_exports = {};\n__export(ln_exports, {\n  $ln: () => $ln\n});\nmodule.exports = __toCommonJS(ln_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $ln = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)((0, import_util.isNumber)(n) || isNaN(n), \"$ln expression must resolve to a number.\");\n  return Math.log(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5571:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar log_exports = {};\n__export(log_exports, {\n  $log: () => $log\n});\nmodule.exports = __toCommonJS(log_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $log = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const msg = \"$log expression must resolve to array(2) of numbers\";\n  (0, import_util.assert)((0, import_util.isArray)(args) && args.length === 2, msg);\n  if (args.some(import_util.isNil)) return null;\n  (0, import_util.assert)(args.some(isNaN) || args.every(import_util.isNumber), msg);\n  return Math.log10(args[0]) / Math.log10(args[1]);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7462:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar log10_exports = {};\n__export(log10_exports, {\n  $log10: () => $log10\n});\nmodule.exports = __toCommonJS(log10_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $log10 = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isNumber)(n) || isNaN(n),\n    \"$log10 expression must resolve to a number.\"\n  );\n  return Math.log10(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7229:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar mod_exports = {};\n__export(mod_exports, {\n  $mod: () => $mod\n});\nmodule.exports = __toCommonJS(mod_exports);\nvar import_core = __webpack_require__(2760);\nconst $mod = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  return args[0] % args[1];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 353:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar multiply_exports = {};\n__export(multiply_exports, {\n  $multiply: () => $multiply\n});\nmodule.exports = __toCommonJS(multiply_exports);\nvar import_core = __webpack_require__(2760);\nconst $multiply = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  return args.reduce((acc, num) => acc * num, 1);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9319:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar pow_exports = {};\n__export(pow_exports, {\n  $pow: () => $pow\n});\nmodule.exports = __toCommonJS(pow_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $pow = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.length === 2 && args.every(import_util.isNumber),\n    \"$pow expression must resolve to array(2) of numbers\"\n  );\n  (0, import_util.assert)(\n    !(args[0] === 0 && args[1] < 0),\n    \"$pow cannot raise 0 to a negative exponent\"\n  );\n  return Math.pow(args[0], args[1]);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5057:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar round_exports = {};\n__export(round_exports, {\n  $round: () => $round\n});\nmodule.exports = __toCommonJS(round_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(6405);\nconst $round = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const num = args[0];\n  const place = args[1];\n  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;\n  (0, import_util.assert)((0, import_util.isNumber)(num), \"$round expression must resolve to a number.\");\n  return (0, import_internal.truncate)(num, place, true);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6451:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sqrt_exports = {};\n__export(sqrt_exports, {\n  $sqrt: () => $sqrt\n});\nmodule.exports = __toCommonJS(sqrt_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $sqrt = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isNumber)(n) && n > 0 || isNaN(n),\n    \"$sqrt expression must resolve to non-negative number.\"\n  );\n  return Math.sqrt(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8413:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar subtract_exports = {};\n__export(subtract_exports, {\n  $subtract: () => $subtract\n});\nmodule.exports = __toCommonJS(subtract_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $subtract = (obj, expr, options) => {\n  const [a, b] = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNumber)(a) && (0, import_util.isNumber)(b) || (0, import_util.isDate)(a) && (0, import_util.isDate)(b)) return +a - +b;\n  if ((0, import_util.isDate)(a) && (0, import_util.isNumber)(b)) return new Date(+a - b);\n  (0, import_util.assert)(false, \"$subtract: must resolve to number/date.\");\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 731:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar trunc_exports = {};\n__export(trunc_exports, {\n  $trunc: () => $trunc\n});\nmodule.exports = __toCommonJS(trunc_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(6405);\nconst $trunc = (obj, expr, options) => {\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  const num = arr[0];\n  const places = arr[1];\n  if ((0, import_util.isNil)(num) || isNaN(num) || Math.abs(num) === Infinity) return num;\n  (0, import_util.assert)((0, import_util.isNumber)(num), \"$trunc expression must resolve to a number.\");\n  (0, import_util.assert)(\n    (0, import_util.isNil)(places) || (0, import_util.isNumber)(places) && places > -20 && places < 100,\n    \"$trunc expression has invalid place\"\n  );\n  return (0, import_internal.truncate)(num, places, false);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3261:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar arrayElemAt_exports = {};\n__export(arrayElemAt_exports, {\n  $arrayElemAt: () => $arrayElemAt\n});\nmodule.exports = __toCommonJS(arrayElemAt_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $arrayElemAt = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.length === 2,\n    \"$arrayElemAt expression must resolve to array(2)\"\n  );\n  if (args.some(import_util.isNil)) return null;\n  const index = args[1];\n  const arr = args[0];\n  if (index < 0 && Math.abs(index) <= arr.length) {\n    return arr[(index + arr.length) % arr.length];\n  } else if (index >= 0 && index < arr.length) {\n    return arr[index];\n  }\n  return void 0;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3285:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar arrayToObject_exports = {};\n__export(arrayToObject_exports, {\n  $arrayToObject: () => $arrayToObject\n});\nmodule.exports = __toCommonJS(arrayToObject_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $arrayToObject = (obj, expr, options) => {\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)((0, import_util.isArray)(arr), \"$arrayToObject: expression must resolve to an array\");\n  return arr.reduce((newObj, val) => {\n    while ((0, import_util.isArray)(val) && val.length === 1) val = val[0];\n    if ((0, import_util.isArray)(val) && val.length == 2) {\n      newObj[val[0]] = val[1];\n    } else {\n      const valObj = val;\n      (0, import_util.assert)(\n        (0, import_util.isObject)(valObj) && (0, import_util.has)(valObj, \"k\") && (0, import_util.has)(valObj, \"v\"),\n        \"$arrayToObject expression is invalid.\"\n      );\n      newObj[valObj.k] = valObj.v;\n    }\n    return newObj;\n  }, {});\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8590:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar concatArrays_exports = {};\n__export(concatArrays_exports, {\n  $concatArrays: () => $concatArrays\n});\nmodule.exports = __toCommonJS(concatArrays_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $concatArrays = (obj, expr, options) => {\n  const nArray = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)((0, import_util.isArray)(nArray), \"$concatArrays: input must resolve to an array\");\n  let size = 0;\n  for (const arr of nArray) {\n    if ((0, import_util.isNil)(arr)) return null;\n    size += arr.length;\n  }\n  const result = new Array(size);\n  let i = 0;\n  for (const arr of nArray) for (const item of arr) result[i++] = item;\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8106:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar filter_exports = {};\n__export(filter_exports, {\n  $filter: () => $filter\n});\nmodule.exports = __toCommonJS(filter_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $filter = (obj, expr, options) => {\n  const input = (0, import_core.computeValue)(obj, expr.input, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"$filter 'input' expression must resolve to an array\");\n  const copts = import_core.ComputeOptions.init(options, obj);\n  const k = expr.as || \"this\";\n  const local = {\n    variables: { [k]: null }\n  };\n  return input.filter((o) => {\n    local.variables[k] = o;\n    const b = (0, import_core.computeValue)(\n      obj,\n      expr.cond,\n      null,\n      copts.update(copts.root, local)\n    );\n    return (0, import_util.truthy)(b, options.useStrictMode);\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6976:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar first_exports = {};\n__export(first_exports, {\n  $first: () => $first\n});\nmodule.exports = __toCommonJS(first_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_first = __webpack_require__(1058);\nconst $first = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_first.$first)(obj, expr, options);\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(arr)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isArray)(arr) && arr.length > 0,\n    \"$first must resolve to a non-empty array.\"\n  );\n  return (0, import_util.flatten)(arr)[0];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2412:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar firstN_exports = {};\n__export(firstN_exports, {\n  $firstN: () => $firstN\n});\nmodule.exports = __toCommonJS(firstN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_firstN = __webpack_require__(6550);\nconst $firstN = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_firstN.$firstN)(obj, expr, options);\n  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"Must resolve to an array/null or missing\");\n  return (0, import_firstN.$firstN)(input, { n, input: \"$$this\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9067:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar in_exports = {};\n__export(in_exports, {\n  $in: () => $in\n});\nmodule.exports = __toCommonJS(in_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $in = (obj, expr, options) => {\n  const [item, arr] = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)((0, import_util.isArray)(arr), \"$in second argument must be an array\");\n  return arr.some((v) => (0, import_util.isEqual)(v, item));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2846:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar array_exports = {};\nmodule.exports = __toCommonJS(array_exports);\n__reExport(array_exports, __webpack_require__(3261), module.exports);\n__reExport(array_exports, __webpack_require__(3285), module.exports);\n__reExport(array_exports, __webpack_require__(8590), module.exports);\n__reExport(array_exports, __webpack_require__(8106), module.exports);\n__reExport(array_exports, __webpack_require__(6976), module.exports);\n__reExport(array_exports, __webpack_require__(2412), module.exports);\n__reExport(array_exports, __webpack_require__(9067), module.exports);\n__reExport(array_exports, __webpack_require__(5910), module.exports);\n__reExport(array_exports, __webpack_require__(3239), module.exports);\n__reExport(array_exports, __webpack_require__(6788), module.exports);\n__reExport(array_exports, __webpack_require__(2080), module.exports);\n__reExport(array_exports, __webpack_require__(2836), module.exports);\n__reExport(array_exports, __webpack_require__(8952), module.exports);\n__reExport(array_exports, __webpack_require__(7110), module.exports);\n__reExport(array_exports, __webpack_require__(5676), module.exports);\n__reExport(array_exports, __webpack_require__(1603), module.exports);\n__reExport(array_exports, __webpack_require__(2866), module.exports);\n__reExport(array_exports, __webpack_require__(7607), module.exports);\n__reExport(array_exports, __webpack_require__(2881), module.exports);\n__reExport(array_exports, __webpack_require__(7292), module.exports);\n__reExport(array_exports, __webpack_require__(1931), module.exports);\n__reExport(array_exports, __webpack_require__(4657), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5910:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar indexOfArray_exports = {};\n__export(indexOfArray_exports, {\n  $indexOfArray: () => $indexOfArray\n});\nmodule.exports = __toCommonJS(indexOfArray_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $indexOfArray = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args)) return null;\n  let arr = args[0];\n  const searchValue = args[1];\n  if ((0, import_util.isNil)(arr)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(arr), \"$indexOfArray expression must resolve to an array.\");\n  const start = args[2] || 0;\n  let end = args[3];\n  if ((0, import_util.isNil)(end)) end = arr.length;\n  if (start > end) return -1;\n  (0, import_util.assert)(start >= 0 && end >= 0, \"$indexOfArray expression is invalid\");\n  if (start > 0 || end < arr.length) {\n    arr = arr.slice(start, end);\n  }\n  let index = -1;\n  arr.some((v, i) => {\n    const b = (0, import_util.isEqual)(v, searchValue);\n    if (b) index = i;\n    return b;\n  });\n  return index + start;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3239:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar isArray_exports = {};\n__export(isArray_exports, {\n  $isArray: () => $isArray\n});\nmodule.exports = __toCommonJS(isArray_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $isArray = (obj, expr, options) => (0, import_util.isArray)((0, import_core.computeValue)(obj, expr[0], null, options));\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6788:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar last_exports = {};\n__export(last_exports, {\n  $last: () => $last\n});\nmodule.exports = __toCommonJS(last_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_last = __webpack_require__(9666);\nconst $last = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_last.$last)(obj, expr, options);\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(arr)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isArray)(arr) && arr.length > 0,\n    \"$last must resolve to a non-empty array.\"\n  );\n  return (0, import_util.flatten)(arr)[arr.length - 1];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2080:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lastN_exports = {};\n__export(lastN_exports, {\n  $lastN: () => $lastN\n});\nmodule.exports = __toCommonJS(lastN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_lastN = __webpack_require__(3830);\nconst $lastN = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_lastN.$lastN)(obj, expr, options);\n  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"Must resolve to an array/null or missing\");\n  return (0, import_lastN.$lastN)(input, { n, input: \"$$this\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2836:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar map_exports = {};\n__export(map_exports, {\n  $map: () => $map\n});\nmodule.exports = __toCommonJS(map_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $map = (obj, expr, options) => {\n  const input = (0, import_core.computeValue)(obj, expr.input, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), `$map 'input' expression must resolve to an array`);\n  const copts = import_core.ComputeOptions.init(options);\n  const k = expr.as || \"this\";\n  return input.map((o) => {\n    return (0, import_core.computeValue)(\n      obj,\n      expr.in,\n      null,\n      copts.update(copts.root, {\n        variables: { [k]: o }\n      })\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8952:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar maxN_exports = {};\n__export(maxN_exports, {\n  $maxN: () => $maxN\n});\nmodule.exports = __toCommonJS(maxN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_maxN = __webpack_require__(6870);\nconst $maxN = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_maxN.$maxN)(obj, expr, options);\n  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"Must resolve to an array/null or missing\");\n  return (0, import_maxN.$maxN)(input, { n, input: \"$$this\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7110:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar minN_exports = {};\n__export(minN_exports, {\n  $minN: () => $minN\n});\nmodule.exports = __toCommonJS(minN_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_minN = __webpack_require__(2184);\nconst $minN = (obj, expr, options) => {\n  if ((0, import_util.isArray)(obj)) return (0, import_minN.$minN)(obj, expr, options);\n  const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"Must resolve to an array/null or missing\");\n  return (0, import_minN.$minN)(input, { n, input: \"$$this\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5676:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar nin_exports = {};\n__export(nin_exports, {\n  $nin: () => $nin\n});\nmodule.exports = __toCommonJS(nin_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $nin = (0, import_predicates.createExpressionOperator)(import_predicates.$nin);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1603:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar range_exports = {};\n__export(range_exports, {\n  $range: () => $range\n});\nmodule.exports = __toCommonJS(range_exports);\nvar import_core = __webpack_require__(2760);\nconst $range = (obj, expr, options) => {\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  const start = arr[0];\n  const end = arr[1];\n  const step = arr[2] || 1;\n  const result = new Array();\n  let counter = start;\n  while (counter < end && step > 0 || counter > end && step < 0) {\n    result.push(counter);\n    counter += step;\n  }\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2866:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar reduce_exports = {};\n__export(reduce_exports, {\n  $reduce: () => $reduce\n});\nmodule.exports = __toCommonJS(reduce_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $reduce = (obj, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  const input = (0, import_core.computeValue)(obj, expr.input, null, copts);\n  const initialValue = (0, import_core.computeValue)(obj, expr.initialValue, null, copts);\n  const inExpr = expr[\"in\"];\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"$reduce 'input' expression must resolve to an array\");\n  return input.reduce((acc, n) => {\n    return (0, import_core.computeValue)(\n      n,\n      inExpr,\n      null,\n      copts.update(copts.root, {\n        variables: { value: acc }\n      })\n    );\n  }, initialValue);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7607:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar reverseArray_exports = {};\n__export(reverseArray_exports, {\n  $reverseArray: () => $reverseArray\n});\nmodule.exports = __toCommonJS(reverseArray_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $reverseArray = (obj, expr, options) => {\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(arr)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(arr), \"$reverseArray expression must resolve to an array\");\n  const result = arr.slice(0);\n  result.reverse();\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2881:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar size_exports = {};\n__export(size_exports, {\n  $size: () => $size\n});\nmodule.exports = __toCommonJS(size_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $size = (obj, expr, options) => {\n  const value = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.isArray)(value) ? value.length : void 0;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7292:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar slice_exports = {};\n__export(slice_exports, {\n  $slice: () => $slice\n});\nmodule.exports = __toCommonJS(slice_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $slice = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const arr = args[0];\n  let skip = args[1];\n  let limit = args[2];\n  if ((0, import_util.isNil)(limit)) {\n    if (skip < 0) {\n      skip = Math.max(0, arr.length + skip);\n      limit = arr.length - skip + 1;\n    } else {\n      limit = skip;\n      skip = 0;\n    }\n  } else {\n    if (skip < 0) {\n      skip = Math.max(0, arr.length + skip);\n    }\n    (0, import_util.assert)(\n      limit > 0,\n      `Invalid argument for $slice operator. Limit must be a positive number`\n    );\n    limit += skip;\n  }\n  return arr.slice(skip, limit);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1931:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sortArray_exports = {};\n__export(sortArray_exports, {\n  $sortArray: () => $sortArray\n});\nmodule.exports = __toCommonJS(sortArray_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $sortArray = (obj, expr, options) => {\n  const { input, sortBy } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(input), \"$sortArray expression must resolve to an array\");\n  if ((0, import_util.isObject)(sortBy)) {\n    return new import_aggregator.Aggregator([{ $sort: sortBy }]).run(input);\n  }\n  const result = [...input];\n  result.sort(import_util.compare);\n  if (sortBy === -1) result.reverse();\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4657:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar zip_exports = {};\n__export(zip_exports, {\n  $zip: () => $zip\n});\nmodule.exports = __toCommonJS(zip_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $zip = (obj, expr, options) => {\n  const inputs = (0, import_core.computeValue)(obj, expr.inputs, null, options);\n  const useLongestLength = expr.useLongestLength || false;\n  if ((0, import_util.isNil)(inputs)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(inputs), \"'inputs' expression must resolve to an array\");\n  (0, import_util.assert)((0, import_util.isBoolean)(useLongestLength), \"'useLongestLength' must be a boolean\");\n  if ((0, import_util.isArray)(expr.defaults)) {\n    (0, import_util.assert)(\n      useLongestLength,\n      \"'useLongestLength' must be set to true to use 'defaults'\"\n    );\n  }\n  let zipCount = 0;\n  for (const arr of inputs) {\n    if ((0, import_util.isNil)(arr)) return null;\n    (0, import_util.assert)(\n      (0, import_util.isArray)(arr),\n      \"'inputs' expression values must resolve to an array or null\"\n    );\n    zipCount = useLongestLength ? Math.max(zipCount, arr.length) : Math.min(zipCount || arr.length, arr.length);\n  }\n  const result = [];\n  const defaults = expr.defaults || [];\n  for (let i = 0; i < zipCount; i++) {\n    const temp = inputs.map((val, index) => {\n      return (0, import_util.isNil)(val[i]) ? defaults[index] || null : val[i];\n    });\n    result.push(temp);\n  }\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1172:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  bitwise: () => bitwise\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst bitwise = (op, compute) => (obj, expr, options) => {\n  (0, import_util.assert)((0, import_util.isArray)(expr), `${op}: expression must be an array.`);\n  const nums = (0, import_core.computeValue)(obj, expr, null, options);\n  if (nums.some(import_util.isNil)) return null;\n  (0, import_util.assert)(\n    nums.every(import_util.isNumber),\n    `${op}: expression must evalue to array of numbers.`\n  );\n  return compute(nums);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4718:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitAnd_exports = {};\n__export(bitAnd_exports, {\n  $bitAnd: () => $bitAnd\n});\nmodule.exports = __toCommonJS(bitAnd_exports);\nvar import_internal = __webpack_require__(1172);\nconst $bitAnd = (0, import_internal.bitwise)(\n  \"$bitAnd\",\n  (nums) => nums.reduce((a, b) => a & b, -1)\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3766:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitNot_exports = {};\n__export(bitNot_exports, {\n  $bitNot: () => $bitNot\n});\nmodule.exports = __toCommonJS(bitNot_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $bitNot = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(n)) return null;\n  if ((0, import_util.isNumber)(n)) return ~n;\n  throw new import_util.MingoError(\"$bitNot: expression must evaluate to a number.\");\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5578:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitOr_exports = {};\n__export(bitOr_exports, {\n  $bitOr: () => $bitOr\n});\nmodule.exports = __toCommonJS(bitOr_exports);\nvar import_internal = __webpack_require__(1172);\nconst $bitOr = (0, import_internal.bitwise)(\n  \"$bitOr\",\n  (nums) => nums.reduce((a, b) => a | b, 0)\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5938:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitXor_exports = {};\n__export(bitXor_exports, {\n  $bitXor: () => $bitXor\n});\nmodule.exports = __toCommonJS(bitXor_exports);\nvar import_internal = __webpack_require__(1172);\nconst $bitXor = (0, import_internal.bitwise)(\n  \"$bitXor\",\n  (nums) => nums.reduce((a, b) => a ^ b, 0)\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5148:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitwise_exports = {};\nmodule.exports = __toCommonJS(bitwise_exports);\n__reExport(bitwise_exports, __webpack_require__(4718), module.exports);\n__reExport(bitwise_exports, __webpack_require__(3766), module.exports);\n__reExport(bitwise_exports, __webpack_require__(5578), module.exports);\n__reExport(bitwise_exports, __webpack_require__(5938), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 70:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar and_exports = {};\n__export(and_exports, {\n  $and: () => $and\n});\nmodule.exports = __toCommonJS(and_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $and = (obj, expr, options) => {\n  const value = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.truthy)(value, options.useStrictMode) && value.every((v) => (0, import_util.truthy)(v, options.useStrictMode));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1703:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar boolean_exports = {};\nmodule.exports = __toCommonJS(boolean_exports);\n__reExport(boolean_exports, __webpack_require__(70), module.exports);\n__reExport(boolean_exports, __webpack_require__(5950), module.exports);\n__reExport(boolean_exports, __webpack_require__(770), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5950:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar not_exports = {};\n__export(not_exports, {\n  $not: () => $not\n});\nmodule.exports = __toCommonJS(not_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $not = (obj, expr, options) => {\n  const booleanExpr = (0, import_util.ensureArray)(expr);\n  if (booleanExpr.length == 0) return false;\n  (0, import_util.assert)(booleanExpr.length == 1, \"Expression $not takes exactly 1 argument\");\n  return !(0, import_core.computeValue)(obj, booleanExpr[0], null, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 770:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar or_exports = {};\n__export(or_exports, {\n  $or: () => $or\n});\nmodule.exports = __toCommonJS(or_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $or = (obj, expr, options) => {\n  const value = (0, import_core.computeValue)(obj, expr, null, options);\n  const strict = options.useStrictMode;\n  return (0, import_util.truthy)(value, strict) && value.some((v) => (0, import_util.truthy)(v, strict));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6460:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar cmp_exports = {};\n__export(cmp_exports, {\n  $cmp: () => $cmp\n});\nmodule.exports = __toCommonJS(cmp_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $cmp = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.length == 2,\n    \"$cmp: expression must resolve to array of size 2.\"\n  );\n  return (0, import_util.compare)(args[0], args[1]);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1768:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar eq_exports = {};\n__export(eq_exports, {\n  $eq: () => $eq\n});\nmodule.exports = __toCommonJS(eq_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $eq = (0, import_predicates.createExpressionOperator)(import_predicates.$eq);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3113:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar gt_exports = {};\n__export(gt_exports, {\n  $gt: () => $gt\n});\nmodule.exports = __toCommonJS(gt_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $gt = (0, import_predicates.createExpressionOperator)(import_predicates.$gt);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9530:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar gte_exports = {};\n__export(gte_exports, {\n  $gte: () => $gte\n});\nmodule.exports = __toCommonJS(gte_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $gte = (0, import_predicates.createExpressionOperator)(import_predicates.$gte);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3336:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar comparison_exports = {};\nmodule.exports = __toCommonJS(comparison_exports);\n__reExport(comparison_exports, __webpack_require__(6460), module.exports);\n__reExport(comparison_exports, __webpack_require__(1768), module.exports);\n__reExport(comparison_exports, __webpack_require__(3113), module.exports);\n__reExport(comparison_exports, __webpack_require__(9530), module.exports);\n__reExport(comparison_exports, __webpack_require__(6646), module.exports);\n__reExport(comparison_exports, __webpack_require__(7887), module.exports);\n__reExport(comparison_exports, __webpack_require__(3515), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6646:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lt_exports = {};\n__export(lt_exports, {\n  $lt: () => $lt\n});\nmodule.exports = __toCommonJS(lt_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $lt = (0, import_predicates.createExpressionOperator)(import_predicates.$lt);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7887:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lte_exports = {};\n__export(lte_exports, {\n  $lte: () => $lte\n});\nmodule.exports = __toCommonJS(lte_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $lte = (0, import_predicates.createExpressionOperator)(import_predicates.$lte);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3515:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ne_exports = {};\n__export(ne_exports, {\n  $ne: () => $ne\n});\nmodule.exports = __toCommonJS(ne_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $ne = (0, import_predicates.createExpressionOperator)(import_predicates.$ne);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6343:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar cond_exports = {};\n__export(cond_exports, {\n  $cond: () => $cond\n});\nmodule.exports = __toCommonJS(cond_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $cond = (obj, expr, options) => {\n  let ifExpr;\n  let thenExpr;\n  let elseExpr;\n  const errorMsg = \"$cond: invalid arguments\";\n  if ((0, import_util.isArray)(expr)) {\n    (0, import_util.assert)(expr.length === 3, errorMsg);\n    ifExpr = expr[0];\n    thenExpr = expr[1];\n    elseExpr = expr[2];\n  } else {\n    (0, import_util.assert)((0, import_util.isObject)(expr), errorMsg);\n    ifExpr = expr.if;\n    thenExpr = expr.then;\n    elseExpr = expr.else;\n  }\n  const condition = (0, import_util.truthy)(\n    (0, import_core.computeValue)(obj, ifExpr, null, options),\n    options.useStrictMode\n  );\n  return (0, import_core.computeValue)(obj, condition ? thenExpr : elseExpr, null, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3653:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ifNull_exports = {};\n__export(ifNull_exports, {\n  $ifNull: () => $ifNull\n});\nmodule.exports = __toCommonJS(ifNull_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $ifNull = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  return args.find((arg) => !(0, import_util.isNil)(arg)) ?? args[args.length - 1];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5459:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar conditional_exports = {};\nmodule.exports = __toCommonJS(conditional_exports);\n__reExport(conditional_exports, __webpack_require__(6343), module.exports);\n__reExport(conditional_exports, __webpack_require__(3653), module.exports);\n__reExport(conditional_exports, __webpack_require__(4739), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4739:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar switch_exports = {};\n__export(switch_exports, {\n  $switch: () => $switch\n});\nmodule.exports = __toCommonJS(switch_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $switch = (obj, expr, options) => {\n  let thenExpr = null;\n  expr.branches.some((b) => {\n    const condition = (0, import_util.truthy)(\n      (0, import_core.computeValue)(obj, b.case, null, options),\n      options.useStrictMode\n    );\n    if (condition) thenExpr = b.then;\n    return condition;\n  });\n  return (0, import_core.computeValue)(\n    obj,\n    thenExpr !== null ? thenExpr : expr.default,\n    null,\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3388:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar function_exports = {};\n__export(function_exports, {\n  $function: () => $function\n});\nmodule.exports = __toCommonJS(function_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $function = (obj, expr, options) => {\n  (0, import_util.assert)(\n    options.scriptEnabled,\n    \"$function operator requires 'scriptEnabled' option to be true\"\n  );\n  const fn = (0, import_core.computeValue)(obj, expr, null, options);\n  return fn.body.apply(null, fn.args);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6518:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar custom_exports = {};\nmodule.exports = __toCommonJS(custom_exports);\n__reExport(custom_exports, __webpack_require__(3388), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1277:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  DATE_FORMAT: () => DATE_FORMAT,\n  DATE_PART_INTERVAL: () => DATE_PART_INTERVAL,\n  DATE_SYM_TABLE: () => DATE_SYM_TABLE,\n  DAYS_OF_WEEK: () => DAYS_OF_WEEK,\n  DAYS_OF_WEEK_SET: () => DAYS_OF_WEEK_SET,\n  DAYS_PER_WEEK: () => DAYS_PER_WEEK,\n  LEAP_YEAR_REF_POINT: () => LEAP_YEAR_REF_POINT,\n  MILLIS_PER_DAY: () => MILLIS_PER_DAY,\n  MINUTES_PER_HOUR: () => MINUTES_PER_HOUR,\n  TIMEUNIT_IN_MILLIS: () => TIMEUNIT_IN_MILLIS,\n  adjustDate: () => adjustDate,\n  computeDate: () => computeDate,\n  dateAdd: () => dateAdd,\n  dateDiffDay: () => dateDiffDay,\n  dateDiffHour: () => dateDiffHour,\n  dateDiffMonth: () => dateDiffMonth,\n  dateDiffQuarter: () => dateDiffQuarter,\n  dateDiffWeek: () => dateDiffWeek,\n  dateDiffYear: () => dateDiffYear,\n  dayOfYear: () => dayOfYear,\n  daysBetweenYears: () => daysBetweenYears,\n  daysInMonth: () => daysInMonth,\n  daysInYear: () => daysInYear,\n  formatTimezone: () => formatTimezone,\n  isLeapYear: () => isLeapYear,\n  isoWeek: () => isoWeek,\n  isoWeekYear: () => isoWeekYear,\n  isoWeekday: () => isoWeekday,\n  padDigits: () => padDigits,\n  parseTimezone: () => parseTimezone\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst LEAP_YEAR_REF_POINT = -1e9;\nconst DAYS_PER_WEEK = 7;\nconst isLeapYear = (y) => (y & 3) == 0 && (y % 100 != 0 || y % 400 == 0);\nconst DAYS_IN_YEAR = [\n  365,\n  366\n  /*leap*/\n];\nconst daysInYear = (year) => DAYS_IN_YEAR[+isLeapYear(year)];\nconst DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\nconst daysInMonth = (d) => DAYS_IN_MONTH[d.getUTCMonth()] + Number(\n  d.getUTCMonth() === 1 && isLeapYear(d.getUTCFullYear())\n);\nconst YEAR_DAYS_OFFSET = [\n  [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],\n  [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]\n  /*leap*/\n];\nconst dayOfYear = (d) => YEAR_DAYS_OFFSET[+isLeapYear(d.getUTCFullYear())][d.getUTCMonth()] + d.getUTCDate();\nconst isoWeekday = (date, startOfWeek = \"sun\") => {\n  const dow = date.getUTCDay() || 7;\n  return (dow - ISO_WEEKDAY_MAP[startOfWeek] + DAYS_PER_WEEK) % DAYS_PER_WEEK;\n};\nconst p = (y) => (y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400)) % 7;\nconst weeks = (y) => 52 + Number(p(y) == 4 || p(y - 1) == 3);\nfunction isoWeek(d) {\n  const dow = d.getUTCDay() || 7;\n  const w = Math.floor((10 + dayOfYear(d) - dow) / 7);\n  if (w < 1) return weeks(d.getUTCFullYear() - 1);\n  if (w > weeks(d.getUTCFullYear())) return 1;\n  return w;\n}\nfunction isoWeekYear(d) {\n  return d.getUTCFullYear() - Number(d.getUTCMonth() === 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);\n}\nconst MINUTES_PER_HOUR = 60;\nconst MILLIS_PER_DAY = 1e3 * 60 * 60 * 24;\nconst TIMEUNIT_IN_MILLIS = {\n  week: MILLIS_PER_DAY * DAYS_PER_WEEK,\n  day: MILLIS_PER_DAY,\n  hour: 1e3 * 60 * 60,\n  minute: 1e3 * 60,\n  second: 1e3,\n  millisecond: 1\n};\nconst DAYS_OF_WEEK = [\n  \"monday\",\n  \"mon\",\n  \"tuesday\",\n  \"tue\",\n  \"wednesday\",\n  \"wed\",\n  \"thursday\",\n  \"thu\",\n  \"friday\",\n  \"fri\",\n  \"saturday\",\n  \"sat\",\n  \"sunday\",\n  \"sun\"\n];\nconst DAYS_OF_WEEK_SET = new Set(DAYS_OF_WEEK);\nconst ISO_WEEKDAY_MAP = Object.freeze({\n  mon: 1,\n  tue: 2,\n  wed: 3,\n  thu: 4,\n  fri: 5,\n  sat: 6,\n  sun: 7\n});\nconst DATE_FORMAT = \"%Y-%m-%dT%H:%M:%S.%LZ\";\nconst DATE_PART_INTERVAL = [\n  [\"year\", 0, 9999],\n  [\"month\", 1, 12],\n  [\"day\", 1, 31],\n  [\"hour\", 0, 23],\n  [\"minute\", 0, 59],\n  [\"second\", 0, 59],\n  [\"millisecond\", 0, 999]\n];\nconst DATE_SYM_TABLE = Object.freeze({\n  \"%Y\": { name: \"year\", padding: 4, re: /([0-9]{4})/ },\n  \"%G\": { name: \"year\", padding: 4, re: /([0-9]{4})/ },\n  \"%m\": { name: \"month\", padding: 2, re: /(0[1-9]|1[012])/ },\n  \"%d\": { name: \"day\", padding: 2, re: /(0[1-9]|[12][0-9]|3[01])/ },\n  \"%H\": { name: \"hour\", padding: 2, re: /([01][0-9]|2[0-3])/ },\n  \"%M\": { name: \"minute\", padding: 2, re: /([0-5][0-9])/ },\n  \"%S\": { name: \"second\", padding: 2, re: /([0-5][0-9]|60)/ },\n  \"%L\": { name: \"millisecond\", padding: 3, re: /([0-9]{3})/ },\n  \"%u\": { name: \"weekday\", padding: 1, re: /([1-7])/ },\n  \"%U\": { name: \"week\", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },\n  \"%V\": { name: \"isoWeek\", padding: 2, re: /([1-4][0-9]?|5[0-3]?)/ },\n  \"%z\": {\n    name: \"timezone\",\n    padding: 2,\n    re: /(([+-][01][0-9]|2[0-3]):?([0-5][0-9])?)/\n  },\n  \"%Z\": { name: \"minuteOffset\", padding: 3, re: /([+-][0-9]{3})/ }\n  // \"%%\": \"%\",\n});\nconst TIMEZONE_RE = /^[a-zA-Z_]+\\/[a-zA-Z_]+$/;\nfunction parseTimezone(tzstr) {\n  if ((0, import_util.isNil)(tzstr)) return 0;\n  if (TIMEZONE_RE.test(tzstr)) {\n    const date = /* @__PURE__ */ new Date();\n    const utcDate = new Date(date.toLocaleString(\"en-US\", { timeZone: \"UTC\" }));\n    const tzDate = new Date(date.toLocaleString(\"en-US\", { timeZone: tzstr }));\n    return (tzDate.getTime() - utcDate.getTime()) / 6e4;\n  }\n  const m = DATE_SYM_TABLE[\"%z\"].re.exec(tzstr);\n  if (!m) {\n    throw new import_util.MingoError(`Timezone '${tzstr}' is invalid or not supported`);\n  }\n  const hr = parseInt(m[2]) || 0;\n  const min = parseInt(m[3]) || 0;\n  return (Math.abs(hr * MINUTES_PER_HOUR) + min) * (hr < 0 ? -1 : 1);\n}\nfunction formatTimezone(minuteOffset) {\n  return (minuteOffset < 0 ? \"-\" : \"+\") + padDigits(Math.abs(Math.floor(minuteOffset / MINUTES_PER_HOUR)), 2) + padDigits(Math.abs(minuteOffset) % MINUTES_PER_HOUR, 2);\n}\nfunction adjustDate(d, minuteOffset) {\n  d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);\n}\nfunction computeDate(obj, expr, options) {\n  if ((0, import_util.isDate)(obj)) return obj;\n  const d = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isDate)(d)) return new Date(d);\n  if ((0, import_util.isNumber)(d)) return new Date(d * 1e3);\n  if (d.date) {\n    const date = (0, import_util.isDate)(d.date) ? new Date(d.date) : new Date(d.date * 1e3);\n    if (d.timezone) {\n      adjustDate(date, parseTimezone(d.timezone));\n    }\n    return date;\n  }\n  throw Error(`cannot convert ${JSON.stringify(expr)} to date`);\n}\nfunction padDigits(n, digits) {\n  return new Array(Math.max(digits - String(n).length + 1, 0)).join(\"0\") + n.toString();\n}\nconst leapYearsSinceReferencePoint = (year) => {\n  const yearsSinceReferencePoint = year - LEAP_YEAR_REF_POINT;\n  return Math.trunc(yearsSinceReferencePoint / 4) - Math.trunc(yearsSinceReferencePoint / 100) + Math.trunc(yearsSinceReferencePoint / 400);\n};\nfunction daysBetweenYears(startYear, endYear) {\n  return Math.trunc(\n    leapYearsSinceReferencePoint(endYear - 1) - leapYearsSinceReferencePoint(startYear - 1) + (endYear - startYear) * DAYS_IN_YEAR[0]\n  );\n}\nconst dateDiffYear = (start, end) => end.getUTCFullYear() - start.getUTCFullYear();\nconst dateDiffMonth = (start, end) => end.getUTCMonth() - start.getUTCMonth() + dateDiffYear(start, end) * 12;\nconst dateDiffQuarter = (start, end) => {\n  const a = Math.trunc(start.getUTCMonth() / 3);\n  const b = Math.trunc(end.getUTCMonth() / 3);\n  return b - a + dateDiffYear(start, end) * 4;\n};\nconst dateDiffDay = (start, end) => dayOfYear(end) - dayOfYear(start) + daysBetweenYears(start.getUTCFullYear(), end.getUTCFullYear());\nconst dateDiffWeek = (start, end, startOfWeek) => {\n  const wk = (startOfWeek || \"sun\").substring(0, 3);\n  return Math.trunc(\n    (dateDiffDay(start, end) + isoWeekday(start, wk) - isoWeekday(end, wk)) / DAYS_PER_WEEK\n  );\n};\nconst dateDiffHour = (start, end) => end.getUTCHours() - start.getUTCHours() + dateDiffDay(start, end) * 24;\nconst addMonth = (d, amount) => {\n  const m = d.getUTCMonth() + amount;\n  const yearOffset = Math.floor(m / 12);\n  if (m < 0) {\n    const month = m % 12 + 12;\n    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());\n  } else {\n    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());\n  }\n};\nconst dateAdd = (date, unit, amount, _timezone) => {\n  const d = new Date(date);\n  switch (unit) {\n    case \"year\":\n      d.setUTCFullYear(d.getUTCFullYear() + amount);\n      break;\n    case \"quarter\":\n      addMonth(d, 3 * amount);\n      break;\n    case \"month\":\n      addMonth(d, amount);\n      break;\n    default:\n      d.setTime(d.getTime() + TIMEUNIT_IN_MILLIS[unit] * amount);\n  }\n  return d;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8410:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateAdd_exports = {};\n__export(dateAdd_exports, {\n  $dateAdd: () => $dateAdd\n});\nmodule.exports = __toCommonJS(dateAdd_exports);\nvar import_core = __webpack_require__(2760);\nvar import_internal = __webpack_require__(1277);\nconst $dateAdd = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_internal.dateAdd)(args.startDate, args.unit, args.amount, args.timezone);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9178:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateDiff_exports = {};\n__export(dateDiff_exports, {\n  $dateDiff: () => $dateDiff\n});\nmodule.exports = __toCommonJS(dateDiff_exports);\nvar import_core = __webpack_require__(2760);\nvar import_internal = __webpack_require__(1277);\nconst $dateDiff = (obj, expr, options) => {\n  const { startDate, endDate, unit, timezone, startOfWeek } = (0, import_core.computeValue)(\n    obj,\n    expr,\n    null,\n    options\n  );\n  const d1 = new Date(startDate);\n  const d2 = new Date(endDate);\n  const minuteOffset = (0, import_internal.parseTimezone)(timezone);\n  (0, import_internal.adjustDate)(d1, minuteOffset);\n  (0, import_internal.adjustDate)(d2, minuteOffset);\n  switch (unit) {\n    case \"year\":\n      return (0, import_internal.dateDiffYear)(d1, d2);\n    case \"quarter\":\n      return (0, import_internal.dateDiffQuarter)(d1, d2);\n    case \"month\":\n      return (0, import_internal.dateDiffMonth)(d1, d2);\n    case \"week\":\n      return (0, import_internal.dateDiffWeek)(d1, d2, startOfWeek);\n    case \"day\":\n      return (0, import_internal.dateDiffDay)(d1, d2);\n    case \"hour\":\n      return (0, import_internal.dateDiffHour)(d1, d2);\n    case \"minute\":\n      d1.setUTCSeconds(0);\n      d1.setUTCMilliseconds(0);\n      d2.setUTCSeconds(0);\n      d2.setUTCMilliseconds(0);\n      return Math.round(\n        (d2.getTime() - d1.getTime()) / import_internal.TIMEUNIT_IN_MILLIS[unit]\n      );\n    default:\n      return Math.round(\n        (d2.getTime() - d1.getTime()) / import_internal.TIMEUNIT_IN_MILLIS[unit]\n      );\n  }\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 611:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateFromParts_exports = {};\n__export(dateFromParts_exports, {\n  $dateFromParts: () => $dateFromParts\n});\nmodule.exports = __toCommonJS(dateFromParts_exports);\nvar import_core = __webpack_require__(2760);\nvar import_internal = __webpack_require__(1277);\nconst DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\nconst getDaysInMonth = (date) => {\n  return date.month == 2 && (0, import_internal.isLeapYear)(date.year) ? 29 : DAYS_IN_MONTH[date.month - 1];\n};\nconst $dateFromParts = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const minuteOffset = (0, import_internal.parseTimezone)(args.timezone);\n  for (let i = import_internal.DATE_PART_INTERVAL.length - 1, remainder = 0; i >= 0; i--) {\n    const datePartInterval = import_internal.DATE_PART_INTERVAL[i];\n    const k = datePartInterval[0];\n    const min = datePartInterval[1];\n    const max = datePartInterval[2];\n    let part = (args[k] || 0) + remainder;\n    remainder = 0;\n    const limit = max + 1;\n    if (k == \"hour\") part += Math.floor(minuteOffset / import_internal.MINUTES_PER_HOUR) * -1;\n    if (k == \"minute\") part += minuteOffset % import_internal.MINUTES_PER_HOUR * -1;\n    if (part < min) {\n      const delta = min - part;\n      remainder = -1 * Math.ceil(delta / limit);\n      part = limit - delta % limit;\n    } else if (part > max) {\n      part += min;\n      remainder = Math.trunc(part / limit);\n      part %= limit;\n    }\n    args[k] = part;\n  }\n  args.day = Math.min(args.day, getDaysInMonth(args));\n  return new Date(\n    Date.UTC(\n      args.year,\n      args.month - 1,\n      args.day,\n      args.hour,\n      args.minute,\n      args.second,\n      args.millisecond\n    )\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5268:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateFromString_exports = {};\n__export(dateFromString_exports, {\n  $dateFromString: () => $dateFromString\n});\nmodule.exports = __toCommonJS(dateFromString_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(1277);\nconst buildMap = (letters, sign) => {\n  const h = {};\n  letters.split(\"\").forEach((v, i) => h[v] = sign * (i + 1));\n  return h;\n};\nconst TZ_LETTER_OFFSETS = {\n  ...buildMap(\"ABCDEFGHIKLM\", 1),\n  ...buildMap(\"NOPQRSTUVWXY\", -1),\n  Z: 0\n};\nconst regexStrip = (s) => s.replace(/^\\//, \"\").replace(/\\/$/, \"\");\nconst REGEX_SPECIAL_CHARS = [\"^\", \".\", \"-\", \"*\", \"?\", \"$\"];\nconst regexQuote = (s) => {\n  REGEX_SPECIAL_CHARS.forEach((c) => {\n    s = s.replace(c, `\\\\${c}`);\n  });\n  return s;\n};\nconst $dateFromString = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  args.format = args.format || import_internal.DATE_FORMAT;\n  args.onNull = args.onNull || null;\n  let dateString = args.dateString;\n  if ((0, import_util.isNil)(dateString)) return args.onNull;\n  const separators = args.format.split(/%[YGmdHMSLuVzZ]/);\n  separators.reverse();\n  const matches = args.format.match(\n    /(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%V|%z|%Z)/g\n  );\n  const dateParts = {};\n  let expectedPattern = \"\";\n  for (let i = 0, len = matches.length; i < len; i++) {\n    const formatSpecifier = matches[i];\n    const props = import_internal.DATE_SYM_TABLE[formatSpecifier];\n    if ((0, import_util.isObject)(props)) {\n      const m2 = props.re.exec(dateString);\n      const delimiter = separators.pop() || \"\";\n      if (m2 !== null) {\n        dateParts[props.name] = /^\\d+$/.exec(m2[0]) ? parseInt(m2[0]) : m2[0];\n        dateString = dateString.substr(0, m2.index) + dateString.substr(m2.index + m2[0].length);\n        expectedPattern += regexQuote(delimiter) + regexStrip(props.re.toString());\n      } else {\n        dateParts[props.name] = null;\n      }\n    }\n  }\n  if ((0, import_util.isNil)(dateParts.year) || (0, import_util.isNil)(dateParts.month) || (0, import_util.isNil)(dateParts.day) || !new RegExp(\"^\" + expectedPattern + \"[A-Z]?$\").exec(args.dateString)) {\n    return args.onError;\n  }\n  const m = args.dateString.match(/([A-Z])$/);\n  (0, import_util.assert)(\n    // only one of in-date timeone or timezone argument but not both.\n    !(m && args.timezone),\n    `$dateFromString: you cannot pass in a date/time string with time zone information ('${m && m[0]}') together with a timezone argument`\n  );\n  const minuteOffset = m ? TZ_LETTER_OFFSETS[m[0]] * import_internal.MINUTES_PER_HOUR : (0, import_internal.parseTimezone)(args.timezone);\n  const d = new Date(\n    Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0)\n  );\n  if (!(0, import_util.isNil)(dateParts.hour)) d.setUTCHours(dateParts.hour);\n  if (!(0, import_util.isNil)(dateParts.minute)) d.setUTCMinutes(dateParts.minute);\n  if (!(0, import_util.isNil)(dateParts.second)) d.setUTCSeconds(dateParts.second);\n  if (!(0, import_util.isNil)(dateParts.millisecond))\n    d.setUTCMilliseconds(dateParts.millisecond);\n  (0, import_internal.adjustDate)(d, -minuteOffset);\n  return d;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5817:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateSubtract_exports = {};\n__export(dateSubtract_exports, {\n  $dateSubtract: () => $dateSubtract\n});\nmodule.exports = __toCommonJS(dateSubtract_exports);\nvar import_core = __webpack_require__(2760);\nvar import_dateAdd = __webpack_require__(8410);\nconst $dateSubtract = (obj, expr, options) => {\n  const amount = (0, import_core.computeValue)(obj, expr?.amount, null, options);\n  return (0, import_dateAdd.$dateAdd)(obj, { ...expr, amount: -1 * amount }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 112:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateToParts_exports = {};\n__export(dateToParts_exports, {\n  $dateToParts: () => $dateToParts\n});\nmodule.exports = __toCommonJS(dateToParts_exports);\nvar import_core = __webpack_require__(2760);\nvar import_internal = __webpack_require__(1277);\nconst $dateToParts = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const d = new Date(args.date);\n  const tz = (0, import_internal.parseTimezone)(args.timezone);\n  (0, import_internal.adjustDate)(d, tz);\n  const timePart = {\n    hour: d.getUTCHours(),\n    minute: d.getUTCMinutes(),\n    second: d.getUTCSeconds(),\n    millisecond: d.getUTCMilliseconds()\n  };\n  if (args.iso8601 == true) {\n    return Object.assign(timePart, {\n      isoWeekYear: (0, import_internal.isoWeekYear)(d),\n      isoWeek: (0, import_internal.isoWeek)(d),\n      isoDayOfWeek: d.getUTCDay() || 7\n    });\n  }\n  return Object.assign(timePart, {\n    year: d.getUTCFullYear(),\n    month: d.getUTCMonth() + 1,\n    day: d.getUTCDate()\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7165:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateToString_exports = {};\n__export(dateToString_exports, {\n  $dateToString: () => $dateToString\n});\nmodule.exports = __toCommonJS(dateToString_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(1277);\nvar import_dayOfMonth = __webpack_require__(2470);\nvar import_hour = __webpack_require__(4067);\nvar import_isoDayOfWeek = __webpack_require__(1125);\nvar import_isoWeek = __webpack_require__(612);\nvar import_millisecond = __webpack_require__(7216);\nvar import_minute = __webpack_require__(949);\nvar import_month = __webpack_require__(7711);\nvar import_second = __webpack_require__(9549);\nvar import_week = __webpack_require__(2813);\nvar import_year = __webpack_require__(2880);\nconst DATE_FUNCTIONS = {\n  \"%Y\": import_year.$year,\n  \"%G\": import_year.$year,\n  \"%m\": import_month.$month,\n  \"%d\": import_dayOfMonth.$dayOfMonth,\n  \"%H\": import_hour.$hour,\n  \"%M\": import_minute.$minute,\n  \"%S\": import_second.$second,\n  \"%L\": import_millisecond.$millisecond,\n  \"%u\": import_isoDayOfWeek.$isoDayOfWeek,\n  \"%U\": import_week.$week,\n  \"%V\": import_isoWeek.$isoWeek\n};\nconst $dateToString = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args.onNull)) args.onNull = null;\n  if ((0, import_util.isNil)(args.date)) return args.onNull;\n  const date = (0, import_internal.computeDate)(obj, args.date, options);\n  let format = args.format || import_internal.DATE_FORMAT;\n  const minuteOffset = (0, import_internal.parseTimezone)(args.timezone);\n  const matches = format.match(/(%%|%Y|%G|%m|%d|%H|%M|%S|%L|%u|%U|%V|%z|%Z)/g);\n  (0, import_internal.adjustDate)(date, minuteOffset);\n  for (let i = 0, len = matches.length; i < len; i++) {\n    const formatSpecifier = matches[i];\n    const props = import_internal.DATE_SYM_TABLE[formatSpecifier];\n    const operatorFn = DATE_FUNCTIONS[formatSpecifier];\n    let value;\n    if ((0, import_util.isObject)(props)) {\n      if (props.name === \"timezone\") {\n        value = (0, import_internal.formatTimezone)(minuteOffset);\n      } else if (props.name === \"minuteOffset\") {\n        value = minuteOffset.toString();\n      } else {\n        (0, import_util.assert)(\n          !!operatorFn,\n          `unsupported date format specifier '${formatSpecifier}'`\n        );\n        value = (0, import_internal.padDigits)(operatorFn(obj, date, options), props.padding);\n      }\n    }\n    format = format.replace(formatSpecifier, value);\n  }\n  return format;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9791:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dateTrunc_exports = {};\n__export(dateTrunc_exports, {\n  $dateTrunc: () => $dateTrunc\n});\nmodule.exports = __toCommonJS(dateTrunc_exports);\nvar import_core = __webpack_require__(2760);\nvar import_types = __webpack_require__(486);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(1277);\nconst REF_DATE_MILLIS = 9466848e5;\nconst distanceToBinLowerBound = (value, binSize) => {\n  let remainder = value % binSize;\n  if (remainder < 0) {\n    remainder += binSize;\n  }\n  return remainder;\n};\nconst DATE_DIFF_FN = {\n  day: import_internal.dateDiffDay,\n  month: import_internal.dateDiffMonth,\n  quarter: import_internal.dateDiffQuarter,\n  year: import_internal.dateDiffYear\n};\nconst $dateTrunc = (obj, expr, options) => {\n  const {\n    date,\n    unit,\n    binSize: optBinSize,\n    timezone,\n    startOfWeek: optStartOfWeek\n  } = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(date) || (0, import_util.isNil)(unit)) return null;\n  const startOfWeek = (optStartOfWeek ?? \"sun\").toLowerCase().substring(0, 3);\n  (0, import_util.assert)(\n    (0, import_util.isDate)(date),\n    \"$dateTrunc: 'date' must resolve to a valid Date object.\"\n  );\n  (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), \"$dateTrunc: unit is invalid.\");\n  (0, import_util.assert)(\n    unit != \"week\" || import_internal.DAYS_OF_WEEK_SET.has(startOfWeek),\n    `$dateTrunc: startOfWeek '${startOfWeek}' is not a valid.`\n  );\n  (0, import_util.assert)(\n    (0, import_util.isNil)(optBinSize) || optBinSize > 0,\n    \"$dateTrunc requires 'binSize' to be greater than 0, but got value 0.\"\n  );\n  const binSize = optBinSize ?? 1;\n  switch (unit) {\n    case \"millisecond\":\n    case \"second\":\n    case \"minute\":\n    case \"hour\": {\n      const binSizeMillis = binSize * import_internal.TIMEUNIT_IN_MILLIS[unit];\n      const shiftedDate = date.getTime() - REF_DATE_MILLIS;\n      return new Date(\n        date.getTime() - distanceToBinLowerBound(shiftedDate, binSizeMillis)\n      );\n    }\n    default: {\n      (0, import_util.assert)(binSize <= 1e11, \"dateTrunc unsupported binSize value\");\n      const d = new Date(date);\n      const refPointDate = new Date(REF_DATE_MILLIS);\n      let distanceFromRefPoint = 0;\n      if (unit == \"week\") {\n        const refPointDayOfWeek = (0, import_internal.isoWeekday)(refPointDate, startOfWeek);\n        const daysToAdjustBy = (import_internal.DAYS_PER_WEEK - refPointDayOfWeek) % import_internal.DAYS_PER_WEEK;\n        refPointDate.setTime(\n          refPointDate.getTime() + daysToAdjustBy * import_internal.TIMEUNIT_IN_MILLIS.day\n        );\n        distanceFromRefPoint = (0, import_internal.dateDiffWeek)(refPointDate, d, startOfWeek);\n      } else {\n        distanceFromRefPoint = DATE_DIFF_FN[unit](refPointDate, d);\n      }\n      const binLowerBoundFromRefPoint = distanceFromRefPoint - distanceToBinLowerBound(distanceFromRefPoint, binSize);\n      const newDate = (0, import_internal.dateAdd)(\n        refPointDate,\n        unit,\n        binLowerBoundFromRefPoint,\n        timezone\n      );\n      const minuteOffset = (0, import_internal.parseTimezone)(timezone);\n      (0, import_internal.adjustDate)(newDate, -minuteOffset);\n      return newDate;\n    }\n  }\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2470:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dayOfMonth_exports = {};\n__export(dayOfMonth_exports, {\n  $dayOfMonth: () => $dayOfMonth\n});\nmodule.exports = __toCommonJS(dayOfMonth_exports);\nvar import_internal = __webpack_require__(1277);\nconst $dayOfMonth = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCDate();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5998:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dayOfWeek_exports = {};\n__export(dayOfWeek_exports, {\n  $dayOfWeek: () => $dayOfWeek\n});\nmodule.exports = __toCommonJS(dayOfWeek_exports);\nvar import_internal = __webpack_require__(1277);\nconst $dayOfWeek = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCDay() + 1;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7107:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar dayOfYear_exports = {};\n__export(dayOfYear_exports, {\n  $dayOfYear: () => $dayOfYear\n});\nmodule.exports = __toCommonJS(dayOfYear_exports);\nvar import_internal = __webpack_require__(1277);\nconst $dayOfYear = (obj, expr, options) => {\n  return (0, import_internal.dayOfYear)((0, import_internal.computeDate)(obj, expr, options));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4067:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar hour_exports = {};\n__export(hour_exports, {\n  $hour: () => $hour\n});\nmodule.exports = __toCommonJS(hour_exports);\nvar import_internal = __webpack_require__(1277);\nconst $hour = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCHours();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3381:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar date_exports = {};\nmodule.exports = __toCommonJS(date_exports);\n__reExport(date_exports, __webpack_require__(8410), module.exports);\n__reExport(date_exports, __webpack_require__(9178), module.exports);\n__reExport(date_exports, __webpack_require__(611), module.exports);\n__reExport(date_exports, __webpack_require__(5268), module.exports);\n__reExport(date_exports, __webpack_require__(5817), module.exports);\n__reExport(date_exports, __webpack_require__(112), module.exports);\n__reExport(date_exports, __webpack_require__(7165), module.exports);\n__reExport(date_exports, __webpack_require__(9791), module.exports);\n__reExport(date_exports, __webpack_require__(2470), module.exports);\n__reExport(date_exports, __webpack_require__(5998), module.exports);\n__reExport(date_exports, __webpack_require__(7107), module.exports);\n__reExport(date_exports, __webpack_require__(4067), module.exports);\n__reExport(date_exports, __webpack_require__(1125), module.exports);\n__reExport(date_exports, __webpack_require__(612), module.exports);\n__reExport(date_exports, __webpack_require__(5373), module.exports);\n__reExport(date_exports, __webpack_require__(7216), module.exports);\n__reExport(date_exports, __webpack_require__(949), module.exports);\n__reExport(date_exports, __webpack_require__(7711), module.exports);\n__reExport(date_exports, __webpack_require__(9549), module.exports);\n__reExport(date_exports, __webpack_require__(2813), module.exports);\n__reExport(date_exports, __webpack_require__(2880), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1125:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar isoDayOfWeek_exports = {};\n__export(isoDayOfWeek_exports, {\n  $isoDayOfWeek: () => $isoDayOfWeek\n});\nmodule.exports = __toCommonJS(isoDayOfWeek_exports);\nvar import_internal = __webpack_require__(1277);\nconst $isoDayOfWeek = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCDay() || 7;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 612:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar isoWeek_exports = {};\n__export(isoWeek_exports, {\n  $isoWeek: () => $isoWeek\n});\nmodule.exports = __toCommonJS(isoWeek_exports);\nvar import_internal = __webpack_require__(1277);\nconst $isoWeek = (obj, expr, options) => {\n  return (0, import_internal.isoWeek)((0, import_internal.computeDate)(obj, expr, options));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5373:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar isoWeekYear_exports = {};\n__export(isoWeekYear_exports, {\n  $isoWeekYear: () => $isoWeekYear\n});\nmodule.exports = __toCommonJS(isoWeekYear_exports);\nvar import_internal = __webpack_require__(1277);\nconst $isoWeekYear = (obj, expr, options) => (0, import_internal.isoWeekYear)((0, import_internal.computeDate)(obj, expr, options));\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7216:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar millisecond_exports = {};\n__export(millisecond_exports, {\n  $millisecond: () => $millisecond\n});\nmodule.exports = __toCommonJS(millisecond_exports);\nvar import_internal = __webpack_require__(1277);\nconst $millisecond = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCMilliseconds();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 949:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar minute_exports = {};\n__export(minute_exports, {\n  $minute: () => $minute\n});\nmodule.exports = __toCommonJS(minute_exports);\nvar import_internal = __webpack_require__(1277);\nconst $minute = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCMinutes();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7711:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar month_exports = {};\n__export(month_exports, {\n  $month: () => $month\n});\nmodule.exports = __toCommonJS(month_exports);\nvar import_internal = __webpack_require__(1277);\nconst $month = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCMonth() + 1;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9549:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar second_exports = {};\n__export(second_exports, {\n  $second: () => $second\n});\nmodule.exports = __toCommonJS(second_exports);\nvar import_internal = __webpack_require__(1277);\nconst $second = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCSeconds();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2813:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar week_exports = {};\n__export(week_exports, {\n  $week: () => $week\n});\nmodule.exports = __toCommonJS(week_exports);\nvar import_internal = __webpack_require__(1277);\nconst $week = (obj, expr, options) => {\n  const d = (0, import_internal.computeDate)(obj, expr, options);\n  const result = (0, import_internal.isoWeek)(d);\n  if (d.getUTCDay() > 0 && d.getUTCDate() == 1 && d.getUTCMonth() == 0)\n    return 0;\n  if (d.getUTCDay() == 0) return result + 1;\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2880:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar year_exports = {};\n__export(year_exports, {\n  $year: () => $year\n});\nmodule.exports = __toCommonJS(year_exports);\nvar import_internal = __webpack_require__(1277);\nconst $year = (obj, expr, options) => {\n  return (0, import_internal.computeDate)(obj, expr, options).getUTCFullYear();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5764:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar expression_exports = {};\nmodule.exports = __toCommonJS(expression_exports);\n__reExport(expression_exports, __webpack_require__(4125), module.exports);\n__reExport(expression_exports, __webpack_require__(2846), module.exports);\n__reExport(expression_exports, __webpack_require__(5148), module.exports);\n__reExport(expression_exports, __webpack_require__(1703), module.exports);\n__reExport(expression_exports, __webpack_require__(3336), module.exports);\n__reExport(expression_exports, __webpack_require__(5459), module.exports);\n__reExport(expression_exports, __webpack_require__(6518), module.exports);\n__reExport(expression_exports, __webpack_require__(3381), module.exports);\n__reExport(expression_exports, __webpack_require__(5535), module.exports);\n__reExport(expression_exports, __webpack_require__(6808), module.exports);\n__reExport(expression_exports, __webpack_require__(6789), module.exports);\n__reExport(expression_exports, __webpack_require__(3450), module.exports);\n__reExport(expression_exports, __webpack_require__(5053), module.exports);\n__reExport(expression_exports, __webpack_require__(5731), module.exports);\n__reExport(expression_exports, __webpack_require__(7620), module.exports);\n__reExport(expression_exports, __webpack_require__(7367), module.exports);\n__reExport(expression_exports, __webpack_require__(1377), module.exports);\n__reExport(expression_exports, __webpack_require__(2537), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5535:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar literal_exports = {};\n__export(literal_exports, {\n  $literal: () => $literal\n});\nmodule.exports = __toCommonJS(literal_exports);\nconst $literal = (_obj, expr, _options) => expr;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6808:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar median_exports = {};\n__export(median_exports, {\n  $median: () => $median\n});\nmodule.exports = __toCommonJS(median_exports);\nvar import_core = __webpack_require__(2760);\nvar import_median = __webpack_require__(9524);\nconst $median = (obj, expr, options) => {\n  const input = (0, import_core.computeValue)(obj, expr.input, null, options);\n  return (0, import_median.$median)(input, { input: \"$$CURRENT\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 257:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar getField_exports = {};\n__export(getField_exports, {\n  $getField: () => $getField\n});\nmodule.exports = __toCommonJS(getField_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $getField = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const [field, input] = (0, import_util.isObject)(args) ? [args.field, args.input || obj] : [args, obj];\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isObject)(input),\n    \"$getField expression 'input' must evaluate to an object\"\n  );\n  (0, import_util.assert)(\n    (0, import_util.isString)(field),\n    \"$getField expression 'field' must evaluate to a string\"\n  );\n  return input[field];\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6789:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar misc_exports = {};\nmodule.exports = __toCommonJS(misc_exports);\n__reExport(misc_exports, __webpack_require__(257), module.exports);\n__reExport(misc_exports, __webpack_require__(438), module.exports);\n__reExport(misc_exports, __webpack_require__(5969), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 438:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar rand_exports = {};\n__export(rand_exports, {\n  $rand: () => $rand\n});\nmodule.exports = __toCommonJS(rand_exports);\nconst $rand = (_obj, _expr, _options) => Math.random();\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5969:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sampleRate_exports = {};\n__export(sampleRate_exports, {\n  $sampleRate: () => $sampleRate\n});\nmodule.exports = __toCommonJS(sampleRate_exports);\nvar import_core = __webpack_require__(2760);\nconst $sampleRate = (obj, expr, options) => Math.random() <= (0, import_core.computeValue)(obj, expr, null, options);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3450:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar object_exports = {};\nmodule.exports = __toCommonJS(object_exports);\n__reExport(object_exports, __webpack_require__(4420), module.exports);\n__reExport(object_exports, __webpack_require__(5013), module.exports);\n__reExport(object_exports, __webpack_require__(4392), module.exports);\n__reExport(object_exports, __webpack_require__(5159), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4420:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar mergeObjects_exports = {};\n__export(mergeObjects_exports, {\n  $mergeObjects: () => $mergeObjects\n});\nmodule.exports = __toCommonJS(mergeObjects_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $mergeObjects = (obj, expr, options) => {\n  const docs = (0, import_core.computeValue)(obj, expr, null, options) ?? [];\n  const acc = {};\n  for (const o of docs) {\n    if ((0, import_util.isNil)(o)) continue;\n    for (const k of Object.keys(o)) {\n      if (o[k] !== void 0) acc[k] = o[k];\n    }\n  }\n  return acc;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5013:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar objectToArray_exports = {};\n__export(objectToArray_exports, {\n  $objectToArray: () => $objectToArray\n});\nmodule.exports = __toCommonJS(objectToArray_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $objectToArray = (obj, expr, options) => {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(val)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isObject)(val),\n    `$objectToArray requires a document input, found: ${(0, import_util.typeOf)(val)}`\n  );\n  const entries = Object.entries(val);\n  const result = new Array(entries.length);\n  let i = 0;\n  for (const [k, v] of entries) {\n    result[i++] = { k, v };\n  }\n  return result;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4392:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setField_exports = {};\n__export(setField_exports, {\n  $setField: () => $setField\n});\nmodule.exports = __toCommonJS(setField_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setField = (obj, expr, options) => {\n  const { input, field, value } = (0, import_core.computeValue)(\n    obj,\n    expr,\n    null,\n    options\n  );\n  if ((0, import_util.isNil)(input)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isObject)(input),\n    \"$setField expression 'input' must evaluate to an object\"\n  );\n  (0, import_util.assert)(\n    (0, import_util.isString)(field),\n    \"$setField expression 'field' must evaluate to a string\"\n  );\n  if (expr.value == \"$$REMOVE\") {\n    delete obj[field];\n  } else {\n    obj[field] = value;\n  }\n  return obj;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5159:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar unsetField_exports = {};\n__export(unsetField_exports, {\n  $unsetField: () => $unsetField\n});\nmodule.exports = __toCommonJS(unsetField_exports);\nvar import_setField = __webpack_require__(4392);\nconst $unsetField = (obj, expr, options) => {\n  return (0, import_setField.$setField)(\n    obj,\n    {\n      ...expr,\n      value: \"$$REMOVE\"\n    },\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5053:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar percentile_exports = {};\n__export(percentile_exports, {\n  $percentile: () => $percentile\n});\nmodule.exports = __toCommonJS(percentile_exports);\nvar import_core = __webpack_require__(2760);\nvar import_percentile = __webpack_require__(6393);\nconst $percentile = (obj, expr, options) => {\n  const input = (0, import_core.computeValue)(obj, expr.input, null, options);\n  return (0, import_percentile.$percentile)(input, { ...expr, input: \"$$CURRENT\" }, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 337:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar allElementsTrue_exports = {};\n__export(allElementsTrue_exports, {\n  $allElementsTrue: () => $allElementsTrue\n});\nmodule.exports = __toCommonJS(allElementsTrue_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $allElementsTrue = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options)[0];\n  return args.every((v) => (0, import_util.truthy)(v, options.useStrictMode));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2961:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar anyElementTrue_exports = {};\n__export(anyElementTrue_exports, {\n  $anyElementTrue: () => $anyElementTrue\n});\nmodule.exports = __toCommonJS(anyElementTrue_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $anyElementTrue = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options)[0];\n  return args.some((v) => (0, import_util.truthy)(v, options.useStrictMode));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5731:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar set_exports = {};\nmodule.exports = __toCommonJS(set_exports);\n__reExport(set_exports, __webpack_require__(337), module.exports);\n__reExport(set_exports, __webpack_require__(2961), module.exports);\n__reExport(set_exports, __webpack_require__(9432), module.exports);\n__reExport(set_exports, __webpack_require__(1962), module.exports);\n__reExport(set_exports, __webpack_require__(7750), module.exports);\n__reExport(set_exports, __webpack_require__(8189), module.exports);\n__reExport(set_exports, __webpack_require__(1476), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9432:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setDifference_exports = {};\n__export(setDifference_exports, {\n  $setDifference: () => $setDifference\n});\nmodule.exports = __toCommonJS(setDifference_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setDifference = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(args), \"$setDifference must be an arrays.\");\n  if (args.some(import_util.isNil)) return null;\n  (0, import_util.assert)(args.length == 2, `$setDifference takes exactly 2 arguments.`);\n  (0, import_util.assert)(args.every(import_util.isArray), \"$setDifference operands must be arrays.\");\n  const m = import_util.ValueMap.init(options.hashFunction);\n  args[0].forEach((v) => m.set(v, true));\n  args[1].forEach((v) => m.delete(v));\n  return Array.from(m.keys());\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1962:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setEquals_exports = {};\n__export(setEquals_exports, {\n  $setEquals: () => $setEquals\n});\nmodule.exports = __toCommonJS(setEquals_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setEquals = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.every(import_util.isArray),\n    \"$setEquals operands must be arrays.\"\n  );\n  const map = import_util.ValueMap.init();\n  args[0].every((v, i) => map.set(v, i));\n  for (let i = 1; i < args.length; i++) {\n    const arr = args[i];\n    const set = /* @__PURE__ */ new Set();\n    for (let j = 0; j < arr.length; j++) {\n      const n = map.get(arr[j]) ?? -1;\n      if (n === -1) return false;\n      set.add(n);\n    }\n    if (set.size !== map.size) return false;\n  }\n  return true;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7750:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setIntersection_exports = {};\n__export(setIntersection_exports, {\n  $setIntersection: () => $setIntersection\n});\nmodule.exports = __toCommonJS(setIntersection_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setIntersection = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args)) return null;\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.every(import_util.isArray),\n    \"$setIntersection operands must be arrays.\"\n  );\n  return (0, import_util.intersection)(args, options?.hashFunction);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8189:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setIsSubset_exports = {};\n__export(setIsSubset_exports, {\n  $setIsSubset: () => $setIsSubset\n});\nmodule.exports = __toCommonJS(setIsSubset_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setIsSubset = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    (0, import_util.isArray)(args) && args.every(import_util.isArray),\n    \"$setIsSubset operands must be arrays.\"\n  );\n  const first = args[0];\n  const second = args[1];\n  const map = import_util.ValueMap.init();\n  const set = /* @__PURE__ */ new Set();\n  first.every((v, i) => map.set(v, i));\n  for (const v of second) {\n    set.add(map.get(v) ?? -1);\n    if (set.size > map.size) return true;\n  }\n  set.delete(-1);\n  return set.size == map.size;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1476:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setUnion_exports = {};\n__export(setUnion_exports, {\n  $setUnion: () => $setUnion\n});\nmodule.exports = __toCommonJS(setUnion_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $setUnion = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args)) return null;\n  (0, import_util.assert)((0, import_util.isArray)(args), \"$setUnion operands must be arrays.\");\n  if (args.some(import_util.isNil)) return null;\n  return (0, import_util.unique)((0, import_util.flatten)(args), options?.hashFunction);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9756:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  regexSearch: () => regexSearch,\n  trimString: () => trimString\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst WHITESPACE_CHARS = [\n  0,\n  // '\\0' Null character\n  32,\n  // ' ', Space\n  9,\n  // '\\t' Horizontal tab\n  10,\n  // '\\n' Line feed/new line\n  11,\n  // '\\v' Vertical tab\n  12,\n  // '\\f' Form feed\n  13,\n  // '\\r' Carriage return\n  160,\n  // Non-breaking space\n  5760,\n  // Ogham space mark\n  8192,\n  // En quad\n  8193,\n  // Em quad\n  8194,\n  // En space\n  8195,\n  // Em space\n  8196,\n  // Three-per-em space\n  8197,\n  // Four-per-em space\n  8198,\n  // Six-per-em space\n  8199,\n  // Figure space\n  8200,\n  // Punctuation space\n  8201,\n  // Thin space\n  8202\n  // Hair space\n];\nfunction trimString(obj, expr, options, trimOpts) {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  const s = val.input;\n  if ((0, import_util.isNil)(s)) return null;\n  const codepoints = (0, import_util.isNil)(val.chars) ? WHITESPACE_CHARS : val.chars.split(\"\").map((c) => c.codePointAt(0));\n  let i = 0;\n  let j = s.length - 1;\n  while (trimOpts.left && i <= j && codepoints.indexOf(s[i].codePointAt(0)) !== -1)\n    i++;\n  while (trimOpts.right && i <= j && codepoints.indexOf(s[j].codePointAt(0)) !== -1)\n    j--;\n  return s.substring(i, j + 1);\n}\nfunction regexSearch(obj, expr, options, reOpts) {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if (!(0, import_util.isString)(val.input)) return [];\n  const regexOptions = val.options;\n  if (regexOptions) {\n    (0, import_util.assert)(\n      regexOptions.indexOf(\"x\") === -1,\n      \"extended capability option 'x' not supported\"\n    );\n    (0, import_util.assert)(regexOptions.indexOf(\"g\") === -1, \"global option 'g' not supported\");\n  }\n  let input = val.input;\n  const re = new RegExp(val.regex, regexOptions);\n  let m;\n  const matches = new Array();\n  let offset = 0;\n  while (m = re.exec(input)) {\n    const result = {\n      match: m[0],\n      idx: m.index + offset,\n      captures: []\n    };\n    for (let i = 1; i < m.length; i++) result.captures.push(m[i] || null);\n    matches.push(result);\n    if (!reOpts.global) break;\n    offset = m.index + m[0].length;\n    input = input.substring(offset);\n  }\n  return matches;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3266:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar concat_exports = {};\n__export(concat_exports, {\n  $concat: () => $concat\n});\nmodule.exports = __toCommonJS(concat_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $concat = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  (0, import_util.assert)(\n    args.every((v) => (0, import_util.isString)(v) || (0, import_util.isNil)(v)),\n    \"$concat only supports strings.\"\n  );\n  if (args.some(import_util.isNil)) return null;\n  return args.join(\"\");\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7620:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar string_exports = {};\nmodule.exports = __toCommonJS(string_exports);\n__reExport(string_exports, __webpack_require__(3266), module.exports);\n__reExport(string_exports, __webpack_require__(6586), module.exports);\n__reExport(string_exports, __webpack_require__(9148), module.exports);\n__reExport(string_exports, __webpack_require__(7724), module.exports);\n__reExport(string_exports, __webpack_require__(7205), module.exports);\n__reExport(string_exports, __webpack_require__(3798), module.exports);\n__reExport(string_exports, __webpack_require__(1541), module.exports);\n__reExport(string_exports, __webpack_require__(6942), module.exports);\n__reExport(string_exports, __webpack_require__(6070), module.exports);\n__reExport(string_exports, __webpack_require__(1612), module.exports);\n__reExport(string_exports, __webpack_require__(9587), module.exports);\n__reExport(string_exports, __webpack_require__(7993), module.exports);\n__reExport(string_exports, __webpack_require__(415), module.exports);\n__reExport(string_exports, __webpack_require__(9635), module.exports);\n__reExport(string_exports, __webpack_require__(5332), module.exports);\n__reExport(string_exports, __webpack_require__(356), module.exports);\n__reExport(string_exports, __webpack_require__(2174), module.exports);\n__reExport(string_exports, __webpack_require__(6459), module.exports);\n__reExport(string_exports, __webpack_require__(5158), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6586:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar indexOfBytes_exports = {};\n__export(indexOfBytes_exports, {\n  $indexOfBytes: () => $indexOfBytes\n});\nmodule.exports = __toCommonJS(indexOfBytes_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $indexOfBytes = (obj, expr, options) => {\n  const arr = (0, import_core.computeValue)(obj, expr, null, options);\n  const errorMsg = \"$indexOfBytes expression resolves to invalid an argument\";\n  if ((0, import_util.isNil)(arr[0])) return null;\n  (0, import_util.assert)((0, import_util.isString)(arr[0]) && (0, import_util.isString)(arr[1]), errorMsg);\n  const str = arr[0];\n  const searchStr = arr[1];\n  let start = arr[2];\n  let end = arr[3];\n  let valid = (0, import_util.isNil)(start) || (0, import_util.isNumber)(start) && start >= 0 && Math.round(start) === start;\n  valid = valid && ((0, import_util.isNil)(end) || (0, import_util.isNumber)(end) && end >= 0 && Math.round(end) === end);\n  (0, import_util.assert)(valid, errorMsg);\n  start = start || 0;\n  end = end || str.length;\n  if (start > end) return -1;\n  const index = str.substring(start, end).indexOf(searchStr);\n  return index > -1 ? index + start : index;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9148:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ltrim_exports = {};\n__export(ltrim_exports, {\n  $ltrim: () => $ltrim\n});\nmodule.exports = __toCommonJS(ltrim_exports);\nvar import_internal = __webpack_require__(9756);\nconst $ltrim = (obj, expr, options) => {\n  return (0, import_internal.trimString)(obj, expr, options, { left: true, right: false });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7724:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar regexFind_exports = {};\n__export(regexFind_exports, {\n  $regexFind: () => $regexFind\n});\nmodule.exports = __toCommonJS(regexFind_exports);\nvar import_internal = __webpack_require__(9756);\nconst $regexFind = (obj, expr, options) => {\n  const result = (0, import_internal.regexSearch)(obj, expr, options, { global: false });\n  return result && result.length > 0 ? result[0] : null;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7205:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar regexFindAll_exports = {};\n__export(regexFindAll_exports, {\n  $regexFindAll: () => $regexFindAll\n});\nmodule.exports = __toCommonJS(regexFindAll_exports);\nvar import_internal = __webpack_require__(9756);\nconst $regexFindAll = (obj, expr, options) => {\n  return (0, import_internal.regexSearch)(obj, expr, options, { global: true });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3798:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar regexMatch_exports = {};\n__export(regexMatch_exports, {\n  $regexMatch: () => $regexMatch\n});\nmodule.exports = __toCommonJS(regexMatch_exports);\nvar import_internal = __webpack_require__(9756);\nconst $regexMatch = (obj, expr, options) => {\n  return (0, import_internal.regexSearch)(obj, expr, options, { global: false }).length != 0;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1541:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar replaceAll_exports = {};\n__export(replaceAll_exports, {\n  $replaceAll: () => $replaceAll\n});\nmodule.exports = __toCommonJS(replaceAll_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $replaceAll = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const arr = [args.input, args.find, args.replacement];\n  if (arr.some(import_util.isNil)) return null;\n  (0, import_util.assert)(\n    arr.every(import_util.isString),\n    \"$replaceAll expression fields must evaluate to string\"\n  );\n  return args.input.replace(new RegExp(args.find, \"g\"), args.replacement);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6942:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar replaceOne_exports = {};\n__export(replaceOne_exports, {\n  $replaceOne: () => $replaceOne\n});\nmodule.exports = __toCommonJS(replaceOne_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $replaceOne = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const arr = [args.input, args.find, args.replacement];\n  if (arr.some(import_util.isNil)) return null;\n  (0, import_util.assert)(\n    arr.every(import_util.isString),\n    \"$replaceOne expression fields must evaluate to string\"\n  );\n  return args.input.replace(args.find, args.replacement);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6070:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar rtrim_exports = {};\n__export(rtrim_exports, {\n  $rtrim: () => $rtrim\n});\nmodule.exports = __toCommonJS(rtrim_exports);\nvar import_internal = __webpack_require__(9756);\nconst $rtrim = (obj, expr, options) => {\n  return (0, import_internal.trimString)(obj, expr, options, { left: false, right: true });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1612:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar split_exports = {};\n__export(split_exports, {\n  $split: () => $split\n});\nmodule.exports = __toCommonJS(split_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $split = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(args[0])) return null;\n  (0, import_util.assert)(\n    args.every(import_util.isString),\n    \"$split expression must result to array(2) of strings\"\n  );\n  return args[0].split(args[1]);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7993:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar strLenBytes_exports = {};\n__export(strLenBytes_exports, {\n  $strLenBytes: () => $strLenBytes\n});\nmodule.exports = __toCommonJS(strLenBytes_exports);\nvar import_core = __webpack_require__(2760);\nconst $strLenBytes = (obj, expr, options) => {\n  return ~-encodeURI((0, import_core.computeValue)(obj, expr, null, options)).split(\n    /%..|./\n  ).length;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 415:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar strLenCP_exports = {};\n__export(strLenCP_exports, {\n  $strLenCP: () => $strLenCP\n});\nmodule.exports = __toCommonJS(strLenCP_exports);\nvar import_core = __webpack_require__(2760);\nconst $strLenCP = (obj, expr, options) => {\n  return (0, import_core.computeValue)(obj, expr, null, options).length;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9587:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar strcasecmp_exports = {};\n__export(strcasecmp_exports, {\n  $strcasecmp: () => $strcasecmp\n});\nmodule.exports = __toCommonJS(strcasecmp_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $strcasecmp = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  let a = args[0];\n  let b = args[1];\n  if ((0, import_util.isEqual)(a, b) || args.every(import_util.isNil)) return 0;\n  (0, import_util.assert)(\n    args.every(import_util.isString),\n    \"$strcasecmp must resolve to array(2) of strings\"\n  );\n  a = a.toUpperCase();\n  b = b.toUpperCase();\n  return a > b && 1 || a < b && -1 || 0;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9635:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar substr_exports = {};\n__export(substr_exports, {\n  $substr: () => $substr\n});\nmodule.exports = __toCommonJS(substr_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $substr = (obj, expr, options) => {\n  const [s, start, count] = (0, import_core.computeValue)(obj, expr, null, options);\n  if (start < 0 || !(0, import_util.isString)(s)) return \"\";\n  if (count < 0) return s.substring(start);\n  return s.substring(start, start + count);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5332:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar substrBytes_exports = {};\n__export(substrBytes_exports, {\n  $substrBytes: () => $substrBytes\n});\nmodule.exports = __toCommonJS(substrBytes_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst UTF8_MASK = [192, 224, 240];\nfunction toUtf8(n) {\n  if (n < 128) return [n];\n  let count = n < 2048 && 1 || n < 65536 && 2 || 3;\n  const offset = UTF8_MASK[count - 1];\n  const utf8 = [(n >> 6 * count) + offset];\n  while (count > 0) utf8.push(128 | n >> 6 * --count & 63);\n  return utf8;\n}\nfunction utf8Encode(s) {\n  const buf = [];\n  for (let i = 0, len = s.length; i < len; i++) {\n    buf.push(toUtf8(s.codePointAt(i)));\n  }\n  return buf;\n}\nconst $substrBytes = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  const s = args[0];\n  const index = args[1];\n  const count = args[2];\n  (0, import_util.assert)(\n    (0, import_util.isString)(s) && (0, import_util.isNumber)(index) && index >= 0 && (0, import_util.isNumber)(count) && count >= 0,\n    \"$substrBytes: invalid arguments\"\n  );\n  const buf = utf8Encode(s);\n  const validIndex = [];\n  let acc = 0;\n  for (let i = 0; i < buf.length; i++) {\n    validIndex.push(acc);\n    acc += buf[i].length;\n  }\n  const begin = validIndex.indexOf(index);\n  const end = validIndex.indexOf(index + count);\n  (0, import_util.assert)(\n    begin > -1 && end > -1,\n    \"$substrBytes: invalid range, start or end index is a UTF-8 continuation byte.\"\n  );\n  return s.substring(begin, end);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 356:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar substrCP_exports = {};\n__export(substrCP_exports, {\n  $substrCP: () => $substrCP\n});\nmodule.exports = __toCommonJS(substrCP_exports);\nvar import_substr = __webpack_require__(9635);\nconst $substrCP = (obj, expr, options) => {\n  return (0, import_substr.$substr)(obj, expr, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2174:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toLower_exports = {};\n__export(toLower_exports, {\n  $toLower: () => $toLower\n});\nmodule.exports = __toCommonJS(toLower_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $toLower = (obj, expr, options) => {\n  const value = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.isEmpty)(value) ? \"\" : value.toLowerCase();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6459:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toUpper_exports = {};\n__export(toUpper_exports, {\n  $toUpper: () => $toUpper\n});\nmodule.exports = __toCommonJS(toUpper_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $toUpper = (obj, expr, options) => {\n  const value = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.isEmpty)(value) ? \"\" : value.toUpperCase();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5158:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar trim_exports = {};\n__export(trim_exports, {\n  $trim: () => $trim\n});\nmodule.exports = __toCommonJS(trim_exports);\nvar import_internal = __webpack_require__(9756);\nconst $trim = (obj, expr, options) => {\n  return (0, import_internal.trimString)(obj, expr, options, { left: true, right: true });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1291:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  createTrignometryOperator: () => createTrignometryOperator\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst FIXED_POINTS = {\n  undefined: null,\n  null: null,\n  NaN: NaN,\n  Infinity: new Error(),\n  \"-Infinity\": new Error()\n};\nfunction createTrignometryOperator(f, fixedPoints = FIXED_POINTS) {\n  const fp = Object.assign({}, FIXED_POINTS, fixedPoints);\n  const keySet = new Set(Object.keys(fp));\n  return (obj, expr, options) => {\n    const n = (0, import_core.computeValue)(obj, expr, null, options);\n    if (keySet.has(`${n}`)) {\n      const res = fp[`${n}`];\n      if (res instanceof Error) {\n        throw new import_util.MingoError(\n          `cannot apply $${f.name} to -inf, value must in (-inf,inf)`\n        );\n      }\n      return res;\n    }\n    return f(n);\n  };\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1025:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar acos_exports = {};\n__export(acos_exports, {\n  $acos: () => $acos\n});\nmodule.exports = __toCommonJS(acos_exports);\nvar import_internal = __webpack_require__(1291);\nconst $acos = (0, import_internal.createTrignometryOperator)(Math.acos, {\n  Infinity: Infinity,\n  0: new Error()\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9637:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar acosh_exports = {};\n__export(acosh_exports, {\n  $acosh: () => $acosh\n});\nmodule.exports = __toCommonJS(acosh_exports);\nvar import_internal = __webpack_require__(1291);\nconst $acosh = (0, import_internal.createTrignometryOperator)(Math.acosh, {\n  Infinity: Infinity,\n  0: new Error()\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8000:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar asin_exports = {};\n__export(asin_exports, {\n  $asin: () => $asin\n});\nmodule.exports = __toCommonJS(asin_exports);\nvar import_internal = __webpack_require__(1291);\nconst $asin = (0, import_internal.createTrignometryOperator)(Math.asin);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8634:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar asinh_exports = {};\n__export(asinh_exports, {\n  $asinh: () => $asinh\n});\nmodule.exports = __toCommonJS(asinh_exports);\nvar import_internal = __webpack_require__(1291);\nconst $asinh = (0, import_internal.createTrignometryOperator)(Math.asinh, {\n  Infinity: Infinity,\n  \"-Infinity\": -Infinity\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5285:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar atan_exports = {};\n__export(atan_exports, {\n  $atan: () => $atan\n});\nmodule.exports = __toCommonJS(atan_exports);\nvar import_internal = __webpack_require__(1291);\nconst $atan = (0, import_internal.createTrignometryOperator)(Math.atan);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5991:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar atan2_exports = {};\n__export(atan2_exports, {\n  $atan2: () => $atan2\n});\nmodule.exports = __toCommonJS(atan2_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $atan2 = (obj, expr, options) => {\n  const [y, x] = (0, import_core.computeValue)(obj, expr, null, options);\n  if (isNaN(y) || (0, import_util.isNil)(y)) return y;\n  if (isNaN(x) || (0, import_util.isNil)(x)) return x;\n  return Math.atan2(y, x);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9825:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar atanh_exports = {};\n__export(atanh_exports, {\n  $atanh: () => $atanh\n});\nmodule.exports = __toCommonJS(atanh_exports);\nvar import_internal = __webpack_require__(1291);\nconst $atanh = (0, import_internal.createTrignometryOperator)(Math.atanh, {\n  1: Infinity,\n  \"-1\": -Infinity\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3676:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar cos_exports = {};\n__export(cos_exports, {\n  $cos: () => $cos\n});\nmodule.exports = __toCommonJS(cos_exports);\nvar import_internal = __webpack_require__(1291);\nconst $cos = (0, import_internal.createTrignometryOperator)(Math.cos);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5310:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar cosh_exports = {};\n__export(cosh_exports, {\n  $cosh: () => $cosh\n});\nmodule.exports = __toCommonJS(cosh_exports);\nvar import_internal = __webpack_require__(1291);\nconst $cosh = (0, import_internal.createTrignometryOperator)(Math.cosh, {\n  \"-Infinity\": Infinity,\n  Infinity: Infinity\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 757:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar degreesToRadians_exports = {};\n__export(degreesToRadians_exports, {\n  $degreesToRadians: () => $degreesToRadians\n});\nmodule.exports = __toCommonJS(degreesToRadians_exports);\nvar import_internal = __webpack_require__(1291);\nconst RADIANS_FACTOR = Math.PI / 180;\nconst $degreesToRadians = (0, import_internal.createTrignometryOperator)(\n  (n) => n * RADIANS_FACTOR,\n  {\n    Infinity: Infinity,\n    \"-Infinity\": Infinity\n  }\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7367:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar trignometry_exports = {};\nmodule.exports = __toCommonJS(trignometry_exports);\n__reExport(trignometry_exports, __webpack_require__(1025), module.exports);\n__reExport(trignometry_exports, __webpack_require__(9637), module.exports);\n__reExport(trignometry_exports, __webpack_require__(8000), module.exports);\n__reExport(trignometry_exports, __webpack_require__(8634), module.exports);\n__reExport(trignometry_exports, __webpack_require__(5285), module.exports);\n__reExport(trignometry_exports, __webpack_require__(5991), module.exports);\n__reExport(trignometry_exports, __webpack_require__(9825), module.exports);\n__reExport(trignometry_exports, __webpack_require__(3676), module.exports);\n__reExport(trignometry_exports, __webpack_require__(5310), module.exports);\n__reExport(trignometry_exports, __webpack_require__(757), module.exports);\n__reExport(trignometry_exports, __webpack_require__(5183), module.exports);\n__reExport(trignometry_exports, __webpack_require__(7969), module.exports);\n__reExport(trignometry_exports, __webpack_require__(9589), module.exports);\n__reExport(trignometry_exports, __webpack_require__(6404), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5183:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar radiansToDegrees_exports = {};\n__export(radiansToDegrees_exports, {\n  $radiansToDegrees: () => $radiansToDegrees\n});\nmodule.exports = __toCommonJS(radiansToDegrees_exports);\nvar import_internal = __webpack_require__(1291);\nconst DEGREES_FACTOR = 180 / Math.PI;\nconst $radiansToDegrees = (0, import_internal.createTrignometryOperator)(\n  (n) => n * DEGREES_FACTOR,\n  {\n    Infinity: Infinity,\n    \"-Infinity\": -Infinity\n  }\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7969:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sin_exports = {};\n__export(sin_exports, {\n  $sin: () => $sin\n});\nmodule.exports = __toCommonJS(sin_exports);\nvar import_internal = __webpack_require__(1291);\nconst $sin = (0, import_internal.createTrignometryOperator)(Math.sin);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9589:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sinh_exports = {};\n__export(sinh_exports, {\n  $sinh: () => $sinh\n});\nmodule.exports = __toCommonJS(sinh_exports);\nvar import_internal = __webpack_require__(1291);\nconst $sinh = (0, import_internal.createTrignometryOperator)(Math.sinh, {\n  \"-Infinity\": -Infinity,\n  Infinity: Infinity\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6404:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar tan_exports = {};\n__export(tan_exports, {\n  $tan: () => $tan\n});\nmodule.exports = __toCommonJS(tan_exports);\nvar import_internal = __webpack_require__(1291);\nconst $tan = (0, import_internal.createTrignometryOperator)(Math.tan);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5281:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  MAX_INT: () => MAX_INT,\n  MAX_LONG: () => MAX_LONG,\n  MIN_INT: () => MIN_INT,\n  MIN_LONG: () => MIN_LONG,\n  TypeConvertError: () => TypeConvertError,\n  toInteger: () => toInteger\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst MAX_INT = 2147483647;\nconst MIN_INT = -2147483648;\nconst MAX_LONG = Number.MAX_SAFE_INTEGER;\nconst MIN_LONG = Number.MIN_SAFE_INTEGER;\nclass TypeConvertError extends Error {\n  constructor(message) {\n    super(message);\n  }\n}\nfunction toInteger(obj, expr, options, min, max) {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if (val === true) return 1;\n  if (val === false) return 0;\n  if ((0, import_util.isNil)(val)) return null;\n  if ((0, import_util.isDate)(val)) return val.getTime();\n  const n = Number(val);\n  if ((0, import_util.isNumber)(n) && n >= min && n <= max) {\n    if (!(0, import_util.isString)(val) || n.toString().indexOf(\".\") === -1) {\n      return Math.trunc(n);\n    }\n  }\n  throw new TypeConvertError(\n    `cannot convert '${val}' to ${max == MAX_INT ? \"int\" : \"long\"}`\n  );\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6234:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar convert_exports = {};\n__export(convert_exports, {\n  $convert: () => $convert\n});\nmodule.exports = __toCommonJS(convert_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(5281);\nvar import_toBool = __webpack_require__(448);\nvar import_toDate = __webpack_require__(2848);\nvar import_toDouble = __webpack_require__(7093);\nvar import_toInt = __webpack_require__(5375);\nvar import_toLong = __webpack_require__(8074);\nvar import_toString = __webpack_require__(4077);\nconst $convert = (obj, expr, options) => {\n  const args = (0, import_core.computeValue)(obj, expr, null, options);\n  args.onNull = args.onNull === void 0 ? null : args.onNull;\n  if ((0, import_util.isNil)(args.input)) return args.onNull;\n  try {\n    switch (args.to) {\n      case 2:\n      case \"string\":\n        return (0, import_toString.$toString)(obj, args.input, options);\n      case 8:\n      case \"boolean\":\n      case \"bool\":\n        return (0, import_toBool.$toBool)(obj, args.input, options);\n      case 9:\n      case \"date\":\n        return (0, import_toDate.$toDate)(obj, args.input, options);\n      case 1:\n      case 19:\n      case \"double\":\n      case \"decimal\":\n      case \"number\":\n        return (0, import_toDouble.$toDouble)(obj, args.input, options);\n      case 16:\n      case \"int\":\n        return (0, import_toInt.$toInt)(obj, args.input, options);\n      case 18:\n      case \"long\":\n        return (0, import_toLong.$toLong)(obj, args.input, options);\n    }\n  } catch {\n  }\n  if (args.onError !== void 0) return args.onError;\n  throw new import_internal.TypeConvertError(`could not convert to type ${args.to}.`);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1377:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar type_exports = {};\nmodule.exports = __toCommonJS(type_exports);\n__reExport(type_exports, __webpack_require__(6234), module.exports);\n__reExport(type_exports, __webpack_require__(2024), module.exports);\n__reExport(type_exports, __webpack_require__(448), module.exports);\n__reExport(type_exports, __webpack_require__(2848), module.exports);\n__reExport(type_exports, __webpack_require__(3289), module.exports);\n__reExport(type_exports, __webpack_require__(7093), module.exports);\n__reExport(type_exports, __webpack_require__(5375), module.exports);\n__reExport(type_exports, __webpack_require__(8074), module.exports);\n__reExport(type_exports, __webpack_require__(4077), module.exports);\n__reExport(type_exports, __webpack_require__(1317), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2024:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar isNumber_exports = {};\n__export(isNumber_exports, {\n  $isNumber: () => $isNumber\n});\nmodule.exports = __toCommonJS(isNumber_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $isNumber = (obj, expr, options) => {\n  const n = (0, import_core.computeValue)(obj, expr, null, options);\n  return (0, import_util.isNumber)(n);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 448:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toBool_exports = {};\n__export(toBool_exports, {\n  $toBool: () => $toBool\n});\nmodule.exports = __toCommonJS(toBool_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $toBool = (obj, expr, options) => {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(val)) return null;\n  if ((0, import_util.isString)(val)) return true;\n  return Boolean(val);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2848:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toDate_exports = {};\n__export(toDate_exports, {\n  $toDate: () => $toDate\n});\nmodule.exports = __toCommonJS(toDate_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(5281);\nconst $toDate = (obj, expr, options) => {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isDate)(val)) return val;\n  if ((0, import_util.isNil)(val)) return null;\n  const d = new Date(val);\n  const n = d.getTime();\n  if (!isNaN(n)) return d;\n  throw new import_internal.TypeConvertError(`cannot convert '${val}' to date`);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3289:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toDecimal_exports = {};\n__export(toDecimal_exports, {\n  $toDecimal: () => $toDecimal\n});\nmodule.exports = __toCommonJS(toDecimal_exports);\nvar import_toDouble = __webpack_require__(7093);\nconst $toDecimal = import_toDouble.$toDouble;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7093:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toDouble_exports = {};\n__export(toDouble_exports, {\n  $toDouble: () => $toDouble\n});\nmodule.exports = __toCommonJS(toDouble_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(5281);\nconst $toDouble = (obj, expr, options) => {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(val)) return null;\n  if ((0, import_util.isDate)(val)) return val.getTime();\n  if (val === true) return 1;\n  if (val === false) return 0;\n  const n = Number(val);\n  if ((0, import_util.isNumber)(n)) return n;\n  throw new import_internal.TypeConvertError(`cannot convert '${val}' to double/decimal`);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5375:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toInt_exports = {};\n__export(toInt_exports, {\n  $toInt: () => $toInt\n});\nmodule.exports = __toCommonJS(toInt_exports);\nvar import_internal = __webpack_require__(5281);\nconst $toInt = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_INT, import_internal.MAX_INT);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8074:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toLong_exports = {};\n__export(toLong_exports, {\n  $toLong: () => $toLong\n});\nmodule.exports = __toCommonJS(toLong_exports);\nvar import_internal = __webpack_require__(5281);\nconst $toLong = (obj, expr, options) => (0, import_internal.toInteger)(obj, expr, options, import_internal.MIN_LONG, import_internal.MAX_LONG);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4077:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar toString_exports = {};\n__export(toString_exports, {\n  $toString: () => $toString\n});\nmodule.exports = __toCommonJS(toString_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_dateToString = __webpack_require__(7165);\nconst $toString = (obj, expr, options) => {\n  const val = (0, import_core.computeValue)(obj, expr, null, options);\n  if ((0, import_util.isNil)(val)) return null;\n  if ((0, import_util.isDate)(val)) {\n    return (0, import_dateToString.$dateToString)(\n      obj,\n      {\n        date: expr,\n        format: \"%Y-%m-%dT%H:%M:%S.%LZ\"\n      },\n      options\n    );\n  }\n  return val.toString();\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1317:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar type_exports = {};\n__export(type_exports, {\n  $type: () => $type\n});\nmodule.exports = __toCommonJS(type_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(5281);\nconst $type = (obj, expr, options) => {\n  const v = (0, import_core.computeValue)(obj, expr, null, options);\n  if (options.useStrictMode) {\n    if (v === void 0) return \"missing\";\n    if (v === true || v === false) return \"bool\";\n    if ((0, import_util.isNumber)(v)) {\n      if (v % 1 != 0) return \"double\";\n      return v >= import_internal.MIN_INT && v <= import_internal.MAX_INT ? \"int\" : \"long\";\n    }\n    if ((0, import_util.isRegExp)(v)) return \"regex\";\n  }\n  return (0, import_util.typeOf)(v);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2537:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar variable_exports = {};\nmodule.exports = __toCommonJS(variable_exports);\n__reExport(variable_exports, __webpack_require__(7544), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7544:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar let_exports = {};\n__export(let_exports, {\n  $let: () => $let\n});\nmodule.exports = __toCommonJS(let_exports);\nvar import_core = __webpack_require__(2760);\nconst $let = (obj, expr, options) => {\n  const variables = {};\n  for (const [key, val] of Object.entries(expr.vars)) {\n    variables[key] = (0, import_core.computeValue)(obj, val, null, options);\n  }\n  return (0, import_core.computeValue)(\n    obj,\n    expr.in,\n    null,\n    import_core.ComputeOptions.init(options, obj, { variables })\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2088:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  isUnbounded: () => isUnbounded\n});\nmodule.exports = __toCommonJS(internal_exports);\nconst isUnbounded = (window) => {\n  const boundary = window?.documents || window?.range;\n  return !boundary || boundary[0] === \"unbounded\" && boundary[1] === \"unbounded\";\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5770:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar addFields_exports = {};\n__export(addFields_exports, {\n  $addFields: () => $addFields\n});\nmodule.exports = __toCommonJS(addFields_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $addFields = (collection, expr, options) => {\n  const newFields = Object.keys(expr);\n  if (newFields.length === 0) return collection;\n  return collection.map((obj) => {\n    const newObj = { ...obj };\n    for (const field of newFields) {\n      const newValue = (0, import_core.computeValue)(obj, expr[field], null, options);\n      if (newValue !== void 0) {\n        (0, import_util.setValue)(newObj, field, newValue);\n      } else {\n        (0, import_util.removeValue)(newObj, field);\n      }\n    }\n    return newObj;\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 308:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bucket_exports = {};\n__export(bucket_exports, {\n  $bucket: () => $bucket\n});\nmodule.exports = __toCommonJS(bucket_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nconst $bucket = (collection, expr, options) => {\n  const bounds = [...expr.boundaries];\n  const defaultKey = expr.default;\n  const lower = bounds[0];\n  const upper = bounds[bounds.length - 1];\n  const outputExpr = expr.output || { count: { $sum: 1 } };\n  (0, import_util.assert)(bounds.length > 1, \"$bucket must specify at least two boundaries.\");\n  const isValid = bounds.every(\n    (v, i) => i === 0 || (0, import_util.typeOf)(v) === (0, import_util.typeOf)(bounds[i - 1]) && (0, import_util.compare)(v, bounds[i - 1]) > 0\n  );\n  (0, import_util.assert)(\n    isValid,\n    `$bucket: bounds must be of same type and in ascending order`\n  );\n  if (!(0, import_util.isNil)(defaultKey) && (0, import_util.typeOf)(defaultKey) === (0, import_util.typeOf)(lower)) {\n    (0, import_util.assert)(\n      (0, import_util.compare)(defaultKey, upper) >= 0 || (0, import_util.compare)(defaultKey, lower) < 0,\n      \"$bucket 'default' expression must be out of boundaries range\"\n    );\n  }\n  const createBuckets = () => {\n    const buckets = /* @__PURE__ */ new Map();\n    for (let i = 0; i < bounds.length - 1; i++) {\n      buckets.set(bounds[i], []);\n    }\n    if (!(0, import_util.isNil)(defaultKey)) buckets.set(defaultKey, []);\n    collection.each((obj) => {\n      const key = (0, import_core.computeValue)(obj, expr.groupBy, null, options);\n      if ((0, import_util.isNil)(key) || (0, import_util.compare)(key, lower) < 0 || (0, import_util.compare)(key, upper) >= 0) {\n        (0, import_util.assert)(\n          !(0, import_util.isNil)(defaultKey),\n          \"$bucket require a default for out of range values\"\n        );\n        buckets.get(defaultKey).push(obj);\n      } else {\n        (0, import_util.assert)(\n          (0, import_util.compare)(key, lower) >= 0 && (0, import_util.compare)(key, upper) < 0,\n          \"$bucket 'groupBy' expression must resolve to a value in range of boundaries\"\n        );\n        const index = (0, import_util.findInsertIndex)(bounds, key);\n        const boundKey = bounds[Math.max(0, index - 1)];\n        buckets.get(boundKey).push(obj);\n      }\n    });\n    bounds.pop();\n    if (!(0, import_util.isNil)(defaultKey)) bounds.push(defaultKey);\n    (0, import_util.assert)(\n      buckets.size === bounds.length,\n      \"bounds and groups must be of equal size.\"\n    );\n    return (0, import_lazy.Lazy)(bounds).map((key) => {\n      return {\n        ...(0, import_core.computeValue)(\n          buckets.get(key),\n          outputExpr,\n          null,\n          options\n        ),\n        _id: key\n      };\n    });\n  };\n  let iterator;\n  return (0, import_lazy.Lazy)(() => {\n    if (!iterator) iterator = createBuckets();\n    return iterator.next();\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7267:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bucketAuto_exports = {};\n__export(bucketAuto_exports, {\n  $bucketAuto: () => $bucketAuto\n});\nmodule.exports = __toCommonJS(bucketAuto_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nconst $bucketAuto = (collection, expr, options) => {\n  const {\n    buckets: bucketCount,\n    groupBy: groupByExpr,\n    output: optOutputExpr,\n    // Available only if the all groupBy values are numeric and none of them are NaN.\n    granularity\n  } = expr;\n  const outputExpr = optOutputExpr ?? { count: { $sum: 1 } };\n  (0, import_util.assert)(\n    bucketCount > 0,\n    `$bucketAuto: 'buckets' field must be greater than 0, but found: ${bucketCount}`\n  );\n  if (granularity) {\n    (0, import_util.assert)(\n      /^POWERSOF2|1-2-5|E(6|12|24|48|96|192)|R(5|10|20|40|80)$/.test(\n        granularity\n      ),\n      `$bucketAuto: invalid granularity '${granularity}'.`\n    );\n  }\n  const keyMap = /* @__PURE__ */ new Map();\n  const setKey = !granularity ? (o, k) => keyMap.set(o, k) : (_, _2) => {\n  };\n  const sorted = collection.map((o) => {\n    const k = (0, import_core.computeValue)(o, groupByExpr, null, options) ?? null;\n    (0, import_util.assert)(\n      !granularity || (0, import_util.isNumber)(k),\n      \"$bucketAuto: groupBy values must be numeric when granularity is specified.\"\n    );\n    setKey(o, k ?? null);\n    return [k ?? null, o];\n  }).value();\n  sorted.sort((x, y) => {\n    if ((0, import_util.isNil)(x[0])) return -1;\n    if ((0, import_util.isNil)(y[0])) return 1;\n    return (0, import_util.compare)(x[0], y[0]);\n  });\n  let getNext;\n  if (!granularity) {\n    getNext = granularityDefault(sorted, bucketCount, keyMap);\n  } else if (granularity == \"POWERSOF2\") {\n    getNext = granularityPowerOfTwo(\n      sorted,\n      bucketCount\n    );\n  } else {\n    getNext = granularityPreferredSeries(\n      sorted,\n      bucketCount,\n      granularity\n    );\n  }\n  let terminate = false;\n  return (0, import_lazy.Lazy)(() => {\n    if (terminate) return { done: true };\n    const { min, max, bucket, done } = getNext();\n    terminate = done;\n    const outFields = (0, import_core.computeValue)(\n      bucket,\n      outputExpr,\n      null,\n      options\n    );\n    for (const [k, v] of Object.entries(outFields)) {\n      if ((0, import_util.isArray)(v)) outFields[k] = v.filter((v2) => v2 !== void 0);\n    }\n    return {\n      done: false,\n      value: {\n        ...outFields,\n        _id: { min, max }\n      }\n    };\n  });\n};\nfunction granularityDefault(sorted, bucketCount, keyMap) {\n  const size = sorted.length;\n  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));\n  let index = 0;\n  let nBuckets = 0;\n  return () => {\n    const isLastBucket = ++nBuckets == bucketCount;\n    const bucket = new Array();\n    while (index < size && (isLastBucket || bucket.length < approxBucketSize || index > 0 && (0, import_util.isEqual)(sorted[index - 1][0], sorted[index][0]))) {\n      bucket.push(sorted[index++][1]);\n    }\n    const min = keyMap.get(bucket[0]);\n    let max;\n    if (index < size) {\n      max = sorted[index][0];\n    } else {\n      max = keyMap.get(bucket[bucket.length - 1]);\n    }\n    (0, import_util.assert)(\n      (0, import_util.isNil)(max) || (0, import_util.isNil)(min) || min <= max,\n      `error: $bucketAuto boundary must be in order.`\n    );\n    return {\n      min,\n      max,\n      bucket,\n      done: index >= size\n    };\n  };\n}\nfunction granularityPowerOfTwo(sorted, bucketCount) {\n  const size = sorted.length;\n  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));\n  const roundUp2 = (n) => n === 0 ? 0 : 2 ** (Math.floor(Math.log2(n)) + 1);\n  let index = 0;\n  let min = 0;\n  let max = 0;\n  return () => {\n    const bucket = new Array();\n    const boundValue = roundUp2(max);\n    min = index > 0 ? max : 0;\n    while (bucket.length < approxBucketSize && index < size && (max === 0 || sorted[index][0] < boundValue)) {\n      bucket.push(sorted[index++][1]);\n    }\n    max = max == 0 ? roundUp2(sorted[index - 1][0]) : boundValue;\n    while (index < size && sorted[index][0] < max) {\n      bucket.push(sorted[index++][1]);\n    }\n    return {\n      min,\n      max,\n      bucket,\n      done: index >= size\n    };\n  };\n}\nconst PREFERRED_NUMBERS = Object.freeze({\n  // \"Least rounded\" Renard number series, taken from Wikipedia page on preferred\n  // numbers: https://en.wikipedia.org/wiki/Preferred_number#Renard_numbers\n  R5: [10, 16, 25, 40, 63],\n  R10: [100, 125, 160, 200, 250, 315, 400, 500, 630, 800],\n  R20: [\n    100,\n    112,\n    125,\n    140,\n    160,\n    180,\n    200,\n    224,\n    250,\n    280,\n    315,\n    355,\n    400,\n    450,\n    500,\n    560,\n    630,\n    710,\n    800,\n    900\n  ],\n  R40: [\n    100,\n    106,\n    112,\n    118,\n    125,\n    132,\n    140,\n    150,\n    160,\n    170,\n    180,\n    190,\n    200,\n    212,\n    224,\n    236,\n    250,\n    265,\n    280,\n    300,\n    315,\n    355,\n    375,\n    400,\n    425,\n    450,\n    475,\n    500,\n    530,\n    560,\n    600,\n    630,\n    670,\n    710,\n    750,\n    800,\n    850,\n    900,\n    950\n  ],\n  R80: [\n    103,\n    109,\n    115,\n    122,\n    128,\n    136,\n    145,\n    155,\n    165,\n    175,\n    185,\n    195,\n    206,\n    218,\n    230,\n    243,\n    258,\n    272,\n    290,\n    307,\n    325,\n    345,\n    365,\n    387,\n    412,\n    437,\n    462,\n    487,\n    515,\n    545,\n    575,\n    615,\n    650,\n    690,\n    730,\n    775,\n    825,\n    875,\n    925,\n    975\n  ],\n  // https://en.wikipedia.org/wiki/Preferred_number#1-2-5_series\n  \"1-2-5\": [10, 20, 50],\n  // E series, taken from Wikipedia page on preferred numbers:\n  // https://en.wikipedia.org/wiki/Preferred_number#E_series\n  E6: [10, 15, 22, 33, 47, 68],\n  E12: [10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82],\n  E24: [\n    10,\n    11,\n    12,\n    13,\n    15,\n    16,\n    18,\n    20,\n    22,\n    24,\n    27,\n    30,\n    33,\n    36,\n    39,\n    43,\n    47,\n    51,\n    56,\n    62,\n    68,\n    75,\n    82,\n    91\n  ],\n  E48: [\n    100,\n    105,\n    110,\n    115,\n    121,\n    127,\n    133,\n    140,\n    147,\n    154,\n    162,\n    169,\n    178,\n    187,\n    196,\n    205,\n    215,\n    226,\n    237,\n    249,\n    261,\n    274,\n    287,\n    301,\n    316,\n    332,\n    348,\n    365,\n    383,\n    402,\n    422,\n    442,\n    464,\n    487,\n    511,\n    536,\n    562,\n    590,\n    619,\n    649,\n    681,\n    715,\n    750,\n    787,\n    825,\n    866,\n    909,\n    953\n  ],\n  E96: [\n    100,\n    102,\n    105,\n    107,\n    110,\n    113,\n    115,\n    118,\n    121,\n    124,\n    127,\n    130,\n    133,\n    137,\n    140,\n    143,\n    147,\n    150,\n    154,\n    158,\n    162,\n    165,\n    169,\n    174,\n    178,\n    182,\n    187,\n    191,\n    196,\n    200,\n    205,\n    210,\n    215,\n    221,\n    226,\n    232,\n    237,\n    243,\n    249,\n    255,\n    261,\n    267,\n    274,\n    280,\n    287,\n    294,\n    301,\n    309,\n    316,\n    324,\n    332,\n    340,\n    348,\n    357,\n    365,\n    374,\n    383,\n    392,\n    402,\n    412,\n    422,\n    432,\n    442,\n    453,\n    464,\n    475,\n    487,\n    499,\n    511,\n    523,\n    536,\n    549,\n    562,\n    576,\n    590,\n    604,\n    619,\n    634,\n    649,\n    665,\n    681,\n    698,\n    715,\n    732,\n    750,\n    768,\n    787,\n    806,\n    825,\n    845,\n    866,\n    887,\n    909,\n    931,\n    953,\n    976\n  ],\n  E192: [\n    100,\n    101,\n    102,\n    104,\n    105,\n    106,\n    107,\n    109,\n    110,\n    111,\n    113,\n    114,\n    115,\n    117,\n    118,\n    120,\n    121,\n    123,\n    124,\n    126,\n    127,\n    129,\n    130,\n    132,\n    133,\n    135,\n    137,\n    138,\n    140,\n    142,\n    143,\n    145,\n    147,\n    149,\n    150,\n    152,\n    154,\n    156,\n    158,\n    160,\n    162,\n    164,\n    165,\n    167,\n    169,\n    172,\n    174,\n    176,\n    178,\n    180,\n    182,\n    184,\n    187,\n    189,\n    191,\n    193,\n    196,\n    198,\n    200,\n    203,\n    205,\n    208,\n    210,\n    213,\n    215,\n    218,\n    221,\n    223,\n    226,\n    229,\n    232,\n    234,\n    237,\n    240,\n    243,\n    246,\n    249,\n    252,\n    255,\n    258,\n    261,\n    264,\n    267,\n    271,\n    274,\n    277,\n    280,\n    284,\n    287,\n    291,\n    294,\n    298,\n    301,\n    305,\n    309,\n    312,\n    316,\n    320,\n    324,\n    328,\n    332,\n    336,\n    340,\n    344,\n    348,\n    352,\n    357,\n    361,\n    365,\n    370,\n    374,\n    379,\n    383,\n    388,\n    392,\n    397,\n    402,\n    407,\n    412,\n    417,\n    422,\n    427,\n    432,\n    437,\n    442,\n    448,\n    453,\n    459,\n    464,\n    470,\n    475,\n    481,\n    487,\n    493,\n    499,\n    505,\n    511,\n    517,\n    523,\n    530,\n    536,\n    542,\n    549,\n    556,\n    562,\n    569,\n    576,\n    583,\n    590,\n    597,\n    604,\n    612,\n    619,\n    626,\n    634,\n    642,\n    649,\n    657,\n    665,\n    673,\n    681,\n    690,\n    698,\n    706,\n    715,\n    723,\n    732,\n    741,\n    750,\n    759,\n    768,\n    777,\n    787,\n    796,\n    806,\n    816,\n    825,\n    835,\n    845,\n    856,\n    866,\n    876,\n    887,\n    898,\n    909,\n    920,\n    931,\n    942,\n    953,\n    965,\n    976,\n    988\n  ]\n});\nconst roundUp = (n, granularity) => {\n  if (n == 0) return 0;\n  const series = PREFERRED_NUMBERS[granularity];\n  const first = series[0];\n  const last = series[series.length - 1];\n  let multiplier = 1;\n  while (n >= last * multiplier) {\n    multiplier *= 10;\n  }\n  let previousMin = 0;\n  while (n < first * multiplier) {\n    previousMin = first * multiplier;\n    multiplier /= 10;\n    if (n >= last * multiplier) {\n      return previousMin;\n    }\n  }\n  (0, import_util.assert)(\n    n >= first * multiplier && n < last * multiplier,\n    \"$bucketAuto: number out of range of series.\"\n  );\n  const i = (0, import_util.findInsertIndex)(series, n, (a, b) => {\n    b *= multiplier;\n    if (a < b) return -1;\n    if (a > b) return 1;\n    return 0;\n  });\n  const seriesNumber = series[i] * multiplier;\n  return n == seriesNumber ? series[i + 1] * multiplier : seriesNumber;\n};\nfunction granularityPreferredSeries(sorted, bucketCount, granularity) {\n  const size = sorted.length;\n  const approxBucketSize = Math.max(1, Math.round(sorted.length / bucketCount));\n  let index = 0;\n  let nBuckets = 0;\n  let min = 0;\n  let max = 0;\n  return () => {\n    const isLastBucket = ++nBuckets == bucketCount;\n    const bucket = new Array();\n    min = index > 0 ? max : 0;\n    while (index < size && (isLastBucket || bucket.length < approxBucketSize)) {\n      bucket.push(sorted[index++][1]);\n    }\n    max = roundUp(sorted[index - 1][0], granularity);\n    const nItems = bucket.length;\n    while (index < size && (isLastBucket || sorted[index][0] < max)) {\n      bucket.push(sorted[index++][1]);\n    }\n    if (nItems != bucket.length) {\n      max = roundUp(sorted[index - 1][0], granularity);\n    }\n    (0, import_util.assert)(min < max, `$bucketAuto: ${min} < ${max}.`);\n    return {\n      min,\n      max,\n      bucket,\n      done: index >= size\n    };\n  };\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 11:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar count_exports = {};\n__export(count_exports, {\n  $count: () => $count\n});\nmodule.exports = __toCommonJS(count_exports);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nconst $count = (collection, expr, _options) => {\n  (0, import_util.assert)(\n    (0, import_util.isString)(expr) && !(0, import_util.isEmpty)(expr) && expr.indexOf(\".\") === -1 && expr.trim()[0] !== \"$\",\n    \"Invalid expression value for $count\"\n  );\n  return (0, import_lazy.Lazy)([\n    {\n      [expr]: collection.size()\n    }\n  ]);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3710:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar densify_exports = {};\n__export(densify_exports, {\n  $densify: () => $densify\n});\nmodule.exports = __toCommonJS(densify_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_types = __webpack_require__(486);\nvar import_util = __webpack_require__(7839);\nvar import_dateAdd = __webpack_require__(8410);\nvar import_sort = __webpack_require__(4290);\nconst EMPTY_OBJECT = Object.freeze({});\nconst $densify = (collection, expr, options) => {\n  const { step, bounds, unit } = expr.range;\n  if (unit) {\n    (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), \"\");\n    (0, import_util.assert)(\n      Number.isInteger(step) && step > 0,\n      \"The step parameter in a range statement must be a whole number when densifying a date range.\"\n    );\n  } else {\n    (0, import_util.assert)(\n      (0, import_util.isNumber)(step) && step > 0,\n      \"The step parameter in a range statement must be a strictly positive numeric value.\"\n    );\n  }\n  if ((0, import_util.isArray)(bounds)) {\n    (0, import_util.assert)(\n      !!bounds && bounds.length === 2,\n      \"A bounding array in a range statement must have exactly two elements.\"\n    );\n    (0, import_util.assert)(\n      (bounds.every(import_util.isNumber) || bounds.every(import_util.isDate)) && bounds[0] < bounds[1],\n      \"A bounding array must be an ascending array of either two dates or two numbers.\"\n    );\n    (0, import_util.assert)(\n      unit && !bounds.some(import_util.isNumber),\n      \"Numeric bounds may not have unit parameter.\"\n    );\n  }\n  if (expr.partitionByFields) {\n    (0, import_util.assert)(\n      (0, import_util.isArray)(expr.partitionByFields),\n      \"$densify: `partitionByFields` must be an array of strings\"\n    );\n  }\n  collection = (0, import_sort.$sort)(collection, { [expr.field]: 1 }, options);\n  const nilOptions = import_core.ComputeOptions.init(options, null);\n  const computeNextValue = (value) => {\n    return (0, import_util.isNumber)(value) ? value + step : (0, import_dateAdd.$dateAdd)(\n      EMPTY_OBJECT,\n      { startDate: value, unit, amount: step },\n      nilOptions\n    );\n  };\n  const isValidUnit = !!unit && import_types.TIME_UNITS.includes(unit);\n  const getFieldValue = (o) => {\n    const v = (0, import_util.resolve)(o, expr.field);\n    if ((0, import_util.isNil)(v)) return v;\n    if ((0, import_util.isNumber)(v)) {\n      (0, import_util.assert)(\n        !isValidUnit,\n        \"$densify: Encountered non-date value in collection when step has a date unit.\"\n      );\n    } else if ((0, import_util.isDate)(v)) {\n      (0, import_util.assert)(\n        isValidUnit,\n        \"$densify: Encountered date value in collection when step does not have a date unit.\"\n      );\n    } else {\n      (0, import_util.assert)(false, \"$densify: Densify field type must be numeric or a date\");\n    }\n    return v;\n  };\n  const peekItem = new Array();\n  const nilFieldsIterator = (0, import_lazy.Lazy)(() => {\n    const item = collection.next();\n    const fieldValue = getFieldValue(item.value);\n    if ((0, import_util.isNil)(fieldValue)) return item;\n    peekItem.push(item);\n    return { done: true };\n  });\n  const nextDensifyValueMap = import_util.ValueMap.init(\n    options.hashFunction\n  );\n  const [lower, upper] = (0, import_util.isArray)(bounds) ? bounds : [bounds, bounds];\n  let maxFieldValue = void 0;\n  const updateMaxFieldValue = (value) => {\n    maxFieldValue = maxFieldValue === void 0 || maxFieldValue < value ? value : maxFieldValue;\n  };\n  const rootKey = [];\n  const densifyIterator = (0, import_lazy.Lazy)(() => {\n    const item = peekItem.length > 0 ? peekItem.pop() : collection.next();\n    if (item.done) return item;\n    let partitionKey = rootKey;\n    if ((0, import_util.isArray)(expr.partitionByFields)) {\n      partitionKey = expr.partitionByFields.map(\n        (k) => (0, import_util.resolve)(item.value, k)\n      );\n      (0, import_util.assert)(\n        partitionKey.every(import_util.isString),\n        \"$densify: Partition fields must evaluate to string values.\"\n      );\n    }\n    (0, import_util.assert)((0, import_util.isObject)(item.value), \"$densify: collection must contain documents\");\n    const itemValue = getFieldValue(item.value);\n    if (!nextDensifyValueMap.has(partitionKey)) {\n      if (lower == \"full\") {\n        if (!nextDensifyValueMap.has(rootKey)) {\n          nextDensifyValueMap.set(rootKey, itemValue);\n        }\n        nextDensifyValueMap.set(partitionKey, nextDensifyValueMap.get(rootKey));\n      } else if (lower == \"partition\") {\n        nextDensifyValueMap.set(partitionKey, itemValue);\n      } else {\n        nextDensifyValueMap.set(partitionKey, lower);\n      }\n    }\n    const densifyValue = nextDensifyValueMap.get(partitionKey);\n    if (\n      // current item field value is lower than current densify value.\n      itemValue <= densifyValue || // range value equals or exceeds upper bound\n      upper != \"full\" && upper != \"partition\" && densifyValue >= upper\n    ) {\n      if (densifyValue <= itemValue) {\n        nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));\n      }\n      updateMaxFieldValue(itemValue);\n      return item;\n    }\n    nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));\n    updateMaxFieldValue(densifyValue);\n    const denseObj = { [expr.field]: densifyValue };\n    if (partitionKey) {\n      partitionKey.forEach((v, i) => {\n        denseObj[expr.partitionByFields[i]] = v;\n      });\n    }\n    peekItem.push(item);\n    return { done: false, value: denseObj };\n  });\n  if (lower !== \"full\") return (0, import_lazy.concat)(nilFieldsIterator, densifyIterator);\n  let paritionIndex = -1;\n  let partitionKeysSet = void 0;\n  const fullBoundsIterator = (0, import_lazy.Lazy)(() => {\n    if (paritionIndex === -1) {\n      const fullDensifyValue = nextDensifyValueMap.get(rootKey);\n      nextDensifyValueMap.delete(rootKey);\n      partitionKeysSet = Array.from(nextDensifyValueMap.keys());\n      if (partitionKeysSet.length === 0) {\n        partitionKeysSet.push(rootKey);\n        nextDensifyValueMap.set(rootKey, fullDensifyValue);\n      }\n      paritionIndex++;\n    }\n    do {\n      const partitionKey = partitionKeysSet[paritionIndex];\n      const partitionMaxValue = nextDensifyValueMap.get(partitionKey);\n      if (partitionMaxValue < maxFieldValue) {\n        nextDensifyValueMap.set(\n          partitionKey,\n          computeNextValue(partitionMaxValue)\n        );\n        const denseObj = { [expr.field]: partitionMaxValue };\n        partitionKey.forEach((v, i) => {\n          denseObj[expr.partitionByFields[i]] = v;\n        });\n        return { done: false, value: denseObj };\n      }\n      paritionIndex++;\n    } while (paritionIndex < partitionKeysSet.length);\n    return { done: true };\n  });\n  return (0, import_lazy.concat)(nilFieldsIterator, densifyIterator, fullBoundsIterator);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2543:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar facet_exports = {};\n__export(facet_exports, {\n  $facet: () => $facet\n});\nmodule.exports = __toCommonJS(facet_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nconst $facet = (collection, expr, options) => {\n  return collection.transform((array) => {\n    const o = {};\n    for (const [k, pipeline] of Object.entries(expr)) {\n      o[k] = new import_aggregator.Aggregator(pipeline, {\n        ...options,\n        processingMode: import_core.ProcessingMode.CLONE_INPUT\n      }).run(array);\n    }\n    return [o];\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2343:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar fill_exports = {};\n__export(fill_exports, {\n  $fill: () => $fill\n});\nmodule.exports = __toCommonJS(fill_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_ifNull = __webpack_require__(3653);\nvar import_linearFill = __webpack_require__(4276);\nvar import_locf = __webpack_require__(4140);\nvar import_addFields = __webpack_require__(5770);\nvar import_setWindowFields = __webpack_require__(3805);\nconst FILL_METHODS = {\n  locf: \"$locf\",\n  linear: \"$linearFill\"\n};\nconst $fill = (collection, expr, options) => {\n  (0, import_util.assert)(!expr.sortBy || (0, import_util.isObject)(expr.sortBy), \"sortBy must be an object.\");\n  (0, import_util.assert)(\n    !!expr.sortBy || Object.values(expr.output).every((m) => (0, import_util.has)(m, \"value\")),\n    \"sortBy required if any output field specifies a 'method'.\"\n  );\n  (0, import_util.assert)(\n    !(expr.partitionBy && expr.partitionByFields),\n    \"specify either partitionBy or partitionByFields.\"\n  );\n  (0, import_util.assert)(\n    !expr.partitionByFields || expr?.partitionByFields?.every((s) => s[0] !== \"$\"),\n    \"fields in partitionByFields cannot begin with '$'.\"\n  );\n  options = (0, import_core.initOptions)(options);\n  options.context.addExpressionOps({ $ifNull: import_ifNull.$ifNull });\n  options.context.addWindowOps({ $locf: import_locf.$locf, $linearFill: import_linearFill.$linearFill });\n  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => `$${s}`);\n  const valueExpr = {};\n  const methodExpr = {};\n  for (const [k, m] of Object.entries(expr.output)) {\n    if ((0, import_util.has)(m, \"value\")) {\n      valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m[\"value\"]] };\n    } else {\n      const fillOp = FILL_METHODS[m[\"method\"]];\n      (0, import_util.assert)(!!fillOp, `invalid fill method '${m[\"method\"]}'.`);\n      methodExpr[k] = { [fillOp]: \"$\" + k };\n    }\n  }\n  if (Object.keys(methodExpr).length > 0) {\n    collection = (0, import_setWindowFields.$setWindowFields)(\n      collection,\n      {\n        sortBy: expr.sortBy || {},\n        partitionBy: partitionExpr,\n        output: methodExpr\n      },\n      options\n    );\n  }\n  if (Object.keys(valueExpr).length > 0) {\n    collection = (0, import_addFields.$addFields)(collection, valueExpr, options);\n  }\n  return collection;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8194:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar graphLookup_exports = {};\n__export(graphLookup_exports, {\n  $graphLookup: () => $graphLookup\n});\nmodule.exports = __toCommonJS(graphLookup_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nvar import_lookup = __webpack_require__(3704);\nconst $graphLookup = (collection, expr, options) => {\n  const fromColl = (0, import_util.isString)(expr.from) ? options?.collectionResolver(expr.from) : expr.from;\n  const {\n    connectFromField,\n    connectToField,\n    as: asField,\n    maxDepth,\n    depthField,\n    restrictSearchWithMatch: matchExpr\n  } = expr;\n  const pipelineExpr = matchExpr ? { pipeline: [{ $match: matchExpr }] } : {};\n  return collection.map((obj) => {\n    const matchObj = {};\n    (0, import_util.setValue)(\n      matchObj,\n      connectFromField,\n      (0, import_core.computeValue)(obj, expr.startWith, null, options)\n    );\n    let matches = [matchObj];\n    let i = -1;\n    const map = import_util.ValueMap.init(options.hashFunction);\n    do {\n      i++;\n      matches = (0, import_util.flatten)(\n        (0, import_lookup.$lookup)(\n          (0, import_lazy.Lazy)(matches),\n          {\n            from: fromColl,\n            localField: connectFromField,\n            foreignField: connectToField,\n            as: asField,\n            ...pipelineExpr\n          },\n          options\n        ).map((o) => o[asField]).value()\n      );\n      const oldSize = map.size;\n      matches.forEach((k) => map.set(k, map.get(k) ?? i));\n      if (oldSize == map.size) break;\n    } while ((0, import_util.isNil)(maxDepth) || i < maxDepth);\n    const result = new Array(map.size);\n    let n = 0;\n    map.forEach((v, k) => {\n      result[n++] = Object.assign(depthField ? { [depthField]: v } : {}, k);\n    });\n    return { ...obj, [asField]: result };\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9723:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar group_exports = {};\n__export(group_exports, {\n  $group: () => $group\n});\nmodule.exports = __toCommonJS(group_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst ID_KEY = \"_id\";\nconst $group = (collection, expr, options) => {\n  (0, import_util.assert)((0, import_util.has)(expr, ID_KEY), \"$group specification must include an '_id'\");\n  const idExpr = expr[ID_KEY];\n  const copts = import_core.ComputeOptions.init(options);\n  const newFields = Object.keys(expr).filter((k) => k != ID_KEY);\n  return collection.transform((coll) => {\n    const partitions = (0, import_util.groupBy)(\n      coll,\n      (obj) => (0, import_core.computeValue)(obj, idExpr, null, options),\n      options.hashFunction\n    );\n    let i = -1;\n    const partitionKeys = Array.from(partitions.keys());\n    return () => {\n      if (++i === partitions.size) return { done: true };\n      const groupId = partitionKeys[i];\n      const obj = {};\n      if (groupId !== void 0) {\n        obj[ID_KEY] = groupId;\n      }\n      for (const key of newFields) {\n        obj[key] = (0, import_core.computeValue)(\n          partitions.get(groupId),\n          expr[key],\n          null,\n          copts.update(null, { groupId })\n        );\n      }\n      return { value: obj, done: false };\n    };\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6936:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar pipeline_exports = {};\nmodule.exports = __toCommonJS(pipeline_exports);\n__reExport(pipeline_exports, __webpack_require__(5770), module.exports);\n__reExport(pipeline_exports, __webpack_require__(308), module.exports);\n__reExport(pipeline_exports, __webpack_require__(7267), module.exports);\n__reExport(pipeline_exports, __webpack_require__(11), module.exports);\n__reExport(pipeline_exports, __webpack_require__(3710), module.exports);\n__reExport(pipeline_exports, __webpack_require__(2543), module.exports);\n__reExport(pipeline_exports, __webpack_require__(2343), module.exports);\n__reExport(pipeline_exports, __webpack_require__(8194), module.exports);\n__reExport(pipeline_exports, __webpack_require__(9723), module.exports);\n__reExport(pipeline_exports, __webpack_require__(4483), module.exports);\n__reExport(pipeline_exports, __webpack_require__(3704), module.exports);\n__reExport(pipeline_exports, __webpack_require__(593), module.exports);\n__reExport(pipeline_exports, __webpack_require__(3508), module.exports);\n__reExport(pipeline_exports, __webpack_require__(6276), module.exports);\n__reExport(pipeline_exports, __webpack_require__(2401), module.exports);\n__reExport(pipeline_exports, __webpack_require__(7191), module.exports);\n__reExport(pipeline_exports, __webpack_require__(31), module.exports);\n__reExport(pipeline_exports, __webpack_require__(824), module.exports);\n__reExport(pipeline_exports, __webpack_require__(9060), module.exports);\n__reExport(pipeline_exports, __webpack_require__(9640), module.exports);\n__reExport(pipeline_exports, __webpack_require__(3805), module.exports);\n__reExport(pipeline_exports, __webpack_require__(8861), module.exports);\n__reExport(pipeline_exports, __webpack_require__(4290), module.exports);\n__reExport(pipeline_exports, __webpack_require__(7708), module.exports);\n__reExport(pipeline_exports, __webpack_require__(1347), module.exports);\n__reExport(pipeline_exports, __webpack_require__(829), module.exports);\n__reExport(pipeline_exports, __webpack_require__(3143), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4483:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar limit_exports = {};\n__export(limit_exports, {\n  $limit: () => $limit\n});\nmodule.exports = __toCommonJS(limit_exports);\nconst $limit = (collection, expr, _options) => collection.take(expr);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3704:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lookup_exports = {};\n__export(lookup_exports, {\n  $lookup: () => $lookup\n});\nmodule.exports = __toCommonJS(lookup_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $lookup = (collection, expr, options) => {\n  const joinColl = (0, import_util.isString)(expr.from) ? options?.collectionResolver(expr.from) : expr.from;\n  const { let: letExpr, pipeline, foreignField, localField } = expr;\n  const subQueryPipeline = pipeline || [];\n  let lookupEq = (_) => [true, []];\n  if (foreignField && localField) {\n    const map = import_util.ValueMap.init(options.hashFunction);\n    for (const doc of joinColl) {\n      (0, import_util.ensureArray)((0, import_util.resolve)(doc, foreignField) ?? null).forEach((v) => {\n        const xs = map.get(v);\n        const arr = xs ?? [];\n        arr.push(doc);\n        if (arr !== xs) map.set(v, arr);\n      });\n    }\n    lookupEq = (o) => {\n      const local = (0, import_util.resolve)(o, localField) ?? null;\n      if ((0, import_util.isArray)(local)) {\n        if (subQueryPipeline.length) {\n          return [local.some((v) => map.has(v)), null];\n        }\n        const result2 = Array.from(\n          new Set((0, import_util.flatten)(local.map((v) => map.get(v), options.hashFunction)))\n        );\n        return [result2.length > 0, result2];\n      }\n      const result = map.get(local) ?? null;\n      return [result !== null, result ?? []];\n    };\n    if (subQueryPipeline.length === 0) {\n      return collection.map((obj) => {\n        return {\n          ...obj,\n          [expr.as]: lookupEq(obj).pop()\n        };\n      });\n    }\n  }\n  const agg = new import_aggregator.Aggregator(subQueryPipeline, options);\n  return collection.map((obj) => {\n    const variables = (0, import_core.computeValue)(obj, letExpr, null, options);\n    const opts = Object.assign({}, options, {\n      variables: { ...options.variables, ...variables }\n    });\n    const [ok, res] = lookupEq(obj);\n    return {\n      ...obj,\n      [expr.as]: ok ? agg.run(joinColl, opts) : res\n    };\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 593:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar match_exports = {};\n__export(match_exports, {\n  $match: () => $match\n});\nmodule.exports = __toCommonJS(match_exports);\nvar import_query = __webpack_require__(6535);\nconst $match = (collection, expr, options) => {\n  const q = new import_query.Query(expr, options);\n  return collection.filter((o) => q.test(o));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3508:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar merge_exports = {};\n__export(merge_exports, {\n  $merge: () => $merge\n});\nmodule.exports = __toCommonJS(merge_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nvar import_expression = __webpack_require__(5764);\nconst $merge = (collection, expr, options) => {\n  const output = (0, import_util.isString)(expr.into) ? options?.collectionResolver(expr.into) : expr.into;\n  (0, import_util.assert)((0, import_util.isArray)(output), `$merge: option 'into' must resolve to an array`);\n  const onField = expr.on || options.idKey;\n  const getHash = (0, import_util.isString)(onField) ? (o) => (0, import_util.hashCode)((0, import_util.resolve)(o, onField), options.hashFunction) : (o) => (0, import_util.hashCode)(onField.map((s) => (0, import_util.resolve)(o, s), options.hashFunction));\n  const map = import_util.ValueMap.init();\n  for (let i = 0; i < output.length; i++) {\n    const obj = output[i];\n    const k = getHash(obj);\n    (0, import_util.assert)(\n      !map.has(k),\n      \"$merge: 'into' collection must have unique entries for the 'on' field.\"\n    );\n    map.set(k, [obj, i]);\n  }\n  const copts = import_core.ComputeOptions.init(options);\n  return collection.map((o) => {\n    const k = getHash(o);\n    if (map.has(k)) {\n      const [target, i] = map.get(k);\n      const variables = (0, import_core.computeValue)(\n        target,\n        expr.let || { new: \"$$ROOT\" },\n        null,\n        // 'root' is the item from the iteration.\n        copts.update(o)\n      );\n      if ((0, import_util.isArray)(expr.whenMatched)) {\n        const aggregator = new import_aggregator.Aggregator(expr.whenMatched, {\n          ...options,\n          variables\n        });\n        output[i] = aggregator.run([target])[0];\n      } else {\n        switch (expr.whenMatched) {\n          case \"replace\":\n            output[i] = o;\n            break;\n          case \"fail\":\n            throw new import_util.MingoError(\n              \"$merge: failed due to matching as specified by 'whenMatched' option.\"\n            );\n          case \"keepExisting\":\n            break;\n          case \"merge\":\n          default:\n            output[i] = (0, import_expression.$mergeObjects)(\n              target,\n              [target, o],\n              // 'root' is the item from the iteration.\n              copts.update(o, { variables })\n            );\n            break;\n        }\n      }\n    } else {\n      switch (expr.whenNotMatched) {\n        case \"discard\":\n          break;\n        case \"fail\":\n          throw new import_util.MingoError(\n            \"$merge: failed due to matching as specified by 'whenMatched' option.\"\n          );\n        case \"insert\":\n        default:\n          output.push(o);\n          break;\n      }\n    }\n    return o;\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6276:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar out_exports = {};\n__export(out_exports, {\n  $out: () => $out\n});\nmodule.exports = __toCommonJS(out_exports);\nvar import_util = __webpack_require__(7839);\nconst $out = (collection, expr, options) => {\n  const outputColl = (0, import_util.isString)(expr) ? options?.collectionResolver(expr) : expr;\n  (0, import_util.assert)((0, import_util.isArray)(outputColl), `expression must resolve to an array`);\n  return collection.map((o) => {\n    outputColl.push((0, import_util.cloneDeep)(o));\n    return o;\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2401:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar project_exports = {};\n__export(project_exports, {\n  $project: () => $project\n});\nmodule.exports = __toCommonJS(project_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst DESCRIPTORS = new Set(Array.from([0, 1, false, true]));\nconst $project = (collection, expr, options) => {\n  if ((0, import_util.isEmpty)(expr)) return collection;\n  const expressionKeys = Object.keys(expr);\n  validateExpression(expr, options);\n  const ID_KEY = options.idKey;\n  if (!expressionKeys.includes(ID_KEY)) {\n    expressionKeys.push(ID_KEY);\n  }\n  const copts = import_core.ComputeOptions.init(options);\n  return collection.map((obj) => processObject(obj, expr, copts.update(obj), expressionKeys));\n};\nfunction processObject(obj, expr, options, expressionKeys) {\n  let newObj = {};\n  let foundSlice = false;\n  let foundExclusion = false;\n  const idOnlyExcluded = expr[options.idKey] === 0 && expressionKeys.length === 1;\n  const dropKeys = [];\n  if (idOnlyExcluded) {\n    dropKeys.push(options.idKey);\n  }\n  for (const key of expressionKeys) {\n    let value = void 0;\n    const subExpr = expr[key];\n    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {\n      foundExclusion = true;\n    }\n    if (key === options.idKey && (0, import_util.isEmpty)(subExpr)) {\n      value = obj[key];\n    } else if ((0, import_util.isString)(subExpr)) {\n      value = (0, import_core.computeValue)(obj, subExpr, key, options);\n    } else if (subExpr === 1 || subExpr === true) {\n    } else if ((0, import_util.isArray)(subExpr)) {\n      value = subExpr.map((v) => {\n        const r = (0, import_core.computeValue)(obj, v, null, options);\n        if ((0, import_util.isNil)(r)) return null;\n        return r;\n      });\n    } else if ((0, import_util.isObject)(subExpr)) {\n      const subExprObj = subExpr;\n      const subExprKeys = Object.keys(subExpr);\n      const operator = subExprKeys.length == 1 ? subExprKeys[0] : \"\";\n      const call = (0, import_core.getOperator)(\n        \"projection\",\n        operator,\n        options\n      );\n      if (call) {\n        if (operator === \"$slice\") {\n          if ((0, import_util.ensureArray)(subExprObj[operator]).every(import_util.isNumber)) {\n            value = call(obj, subExprObj[operator], key, options);\n            foundSlice = true;\n          } else {\n            value = (0, import_core.computeValue)(obj, subExprObj, key, options);\n          }\n        } else {\n          value = call(obj, subExprObj[operator], key, options);\n        }\n      } else if ((0, import_util.isOperator)(operator)) {\n        value = (0, import_core.computeValue)(obj, subExprObj[operator], operator, options);\n      } else if ((0, import_util.has)(obj, key)) {\n        validateExpression(subExprObj, options);\n        let target = obj[key];\n        if ((0, import_util.isArray)(target)) {\n          value = target.map(\n            (o) => processObject(o, subExprObj, options, subExprKeys)\n          );\n        } else {\n          target = (0, import_util.isObject)(target) ? target : obj;\n          value = processObject(\n            target,\n            subExprObj,\n            options,\n            subExprKeys\n          );\n        }\n      } else {\n        value = (0, import_core.computeValue)(obj, subExpr, null, options);\n      }\n    } else {\n      dropKeys.push(key);\n      continue;\n    }\n    const objPathGraph = (0, import_util.resolveGraph)(obj, key, {\n      preserveMissing: true\n    });\n    if ((0, import_util.isObject)(objPathGraph)) {\n      (0, import_util.merge)(newObj, objPathGraph);\n    }\n    if (!DESCRIPTORS.has(subExpr)) {\n      if (value === void 0) {\n        (0, import_util.removeValue)(newObj, key, { descendArray: true });\n      } else {\n        (0, import_util.setValue)(newObj, key, value);\n      }\n    }\n  }\n  (0, import_util.filterMissing)(newObj);\n  if (foundSlice || foundExclusion || idOnlyExcluded) {\n    newObj = (0, import_util.into)({}, obj, newObj);\n    if (dropKeys.length > 0) {\n      for (const k of dropKeys) {\n        (0, import_util.removeValue)(newObj, k, { descendArray: true });\n      }\n    }\n  }\n  return newObj;\n}\nfunction validateExpression(expr, options) {\n  const check = [false, false];\n  for (const [k, v] of Object.entries(expr)) {\n    if (k === options?.idKey) return;\n    if (v === 0 || v === false) {\n      check[0] = true;\n    } else if (v === 1 || v === true) {\n      check[1] = true;\n    }\n    (0, import_util.assert)(\n      !(check[0] && check[1]),\n      \"Projection cannot have a mix of inclusion and exclusion.\"\n    );\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7191:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar redact_exports = {};\n__export(redact_exports, {\n  $redact: () => $redact\n});\nmodule.exports = __toCommonJS(redact_exports);\nvar import_core = __webpack_require__(2760);\nconst $redact = (collection, expr, options) => {\n  const copts = import_core.ComputeOptions.init(options);\n  return collection.map(\n    (obj) => (0, import_core.redact)(obj, expr, copts.update(obj))\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 31:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar replaceRoot_exports = {};\n__export(replaceRoot_exports, {\n  $replaceRoot: () => $replaceRoot\n});\nmodule.exports = __toCommonJS(replaceRoot_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $replaceRoot = (collection, expr, options) => {\n  return collection.map((obj) => {\n    obj = (0, import_core.computeValue)(obj, expr.newRoot, null, options);\n    (0, import_util.assert)((0, import_util.isObject)(obj), \"$replaceRoot expression must return an object\");\n    return obj;\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 824:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar replaceWith_exports = {};\n__export(replaceWith_exports, {\n  $replaceWith: () => $replaceWith\n});\nmodule.exports = __toCommonJS(replaceWith_exports);\nvar import_core = __webpack_require__(2760);\nvar import_util = __webpack_require__(7839);\nconst $replaceWith = (collection, expr, options) => {\n  return collection.map((obj) => {\n    obj = (0, import_core.computeValue)(obj, expr, null, options);\n    (0, import_util.assert)((0, import_util.isObject)(obj), \"$replaceWith expression must return an object\");\n    return obj;\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9060:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sample_exports = {};\n__export(sample_exports, {\n  $sample: () => $sample\n});\nmodule.exports = __toCommonJS(sample_exports);\nconst $sample = (collection, expr, _options) => {\n  return collection.transform((xs) => {\n    const len = xs.length;\n    let i = -1;\n    return () => {\n      if (++i === expr.size) return { done: true };\n      const n = Math.floor(Math.random() * len);\n      return { value: xs[n], done: false };\n    };\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9640:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar set_exports = {};\n__export(set_exports, {\n  $set: () => $set\n});\nmodule.exports = __toCommonJS(set_exports);\nvar import_addFields = __webpack_require__(5770);\nconst $set = import_addFields.$addFields;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3805:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar setWindowFields_exports = {};\n__export(setWindowFields_exports, {\n  $setWindowFields: () => $setWindowFields\n});\nmodule.exports = __toCommonJS(setWindowFields_exports);\nvar import_core = __webpack_require__(2760);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nvar import_function = __webpack_require__(3388);\nvar import_dateAdd = __webpack_require__(8410);\nvar import_internal = __webpack_require__(2088);\nvar import_addFields = __webpack_require__(5770);\nvar import_group = __webpack_require__(9723);\nvar import_sort = __webpack_require__(4290);\nconst SORT_REQUIRED_OPS = /* @__PURE__ */ new Set([\n  \"$denseRank\",\n  \"$documentNumber\",\n  \"$first\",\n  \"$last\",\n  \"$linearFill\",\n  \"$rank\",\n  \"$shift\"\n]);\nconst WINDOW_UNBOUNDED_OPS = /* @__PURE__ */ new Set([\n  \"$denseRank\",\n  \"$expMovingAvg\",\n  \"$linearFill\",\n  \"$locf\",\n  \"$rank\",\n  \"$shift\"\n]);\nconst $setWindowFields = (collection, expr, options) => {\n  options = (0, import_core.initOptions)(options);\n  options.context.addExpressionOps({ $function: import_function.$function });\n  for (const outputExpr of Object.values(expr.output)) {\n    const keys = Object.keys(outputExpr);\n    const op = keys.find(import_util.isOperator);\n    (0, import_util.assert)(\n      !!(0, import_core.getOperator)(\"window\", op, options) || !!(0, import_core.getOperator)(\"accumulator\", op, options),\n      `'${op}' is not a valid window operator`\n    );\n    (0, import_util.assert)(\n      keys.length > 0 && keys.length <= 2 && (keys.length == 1 || keys.includes(\"window\")),\n      \"'output' option should have a single window operator.\"\n    );\n    if (outputExpr?.window) {\n      const { documents, range } = outputExpr.window;\n      (0, import_util.assert)(\n        !!documents && !range || !documents && !!range || !documents && !range,\n        \"'window' option supports only one of 'documents' or 'range'.\"\n      );\n    }\n  }\n  if (expr.sortBy) {\n    collection = (0, import_sort.$sort)(collection, expr.sortBy, options);\n  }\n  collection = (0, import_group.$group)(\n    collection,\n    {\n      _id: expr.partitionBy,\n      items: { $push: \"$$CURRENT\" }\n    },\n    options\n  );\n  return collection.transform((partitions) => {\n    const iterators = [];\n    const outputConfig = [];\n    for (const [field, outputExpr] of Object.entries(expr.output)) {\n      const op = Object.keys(outputExpr).find(import_util.isOperator);\n      const config = {\n        operatorName: op,\n        func: {\n          left: (0, import_core.getOperator)(\"accumulator\", op, options),\n          right: (0, import_core.getOperator)(\"window\", op, options)\n        },\n        args: outputExpr[op],\n        field,\n        window: outputExpr.window\n      };\n      (0, import_util.assert)(\n        !!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window),\n        `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : \"bounded window operation\"} requires a sortBy.`\n      );\n      (0, import_util.assert)(\n        !config.window || !WINDOW_UNBOUNDED_OPS.has(op),\n        `${op} does not accept a 'window' field.`\n      );\n      outputConfig.push(config);\n    }\n    partitions.forEach((group) => {\n      const items = group.items;\n      let iterator = (0, import_lazy.Lazy)(items);\n      const windowResultMap = {};\n      for (const config of outputConfig) {\n        const { func, args, field, window } = config;\n        const makeResultFunc = (getItemsFn) => {\n          let index = -1;\n          return (obj) => {\n            ++index;\n            if (func.left) {\n              return func.left(getItemsFn(obj, index), args, options);\n            } else if (func.right) {\n              return func.right(\n                obj,\n                getItemsFn(obj, index),\n                {\n                  parentExpr: expr,\n                  inputExpr: args,\n                  documentNumber: index + 1,\n                  field\n                },\n                // must use raw options only since it operates over a collection.\n                options\n              );\n            }\n          };\n        };\n        if (window) {\n          const { documents, range, unit } = window;\n          const boundary = documents || range;\n          if (!(0, import_internal.isUnbounded)(window)) {\n            const [begin, end] = boundary;\n            const toBeginIndex = (currentIndex) => {\n              if (begin == \"current\") return currentIndex;\n              if (begin == \"unbounded\") return 0;\n              return Math.max(begin + currentIndex, 0);\n            };\n            const toEndIndex = (currentIndex) => {\n              if (end == \"current\") return currentIndex + 1;\n              if (end == \"unbounded\") return items.length;\n              return end + currentIndex + 1;\n            };\n            const getItems = (current, index) => {\n              if (!!documents || boundary.every(import_util.isString)) {\n                return items.slice(toBeginIndex(index), toEndIndex(index));\n              }\n              const sortKey = Object.keys(expr.sortBy)[0];\n              let lower;\n              let upper;\n              if (unit) {\n                const getTime = (amount) => {\n                  return (0, import_dateAdd.$dateAdd)(\n                    current,\n                    {\n                      startDate: new Date(current[sortKey]),\n                      unit,\n                      amount\n                    },\n                    options\n                  ).getTime();\n                };\n                lower = (0, import_util.isNumber)(begin) ? getTime(begin) : -Infinity;\n                upper = (0, import_util.isNumber)(end) ? getTime(end) : Infinity;\n              } else {\n                const currentValue = current[sortKey];\n                lower = (0, import_util.isNumber)(begin) ? currentValue + begin : -Infinity;\n                upper = (0, import_util.isNumber)(end) ? currentValue + end : Infinity;\n              }\n              let array = items;\n              if (begin == \"current\") array = items.slice(index);\n              if (end == \"current\") array = items.slice(0, index + 1);\n              return array.filter((o) => {\n                const n = +o[sortKey];\n                return n >= lower && n <= upper;\n              });\n            };\n            windowResultMap[field] = makeResultFunc(getItems);\n          }\n        }\n        if (!windowResultMap[field]) {\n          windowResultMap[field] = makeResultFunc((_) => items);\n        }\n        iterator = (0, import_addFields.$addFields)(\n          iterator,\n          {\n            [field]: {\n              $function: {\n                body: (obj) => windowResultMap[field](obj),\n                args: [\"$$CURRENT\"]\n              }\n            }\n          },\n          options\n        );\n      }\n      iterators.push(iterator);\n    });\n    return (0, import_lazy.concat)(...iterators);\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8861:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar skip_exports = {};\n__export(skip_exports, {\n  $skip: () => $skip\n});\nmodule.exports = __toCommonJS(skip_exports);\nconst $skip = (collection, expr, _options) => {\n  return collection.drop(expr);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4290:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sort_exports = {};\n__export(sort_exports, {\n  $sort: () => $sort\n});\nmodule.exports = __toCommonJS(sort_exports);\nvar import_util = __webpack_require__(7839);\nconst $sort = (collection, sortKeys, options) => {\n  if ((0, import_util.isEmpty)(sortKeys) || !(0, import_util.isObject)(sortKeys)) return collection;\n  let cmp = import_util.compare;\n  const collationSpec = options.collation;\n  if ((0, import_util.isObject)(collationSpec) && (0, import_util.isString)(collationSpec.locale)) {\n    cmp = collationComparator(collationSpec);\n  }\n  return collection.transform((coll) => {\n    const modifiers = Object.keys(sortKeys);\n    for (const key of modifiers.reverse()) {\n      const groups = (0, import_util.groupBy)(\n        coll,\n        (obj) => (0, import_util.resolve)(obj, key),\n        options.hashFunction\n      );\n      const sortedKeys = Array.from(groups.keys()).sort(cmp);\n      if (sortKeys[key] === -1) sortedKeys.reverse();\n      let i = 0;\n      for (const k of sortedKeys) for (const v of groups.get(k)) coll[i++] = v;\n      (0, import_util.assert)(i == coll.length, \"bug: counter must match collection size.\");\n    }\n    return coll;\n  });\n};\nconst COLLATION_STRENGTH = {\n  // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.\n  1: \"base\",\n  //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.\n  // Examples: a ≠ b, a ≠ á, a = A.\n  2: \"accent\",\n  // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.\n  // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A\n  3: \"variant\"\n  // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.\n};\nfunction collationComparator(spec) {\n  const localeOpt = {\n    sensitivity: COLLATION_STRENGTH[spec.strength || 3],\n    caseFirst: spec.caseFirst === \"off\" ? \"false\" : spec.caseFirst || \"false\",\n    numeric: spec.numericOrdering || false,\n    ignorePunctuation: spec.alternate === \"shifted\"\n  };\n  if ((spec.caseLevel || false) === true) {\n    if (localeOpt.sensitivity === \"base\") localeOpt.sensitivity = \"case\";\n    if (localeOpt.sensitivity === \"accent\") localeOpt.sensitivity = \"variant\";\n  }\n  const collator = new Intl.Collator(spec.locale, localeOpt);\n  return (a, b) => {\n    if (!(0, import_util.isString)(a) || !(0, import_util.isString)(b)) return (0, import_util.compare)(a, b);\n    const i = collator.compare(a, b);\n    if (i < 0) return -1;\n    if (i > 0) return 1;\n    return 0;\n  };\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7708:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar sortByCount_exports = {};\n__export(sortByCount_exports, {\n  $sortByCount: () => $sortByCount\n});\nmodule.exports = __toCommonJS(sortByCount_exports);\nvar import_group = __webpack_require__(9723);\nvar import_sort = __webpack_require__(4290);\nconst $sortByCount = (collection, expr, options) => {\n  return (0, import_sort.$sort)(\n    (0, import_group.$group)(collection, { _id: expr, count: { $sum: 1 } }, options),\n    { count: -1 },\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1347:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar unionWith_exports = {};\n__export(unionWith_exports, {\n  $unionWith: () => $unionWith\n});\nmodule.exports = __toCommonJS(unionWith_exports);\nvar import_aggregator = __webpack_require__(6878);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nconst $unionWith = (collection, expr, options) => {\n  const array = (0, import_util.isString)(expr.coll) ? options.collectionResolver(expr.coll) : expr.coll;\n  const iterators = [collection];\n  iterators.push(\n    expr.pipeline ? new import_aggregator.Aggregator(expr.pipeline, options).stream(array) : (0, import_lazy.Lazy)(array)\n  );\n  return (0, import_lazy.concat)(...iterators);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 829:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar unset_exports = {};\n__export(unset_exports, {\n  $unset: () => $unset\n});\nmodule.exports = __toCommonJS(unset_exports);\nvar import_util = __webpack_require__(7839);\nvar import_project = __webpack_require__(2401);\nconst $unset = (collection, expr, options) => {\n  expr = (0, import_util.ensureArray)(expr);\n  const doc = {};\n  for (const k of expr) doc[k] = 0;\n  return (0, import_project.$project)(collection, doc, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3143:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar unwind_exports = {};\n__export(unwind_exports, {\n  $unwind: () => $unwind\n});\nmodule.exports = __toCommonJS(unwind_exports);\nvar import_lazy = __webpack_require__(8625);\nvar import_util = __webpack_require__(7839);\nconst $unwind = (collection, expr, _options) => {\n  if ((0, import_util.isString)(expr)) expr = { path: expr };\n  const path = expr.path;\n  const field = path.substring(1);\n  const includeArrayIndex = expr?.includeArrayIndex || false;\n  const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;\n  const format = (o, i) => {\n    if (includeArrayIndex !== false) o[includeArrayIndex] = i;\n    return o;\n  };\n  let value;\n  return (0, import_lazy.Lazy)(() => {\n    for (; ; ) {\n      if (value instanceof import_lazy.Iterator) {\n        const tmp = value.next();\n        if (!tmp.done) return tmp;\n      }\n      const wrapper = collection.next();\n      if (wrapper.done) return wrapper;\n      const obj = wrapper.value;\n      value = (0, import_util.resolve)(obj, field);\n      if ((0, import_util.isArray)(value)) {\n        if (value.length === 0 && preserveNullAndEmptyArrays === true) {\n          value = null;\n          (0, import_util.removeValue)(obj, field);\n          return { value: format(obj, null), done: false };\n        } else {\n          value = (0, import_lazy.Lazy)(value).map((item, i) => {\n            const newObj = (0, import_util.resolveGraph)(obj, field, {\n              preserveKeys: true\n            });\n            (0, import_util.setValue)(newObj, field, item);\n            return format(newObj, i);\n          });\n        }\n      } else if (!(0, import_util.isEmpty)(value) || preserveNullAndEmptyArrays === true) {\n        return { value: format(obj, null), done: false };\n      }\n    }\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5975:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar elemMatch_exports = {};\n__export(elemMatch_exports, {\n  $elemMatch: () => $elemMatch\n});\nmodule.exports = __toCommonJS(elemMatch_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nconst $elemMatch = (obj, expr, field, options) => {\n  const arr = (0, import_util.resolve)(obj, field);\n  const query = new import_query.Query(expr, options);\n  (0, import_util.assert)((0, import_util.isArray)(arr), \"$elemMatch: argument must resolve to array\");\n  const result = [];\n  for (let i = 0; i < arr.length; i++) {\n    if (query.test(arr[i])) {\n      if (options.useStrictMode) return [arr[i]];\n      result.push(arr[i]);\n    }\n  }\n  return result.length > 0 ? result : void 0;\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4487:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar projection_exports = {};\nmodule.exports = __toCommonJS(projection_exports);\n__reExport(projection_exports, __webpack_require__(5975), module.exports);\n__reExport(projection_exports, __webpack_require__(2169), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2169:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar slice_exports = {};\n__export(slice_exports, {\n  $slice: () => $slice\n});\nmodule.exports = __toCommonJS(slice_exports);\nvar import_util = __webpack_require__(7839);\nvar import_slice = __webpack_require__(7292);\nconst $slice = (obj, expr, field, options) => {\n  const xs = (0, import_util.resolve)(obj, field);\n  const exprAsArray = expr;\n  if (!(0, import_util.isArray)(xs)) return xs;\n  return (0, import_slice.$slice)(\n    obj,\n    (0, import_util.isArray)(expr) ? [xs, ...exprAsArray] : [xs, expr],\n    options\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6007:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar all_exports = {};\n__export(all_exports, {\n  $all: () => $all\n});\nmodule.exports = __toCommonJS(all_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $all = (0, import_predicates.createQueryOperator)(import_predicates.$all);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2604:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar elemMatch_exports = {};\n__export(elemMatch_exports, {\n  $elemMatch: () => $elemMatch\n});\nmodule.exports = __toCommonJS(elemMatch_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $elemMatch = (0, import_predicates.createQueryOperator)(import_predicates.$elemMatch);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4748:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar array_exports = {};\nmodule.exports = __toCommonJS(array_exports);\n__reExport(array_exports, __webpack_require__(6007), module.exports);\n__reExport(array_exports, __webpack_require__(2604), module.exports);\n__reExport(array_exports, __webpack_require__(6143), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6143:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar size_exports = {};\n__export(size_exports, {\n  $size: () => $size\n});\nmodule.exports = __toCommonJS(size_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $size = (0, import_predicates.createQueryOperator)(import_predicates.$size);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5450:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  createBitwiseOperator: () => createBitwiseOperator\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_util = __webpack_require__(7839);\nvar import_predicates = __webpack_require__(4330);\nconst createBitwiseOperator = (predicate) => {\n  return (0, import_predicates.createQueryOperator)(\n    (value, mask, _options) => {\n      let b = 0;\n      if ((0, import_util.isArray)(mask)) {\n        for (const n of mask) b = b | 1 << n;\n      } else {\n        b = mask;\n      }\n      return predicate(value & b, b);\n    }\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1996:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitsAllClear_exports = {};\n__export(bitsAllClear_exports, {\n  $bitsAllClear: () => $bitsAllClear\n});\nmodule.exports = __toCommonJS(bitsAllClear_exports);\nvar import_internal = __webpack_require__(5450);\nconst $bitsAllClear = (0, import_internal.createBitwiseOperator)((result, _) => result == 0);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7537:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitsAllSet_exports = {};\n__export(bitsAllSet_exports, {\n  $bitsAllSet: () => $bitsAllSet\n});\nmodule.exports = __toCommonJS(bitsAllSet_exports);\nvar import_internal = __webpack_require__(5450);\nconst $bitsAllSet = (0, import_internal.createBitwiseOperator)(\n  (result, mask) => result == mask\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6864:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitsAnyClear_exports = {};\n__export(bitsAnyClear_exports, {\n  $bitsAnyClear: () => $bitsAnyClear\n});\nmodule.exports = __toCommonJS(bitsAnyClear_exports);\nvar import_internal = __webpack_require__(5450);\nconst $bitsAnyClear = (0, import_internal.createBitwiseOperator)(\n  (result, mask) => result < mask\n);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4010:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitsAnySet_exports = {};\n__export(bitsAnySet_exports, {\n  $bitsAnySet: () => $bitsAnySet\n});\nmodule.exports = __toCommonJS(bitsAnySet_exports);\nvar import_internal = __webpack_require__(5450);\nconst $bitsAnySet = (0, import_internal.createBitwiseOperator)((result, _) => result > 0);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8286:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bitwise_exports = {};\n__export(bitwise_exports, {\n  $bitsAllClear: () => import_bitsAllClear.$bitsAllClear,\n  $bitsAllSet: () => import_bitsAllSet.$bitsAllSet,\n  $bitsAnyClear: () => import_bitsAnyClear.$bitsAnyClear,\n  $bitsAnySet: () => import_bitsAnySet.$bitsAnySet\n});\nmodule.exports = __toCommonJS(bitwise_exports);\nvar import_bitsAllClear = __webpack_require__(1996);\nvar import_bitsAllSet = __webpack_require__(7537);\nvar import_bitsAnyClear = __webpack_require__(6864);\nvar import_bitsAnySet = __webpack_require__(4010);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7586:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar eq_exports = {};\n__export(eq_exports, {\n  $eq: () => $eq\n});\nmodule.exports = __toCommonJS(eq_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $eq = (0, import_predicates.createQueryOperator)(import_predicates.$eq);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1855:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar gt_exports = {};\n__export(gt_exports, {\n  $gt: () => $gt\n});\nmodule.exports = __toCommonJS(gt_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $gt = (0, import_predicates.createQueryOperator)(import_predicates.$gt);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4268:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar gte_exports = {};\n__export(gte_exports, {\n  $gte: () => $gte\n});\nmodule.exports = __toCommonJS(gte_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $gte = (0, import_predicates.createQueryOperator)(import_predicates.$gte);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4399:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar in_exports = {};\n__export(in_exports, {\n  $in: () => $in\n});\nmodule.exports = __toCommonJS(in_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $in = (0, import_predicates.createQueryOperator)(import_predicates.$in);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3338:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar comparison_exports = {};\n__export(comparison_exports, {\n  $eq: () => import_eq.$eq,\n  $gt: () => import_gt.$gt,\n  $gte: () => import_gte.$gte,\n  $in: () => import_in.$in,\n  $lt: () => import_lt.$lt,\n  $lte: () => import_lte.$lte,\n  $ne: () => import_ne.$ne,\n  $nin: () => import_nin.$nin\n});\nmodule.exports = __toCommonJS(comparison_exports);\nvar import_eq = __webpack_require__(7586);\nvar import_gt = __webpack_require__(1855);\nvar import_gte = __webpack_require__(4268);\nvar import_in = __webpack_require__(4399);\nvar import_lt = __webpack_require__(7768);\nvar import_lte = __webpack_require__(3525);\nvar import_ne = __webpack_require__(4793);\nvar import_nin = __webpack_require__(819);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7768:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lt_exports = {};\n__export(lt_exports, {\n  $lt: () => $lt\n});\nmodule.exports = __toCommonJS(lt_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $lt = (0, import_predicates.createQueryOperator)(import_predicates.$lt);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3525:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar lte_exports = {};\n__export(lte_exports, {\n  $lte: () => $lte\n});\nmodule.exports = __toCommonJS(lte_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $lte = (0, import_predicates.createQueryOperator)(import_predicates.$lte);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4793:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar ne_exports = {};\n__export(ne_exports, {\n  $ne: () => $ne\n});\nmodule.exports = __toCommonJS(ne_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $ne = (0, import_predicates.createQueryOperator)(import_predicates.$ne);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 819:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar nin_exports = {};\n__export(nin_exports, {\n  $nin: () => $nin\n});\nmodule.exports = __toCommonJS(nin_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $nin = (0, import_predicates.createQueryOperator)(import_predicates.$nin);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1917:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar exists_exports = {};\n__export(exists_exports, {\n  $exists: () => $exists\n});\nmodule.exports = __toCommonJS(exists_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $exists = (0, import_predicates.createQueryOperator)(import_predicates.$exists);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2206:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar element_exports = {};\nmodule.exports = __toCommonJS(element_exports);\n__reExport(element_exports, __webpack_require__(1917), module.exports);\n__reExport(element_exports, __webpack_require__(3989), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3989:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar type_exports = {};\n__export(type_exports, {\n  $type: () => $type\n});\nmodule.exports = __toCommonJS(type_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $type = (0, import_predicates.createQueryOperator)(import_predicates.$type);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9170:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar expr_exports = {};\n__export(expr_exports, {\n  $expr: () => $expr\n});\nmodule.exports = __toCommonJS(expr_exports);\nvar import_core = __webpack_require__(2760);\nfunction $expr(_, rhs, options) {\n  return (obj) => (0, import_core.computeValue)(obj, rhs, null, options);\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5437:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar evaluation_exports = {};\nmodule.exports = __toCommonJS(evaluation_exports);\n__reExport(evaluation_exports, __webpack_require__(9170), module.exports);\n__reExport(evaluation_exports, __webpack_require__(3008), module.exports);\n__reExport(evaluation_exports, __webpack_require__(1661), module.exports);\n__reExport(evaluation_exports, __webpack_require__(3130), module.exports);\n__reExport(evaluation_exports, __webpack_require__(3617), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3008:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar jsonSchema_exports = {};\n__export(jsonSchema_exports, {\n  $jsonSchema: () => $jsonSchema\n});\nmodule.exports = __toCommonJS(jsonSchema_exports);\nvar import_util = __webpack_require__(7839);\nfunction $jsonSchema(_, schema, options) {\n  if (!options?.jsonSchemaValidator) {\n    throw new import_util.MingoError(\n      \"Missing option 'jsonSchemaValidator'. Configure to use '$jsonSchema' operator.\"\n    );\n  }\n  const validate = options?.jsonSchemaValidator(schema);\n  return (obj) => validate(obj);\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1661:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar mod_exports = {};\n__export(mod_exports, {\n  $mod: () => $mod\n});\nmodule.exports = __toCommonJS(mod_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $mod = (0, import_predicates.createQueryOperator)(import_predicates.$mod);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3130:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar regex_exports = {};\n__export(regex_exports, {\n  $regex: () => $regex\n});\nmodule.exports = __toCommonJS(regex_exports);\nvar import_predicates = __webpack_require__(4330);\nconst $regex = (0, import_predicates.createQueryOperator)(import_predicates.$regex);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3617:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar where_exports = {};\n__export(where_exports, {\n  $where: () => $where\n});\nmodule.exports = __toCommonJS(where_exports);\nvar import_util = __webpack_require__(7839);\nfunction $where(_, rhs, options) {\n  (0, import_util.assert)(\n    options.scriptEnabled,\n    \"$where operator requires 'scriptEnabled' option to be true\"\n  );\n  const f = rhs;\n  (0, import_util.assert)((0, import_util.isFunction)(f), \"$where only accepts a Function object\");\n  return (obj) => (0, import_util.truthy)(f.call(obj), options?.useStrictMode);\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8510:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar query_exports = {};\nmodule.exports = __toCommonJS(query_exports);\n__reExport(query_exports, __webpack_require__(4748), module.exports);\n__reExport(query_exports, __webpack_require__(8286), module.exports);\n__reExport(query_exports, __webpack_require__(3338), module.exports);\n__reExport(query_exports, __webpack_require__(2206), module.exports);\n__reExport(query_exports, __webpack_require__(5437), module.exports);\n__reExport(query_exports, __webpack_require__(7218), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2096:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar and_exports = {};\n__export(and_exports, {\n  $and: () => $and\n});\nmodule.exports = __toCommonJS(and_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nconst $and = (_, rhs, options) => {\n  (0, import_util.assert)(\n    (0, import_util.isArray)(rhs),\n    \"Invalid expression: $and expects value to be an Array.\"\n  );\n  const queries = rhs.map((expr) => new import_query.Query(expr, options));\n  return (obj) => queries.every((q) => q.test(obj));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7218:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar logical_exports = {};\nmodule.exports = __toCommonJS(logical_exports);\n__reExport(logical_exports, __webpack_require__(2096), module.exports);\n__reExport(logical_exports, __webpack_require__(737), module.exports);\n__reExport(logical_exports, __webpack_require__(1083), module.exports);\n__reExport(logical_exports, __webpack_require__(7805), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 737:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar nor_exports = {};\n__export(nor_exports, {\n  $nor: () => $nor\n});\nmodule.exports = __toCommonJS(nor_exports);\nvar import_util = __webpack_require__(7839);\nvar import_or = __webpack_require__(7805);\nconst $nor = (_, rhs, options) => {\n  (0, import_util.assert)(\n    (0, import_util.isArray)(rhs),\n    \"Invalid expression. $nor expects value to be an array.\"\n  );\n  const f = (0, import_or.$or)(\"$or\", rhs, options);\n  return (obj) => !f(obj);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1083:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar not_exports = {};\n__export(not_exports, {\n  $not: () => $not\n});\nmodule.exports = __toCommonJS(not_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nconst $not = (selector, rhs, options) => {\n  const criteria = {};\n  criteria[selector] = (0, import_util.normalize)(rhs);\n  const query = new import_query.Query(criteria, options);\n  return (obj) => !query.test(obj);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7805:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar or_exports = {};\n__export(or_exports, {\n  $or: () => $or\n});\nmodule.exports = __toCommonJS(or_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nconst $or = (_, rhs, options) => {\n  (0, import_util.assert)((0, import_util.isArray)(rhs), \"Invalid expression. $or expects value to be an Array\");\n  const queries = rhs.map((expr) => new import_query.Query(expr, options));\n  return (obj) => queries.some((q) => q.test(obj));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3695:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  applyUpdate: () => applyUpdate,\n  clone: () => clone,\n  tokenizePath: () => tokenizePath,\n  walkExpression: () => walkExpression\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nconst clone = (mode, val) => {\n  switch (mode) {\n    case \"deep\":\n      return (0, import_util.cloneDeep)(val);\n    case \"copy\": {\n      if ((0, import_util.isDate)(val)) return new Date(val);\n      if ((0, import_util.isArray)(val)) return [...val];\n      if ((0, import_util.isObject)(val)) return { ...val };\n      if ((0, import_util.isRegExp)(val)) return new RegExp(val);\n      return val;\n    }\n    default:\n      return val;\n  }\n};\nconst FILTER_IDENT_RE = /^[a-z]+[a-zA-Z0-9]*$/;\nfunction tokenizePath(selector) {\n  if (!selector.includes(\".$\")) {\n    return [{ parent: selector, selector }, []];\n  }\n  const begin = selector.indexOf(\".$\");\n  const end = selector.indexOf(\"]\");\n  const parent = selector.substring(0, begin);\n  const child = selector.substring(begin + 3, end);\n  (0, import_util.assert)(\n    child === \"\" || FILTER_IDENT_RE.test(child),\n    \"The filter <identifier> must begin with a lowercase letter and contain only alphanumeric characters.\"\n  );\n  const rest = selector.substring(end + 2);\n  const [next, elems] = rest ? tokenizePath(rest) : [];\n  return [\n    { selector, parent, child: child || \"$\", next },\n    [child, ...elems || []].filter(Boolean)\n  ];\n}\nconst applyUpdate = (o, n, q, f, opts) => {\n  const { parent, child: c, next } = n;\n  if (!c) {\n    let b = false;\n    const g = (u, k) => b = Boolean(f(u, k)) || b;\n    (0, import_util.walk)(o, parent, g, opts);\n    return b;\n  }\n  const t = (0, import_util.resolve)(o, parent);\n  if (!(0, import_util.isArray)(t)) return false;\n  return t.map((e, i) => {\n    if (q[c] && !q[c].test({ [c]: e })) return false;\n    return next ? applyUpdate(e, next, q, f, opts) : f(t, i);\n  }).some(Boolean);\n};\nfunction walkExpression(expr, arrayFilter, options, callback) {\n  const res = [];\n  for (const [selector, val] of Object.entries(expr)) {\n    const [node, vars] = tokenizePath(selector);\n    if (!vars.length) {\n      if (callback(val, node, {})) res.push(node.parent);\n    } else {\n      const conditions = {};\n      arrayFilter.forEach((o) => {\n        Object.keys(o).forEach((k) => {\n          vars.forEach((w) => {\n            if (k === w || k.startsWith(w + \".\")) {\n              conditions[w] = conditions[w] || {};\n              Object.assign(conditions[w], { [k]: o[k] });\n            }\n          });\n        });\n      });\n      const queries = {};\n      for (const [k, condition] of Object.entries(conditions)) {\n        queries[k] = new import_query.Query(condition, options.queryOptions);\n      }\n      if (callback(val, node, queries)) res.push(node.parent);\n    }\n  }\n  return res;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7985:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar addToSet_exports = {};\n__export(addToSet_exports, {\n  $addToSet: () => $addToSet\n});\nmodule.exports = __toCommonJS(addToSet_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $addToSet = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    const args = { $each: [val] };\n    if ((0, import_util.isObject)(val) && (0, import_util.has)(val, \"$each\")) {\n      Object.assign(args, val);\n    }\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        const prev = o[k] ||= [];\n        const common = (0, import_util.intersection)([prev, args.$each]);\n        if (common.length === args.$each.length) return false;\n        o[k] = (0, import_internal.clone)(options.cloneMode, (0, import_util.unique)(prev.concat(args.$each)));\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2592:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar bit_exports = {};\n__export(bit_exports, {\n  $bit: () => $bit\n});\nmodule.exports = __toCommonJS(bit_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst BIT_OPS = /* @__PURE__ */ new Set([\"and\", \"or\", \"xor\"]);\nconst $bit = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    const op = Object.keys(val);\n    (0, import_util.assert)(\n      op.length === 1 && BIT_OPS.has(op[0]),\n      `Invalid bit operator '${op[0]}'. Must be one of 'and', 'or', or 'xor'.`\n    );\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        let n = o[k];\n        const v = val[op[0]];\n        if (n !== void 0 && !((0, import_util.isNumber)(n) && (0, import_util.isNumber)(v))) return false;\n        n = n || 0;\n        switch (op[0]) {\n          case \"and\":\n            o[k] = n & v;\n            break;\n          case \"or\":\n            o[k] = n | v;\n            break;\n          case \"xor\":\n            o[k] = n ^ v;\n            break;\n        }\n        return o[k] !== n;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7346:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar currentDate_exports = {};\n__export(currentDate_exports, {\n  $currentDate: () => $currentDate\n});\nmodule.exports = __toCommonJS(currentDate_exports);\nvar import_internal = __webpack_require__(3695);\nconst $currentDate = (obj, expr, arrayFilters = [], options = {}) => {\n  const now = Date.now();\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        o[k] = now;\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8891:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar inc_exports = {};\n__export(inc_exports, {\n  $inc: () => $inc\n});\nmodule.exports = __toCommonJS(inc_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $inc = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    if (!node.child) {\n      const n = (0, import_util.resolve)(obj, node.parent);\n      (0, import_util.assert)(\n        n === void 0 || (0, import_util.isNumber)(n),\n        `cannot apply $inc to a value of non-numeric type`\n      );\n    }\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        o[k] = (o[k] ||= 0) + val;\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2835:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, \"default\"), secondTarget && __copyProps(secondTarget, mod, \"default\"));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar update_exports = {};\nmodule.exports = __toCommonJS(update_exports);\n__reExport(update_exports, __webpack_require__(7985), module.exports);\n__reExport(update_exports, __webpack_require__(2592), module.exports);\n__reExport(update_exports, __webpack_require__(7346), module.exports);\n__reExport(update_exports, __webpack_require__(8891), module.exports);\n__reExport(update_exports, __webpack_require__(1929), module.exports);\n__reExport(update_exports, __webpack_require__(2619), module.exports);\n__reExport(update_exports, __webpack_require__(9017), module.exports);\n__reExport(update_exports, __webpack_require__(628), module.exports);\n__reExport(update_exports, __webpack_require__(4868), module.exports);\n__reExport(update_exports, __webpack_require__(6381), module.exports);\n__reExport(update_exports, __webpack_require__(9891), module.exports);\n__reExport(update_exports, __webpack_require__(1461), module.exports);\n__reExport(update_exports, __webpack_require__(8356), module.exports);\n__reExport(update_exports, __webpack_require__(8402), module.exports);\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1929:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar max_exports = {};\n__export(max_exports, {\n  $max: () => $max\n});\nmodule.exports = __toCommonJS(max_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $max = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) > -1) return false;\n        o[k] = val;\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 2619:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar min_exports = {};\n__export(min_exports, {\n  $min: () => $min\n});\nmodule.exports = __toCommonJS(min_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $min = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        if (o[k] !== void 0 && (0, import_util.compare)(o[k], val) < 1) return false;\n        o[k] = val;\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9017:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar mul_exports = {};\n__export(mul_exports, {\n  $mul: () => $mul\n});\nmodule.exports = __toCommonJS(mul_exports);\nvar import_internal = __webpack_require__(3695);\nconst $mul = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        const prev = o[k];\n        o[k] = o[k] === void 0 ? 0 : o[k] * val;\n        return o[k] !== prev;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 628:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar pop_exports = {};\n__export(pop_exports, {\n  $pop: () => $pop\n});\nmodule.exports = __toCommonJS(pop_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $pop = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {\n      const arr = o[k];\n      (0, import_util.assert)(\n        (0, import_util.isArray)(arr),\n        `path '${node.selector}' contains an element of non-array type.`\n      );\n      if (!arr.length) return false;\n      if (val === -1) {\n        arr.splice(0, 1);\n      } else {\n        arr.pop();\n      }\n      return true;\n    });\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4868:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar pull_exports = {};\n__export(pull_exports, {\n  $pull: () => $pull\n});\nmodule.exports = __toCommonJS(pull_exports);\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $pull = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    const wrap = !(0, import_util.isObject)(val) || Object.keys(val).some(import_util.isOperator);\n    const query = new import_query.Query(\n      wrap ? { k: val } : val,\n      options.queryOptions\n    );\n    const pred = wrap ? (v) => query.test({ k: v }) : (v) => query.test(v);\n    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {\n      const prev = o[k];\n      const curr = new Array();\n      const found = prev.map((v) => {\n        const b = pred(v);\n        if (!b) curr.push(v);\n        return b;\n      }).some(Boolean);\n      if (!found) return false;\n      o[k] = curr;\n      return true;\n    });\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6381:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar pullAll_exports = {};\n__export(pullAll_exports, {\n  $pullAll: () => $pullAll\n});\nmodule.exports = __toCommonJS(pullAll_exports);\nvar import_pull = __webpack_require__(4868);\nconst $pullAll = (obj, expr, arrayFilters = [], options = {}) => {\n  const pullExpr = {};\n  Object.entries(expr).forEach(([k, v]) => {\n    pullExpr[k] = { $in: v };\n  });\n  return (0, import_pull.$pull)(obj, pullExpr, arrayFilters, options);\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 9891:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar push_exports = {};\n__export(push_exports, {\n  $push: () => $push\n});\nmodule.exports = __toCommonJS(push_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst OPERATOR_MODIFIERS = Object.freeze([\n  \"$each\",\n  \"$slice\",\n  \"$sort\",\n  \"$position\"\n]);\nconst $push = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    const args = {\n      $each: [val]\n    };\n    if ((0, import_util.isObject)(val) && OPERATOR_MODIFIERS.some((m) => (0, import_util.has)(val, m))) {\n      Object.assign(args, val);\n    }\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        const arr = o[k] ||= [];\n        const prev = arr.slice(0, args.$slice || arr.length);\n        const oldsize = arr.length;\n        const pos = (0, import_util.isNumber)(args.$position) ? args.$position : arr.length;\n        arr.splice(pos, 0, ...(0, import_internal.clone)(options.cloneMode, args.$each));\n        if (args.$sort) {\n          const sortKey = (0, import_util.isObject)(args.$sort) ? Object.keys(args.$sort || {}).pop() : \"\";\n          const order = !sortKey ? args.$sort : args.$sort[sortKey];\n          const f = !sortKey ? (a) => a : (a) => (0, import_util.resolve)(a, sortKey);\n          arr.sort((a, b) => order * (0, import_util.compare)(f(a), f(b)));\n        }\n        if ((0, import_util.isNumber)(args.$slice)) {\n          if (args.$slice < 0) arr.splice(0, arr.length + args.$slice);\n          else arr.splice(args.$slice);\n        }\n        return oldsize != arr.length || !(0, import_util.isEqual)(prev, arr);\n      },\n      { descendArray: true, buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 1461:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar rename_exports = {};\n__export(rename_exports, {\n  $rename: () => $rename\n});\nmodule.exports = __toCommonJS(rename_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nvar import_set = __webpack_require__(8356);\nconst $rename = (obj, expr, arrayFilters = [], options = {}) => {\n  const res = [];\n  const changed = (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {\n      if (!(0, import_util.has)(o, k)) return false;\n      res.push(...(0, import_set.$set)(obj, { [val]: o[k] }, arrayFilters, options));\n      delete o[k];\n      return true;\n    });\n  });\n  return Array.from(new Set(changed.concat(res)));\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8356:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar set_exports = {};\n__export(set_exports, {\n  $set: () => $set\n});\nmodule.exports = __toCommonJS(set_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $set = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (val, node, queries) => {\n    return (0, import_internal.applyUpdate)(\n      obj,\n      node,\n      queries,\n      (o, k) => {\n        if ((0, import_util.isEqual)(o[k], val)) return false;\n        o[k] = (0, import_internal.clone)(options.cloneMode, val);\n        return true;\n      },\n      { buildGraph: true }\n    );\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 8402:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar unset_exports = {};\n__export(unset_exports, {\n  $unset: () => $unset\n});\nmodule.exports = __toCommonJS(unset_exports);\nvar import_util = __webpack_require__(7839);\nvar import_internal = __webpack_require__(3695);\nconst $unset = (obj, expr, arrayFilters = [], options = {}) => {\n  return (0, import_internal.walkExpression)(expr, arrayFilters, options, (_, node, queries) => {\n    return (0, import_internal.applyUpdate)(obj, node, queries, (o, k) => {\n      if (!(0, import_util.has)(o, k)) return false;\n      if ((0, import_util.isArray)(o)) {\n        o[k] = null;\n      } else {\n        delete o[k];\n      }\n      return true;\n    });\n  });\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 5914:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar internal_exports = {};\n__export(internal_exports, {\n  MILLIS_PER_UNIT: () => MILLIS_PER_UNIT,\n  rank: () => rank,\n  withMemo: () => withMemo\n});\nmodule.exports = __toCommonJS(internal_exports);\nvar import_util = __webpack_require__(7839);\nvar import_accumulator = __webpack_require__(1248);\nvar import_internal = __webpack_require__(1277);\nvar import_internal2 = __webpack_require__(2088);\nconst MILLIS_PER_UNIT = {\n  week: import_internal.MILLIS_PER_DAY * 7,\n  day: import_internal.MILLIS_PER_DAY,\n  hour: import_internal.MILLIS_PER_DAY / 24,\n  minute: 6e4,\n  second: 1e3,\n  millisecond: 1\n};\nconst memo = /* @__PURE__ */ new WeakMap();\nfunction withMemo(collection, expr, cacheFn, fn) {\n  if (!(0, import_internal2.isUnbounded)(expr.parentExpr.output[expr.field].window)) {\n    return fn(cacheFn());\n  }\n  if (!memo.has(collection)) {\n    memo.set(collection, { [expr.field]: cacheFn() });\n  }\n  const data = memo.get(collection);\n  if (data[expr.field] === void 0) {\n    data[expr.field] = cacheFn();\n  }\n  let failed = false;\n  try {\n    return fn(data[expr.field]);\n  } catch {\n    failed = true;\n  } finally {\n    if (failed || expr.documentNumber === collection.length) {\n      delete data[expr.field];\n      if (Object.keys(data).length === 0) memo.delete(collection);\n    }\n  }\n}\nfunction rank(_, collection, expr, options, dense) {\n  return withMemo(\n    collection,\n    expr,\n    () => {\n      const sortKey = \"$\" + Object.keys(expr.parentExpr.sortBy)[0];\n      const values = (0, import_accumulator.$push)(collection, sortKey, options);\n      const groups = (0, import_util.groupBy)(\n        values,\n        (_2, n) => values[n],\n        options.hashFunction\n      );\n      return { values, groups };\n    },\n    (input) => {\n      const { values, groups: partitions } = input;\n      if (partitions.size == collection.length) {\n        return expr.documentNumber;\n      }\n      const current = values[expr.documentNumber - 1];\n      let i = 0;\n      let offset = 0;\n      for (const key of partitions.keys()) {\n        if ((0, import_util.isEqual)(current, key)) {\n          return dense ? i + 1 : offset + 1;\n        }\n        i++;\n        offset += partitions.get(key).length;\n      }\n      throw new import_util.MingoError(\n        \"rank: invalid return value. please submit a bug report.\"\n      );\n    }\n  );\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4276:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar linearFill_exports = {};\n__export(linearFill_exports, {\n  $linearFill: () => $linearFill\n});\nmodule.exports = __toCommonJS(linearFill_exports);\nvar import_util = __webpack_require__(7839);\nvar import_accumulator = __webpack_require__(1248);\nvar import_internal = __webpack_require__(5914);\nconst interpolate = (x1, y1, x2, y2, x) => y1 + (x - x1) * ((y2 - y1) / (x2 - x1));\nconst $linearFill = (_, collection, expr, options) => {\n  return (0, import_internal.withMemo)(\n    collection,\n    expr,\n    () => {\n      const sortKey = \"$\" + Object.keys(expr.parentExpr.sortBy)[0];\n      const points = (0, import_accumulator.$push)(\n        collection,\n        [sortKey, expr.inputExpr],\n        options\n      ).filter(([x, _2]) => (0, import_util.isNumber)(+x));\n      if (points.length !== collection.length) return null;\n      let lindex = -1;\n      let rindex = 0;\n      while (rindex < points.length) {\n        while (lindex + 1 < points.length && (0, import_util.isNumber)(points[lindex + 1][1])) {\n          lindex++;\n          rindex = lindex;\n        }\n        while (rindex + 1 < points.length && !(0, import_util.isNumber)(points[rindex + 1][1])) {\n          rindex++;\n        }\n        if (rindex + 1 >= points.length) break;\n        rindex++;\n        while (lindex + 1 < rindex) {\n          points[lindex + 1][1] = interpolate(\n            points[lindex][0],\n            points[lindex][1],\n            points[rindex][0],\n            points[rindex][1],\n            points[lindex + 1][0]\n          );\n          lindex++;\n        }\n        lindex = rindex;\n      }\n      return points.map(([_2, y]) => y);\n    },\n    (values) => values[expr.documentNumber - 1]\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 4140:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar locf_exports = {};\n__export(locf_exports, {\n  $locf: () => $locf\n});\nmodule.exports = __toCommonJS(locf_exports);\nvar import_util = __webpack_require__(7839);\nvar import_push = __webpack_require__(4518);\nvar import_internal = __webpack_require__(5914);\nconst $locf = (_, collection, expr, options) => {\n  return (0, import_internal.withMemo)(\n    collection,\n    expr,\n    () => {\n      const values = (0, import_push.$push)(collection, expr.inputExpr, options);\n      for (let i = 1; i < values.length; i++) {\n        if ((0, import_util.isNil)(values[i])) values[i] = values[i - 1];\n      }\n      return values;\n    },\n    (series) => series[expr.documentNumber - 1]\n  );\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 6535:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar query_exports = {};\n__export(query_exports, {\n  Query: () => Query\n});\nmodule.exports = __toCommonJS(query_exports);\nvar import_core = __webpack_require__(2760);\nvar import_cursor = __webpack_require__(4529);\nvar import_util = __webpack_require__(7839);\nconst TOP_LEVEL_OPS = new Set(\n  Array.from([\"$and\", \"$or\", \"$nor\", \"$expr\", \"$jsonSchema\"])\n);\nclass Query {\n  #compiled;\n  #options;\n  #condition;\n  constructor(condition, options) {\n    this.#condition = condition;\n    this.#options = (0, import_core.initOptions)(options);\n    this.#compiled = [];\n    this.compile();\n  }\n  compile() {\n    (0, import_util.assert)(\n      (0, import_util.isObject)(this.#condition),\n      `query criteria must be an object: ${JSON.stringify(this.#condition)}`\n    );\n    const whereOperator = {};\n    for (const [field, expr] of Object.entries(this.#condition)) {\n      if (\"$where\" === field) {\n        Object.assign(whereOperator, { field, expr });\n      } else if (TOP_LEVEL_OPS.has(field)) {\n        this.processOperator(field, field, expr);\n      } else {\n        (0, import_util.assert)(!(0, import_util.isOperator)(field), `unknown top level operator: ${field}`);\n        for (const [operator, val] of Object.entries(\n          (0, import_util.normalize)(expr)\n        )) {\n          this.processOperator(field, operator, val);\n        }\n      }\n      if (whereOperator.field) {\n        this.processOperator(\n          whereOperator.field,\n          whereOperator.field,\n          whereOperator.expr\n        );\n      }\n    }\n  }\n  processOperator(field, operator, value) {\n    const call = (0, import_core.getOperator)(\"query\", operator, this.#options);\n    if (!call) {\n      throw new import_util.MingoError(`unknown query operator ${operator}`);\n    }\n    const fn = call(field, value, this.#options);\n    this.#compiled.push(fn);\n  }\n  /**\n   * Checks if the object passes the query criteria. Returns true if so, false otherwise.\n   *\n   * @param obj The object to test\n   * @returns {boolean} True or false\n   */\n  test(obj) {\n    for (let i = 0, len = this.#compiled.length; i < len; i++) {\n      if (!this.#compiled[i](obj)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  /**\n   * Returns a cursor to select matching documents from the input source.\n   *\n   * @param source A source providing a sequence of documents\n   * @param projection An optional projection criteria\n   * @returns {Cursor} A Cursor for iterating over the results\n   */\n  find(collection, projection) {\n    return new import_cursor.Cursor(\n      collection,\n      (x) => this.test(x),\n      projection || {},\n      this.#options\n    );\n  }\n  /**\n   * Remove matched documents from the collection returning the remainder\n   *\n   * @param collection An array of documents\n   * @returns {Array} A new array with matching elements removed\n   */\n  remove(collection) {\n    return collection.reduce((acc, obj) => {\n      if (!this.test(obj)) acc.push(obj);\n      return acc;\n    }, []);\n  }\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 486:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar types_exports = {};\n__export(types_exports, {\n  TIME_UNITS: () => TIME_UNITS\n});\nmodule.exports = __toCommonJS(types_exports);\nconst TIME_UNITS = [\n  \"year\",\n  \"quarter\",\n  \"month\",\n  \"week\",\n  \"day\",\n  \"hour\",\n  \"minute\",\n  \"second\",\n  \"millisecond\"\n];\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 3550:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar updater_exports = {};\n__export(updater_exports, {\n  createUpdater: () => createUpdater,\n  update: () => update,\n  updateObject: () => updateObject\n});\nmodule.exports = __toCommonJS(updater_exports);\nvar import_core = __webpack_require__(2760);\nvar booleanOperators = __toESM(__webpack_require__(1703));\nvar comparisonOperators = __toESM(__webpack_require__(3336));\nvar queryOperators = __toESM(__webpack_require__(8510));\nvar UPDATE_OPERATORS = __toESM(__webpack_require__(2835));\nvar import_query = __webpack_require__(6535);\nvar import_util = __webpack_require__(7839);\nfunction createUpdater(defaultOptions) {\n  defaultOptions = defaultOptions || {};\n  defaultOptions = {\n    ...defaultOptions,\n    queryOptions: (0, import_core.initOptions)(defaultOptions.queryOptions)\n  };\n  defaultOptions.queryOptions.context.addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators);\n  return (obj, expr, arrayFilters = [], condition = {}, options = {}) => {\n    const opts = Object.assign({ cloneMode: \"copy\" }, defaultOptions, options);\n    Object.assign(opts, {\n      queryOptions: (0, import_core.initOptions)(\n        Object.assign({ useStrictMode: false }, opts?.queryOptions)\n      )\n    });\n    const entry = Object.entries(expr);\n    (0, import_util.assert)(\n      entry.length === 1,\n      \"Update expression must contain only one operator.\"\n    );\n    const [op, args] = entry[0];\n    (0, import_util.assert)(\n      (0, import_util.has)(UPDATE_OPERATORS, op),\n      `Update operator '${op}' is not supported.`\n    );\n    const mutate = UPDATE_OPERATORS[op];\n    if (Object.keys(condition).length) {\n      const q = condition instanceof import_query.Query ? condition : new import_query.Query(condition, opts.queryOptions);\n      if (!q.test(obj)) return [];\n    }\n    return mutate(obj, args, arrayFilters, opts);\n  };\n}\nconst update = createUpdater();\nconst updateObject = update;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7839:\n/***/ ((module) => {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\nvar util_exports = {};\n__export(util_exports, {\n  MingoError: () => MingoError,\n  ValueMap: () => ValueMap,\n  assert: () => assert,\n  cloneDeep: () => cloneDeep,\n  compare: () => compare,\n  ensureArray: () => ensureArray,\n  filterMissing: () => filterMissing,\n  findInsertIndex: () => findInsertIndex,\n  flatten: () => flatten,\n  groupBy: () => groupBy,\n  has: () => has,\n  hashCode: () => hashCode,\n  intersection: () => intersection,\n  into: () => into,\n  isArray: () => isArray,\n  isBoolean: () => isBoolean,\n  isDate: () => isDate,\n  isEmpty: () => isEmpty,\n  isEqual: () => isEqual,\n  isFunction: () => isFunction,\n  isNil: () => isNil,\n  isNotNaN: () => isNotNaN,\n  isNumber: () => isNumber,\n  isObject: () => isObject,\n  isObjectLike: () => isObjectLike,\n  isOperator: () => isOperator,\n  isRegExp: () => isRegExp,\n  isString: () => isString,\n  isSymbol: () => isSymbol,\n  merge: () => merge,\n  normalize: () => normalize,\n  removeValue: () => removeValue,\n  resolve: () => resolve,\n  resolveGraph: () => resolveGraph,\n  setValue: () => setValue,\n  stringify: () => stringify,\n  truthy: () => truthy,\n  typeOf: () => typeOf,\n  unique: () => unique,\n  walk: () => walk\n});\nmodule.exports = __toCommonJS(util_exports);\nclass MingoError extends Error {\n}\nconst MISSING = Symbol(\"missing\");\nconst CYCLE_FOUND_ERROR = Object.freeze(\n  new Error(\"mingo: cycle detected while processing object/array\")\n);\nconst DEFAULT_HASH_FUNCTION = (value) => {\n  const s = stringify(value);\n  let hash = 0;\n  let i = s.length;\n  while (i) hash = (hash << 5) - hash ^ s.charCodeAt(--i);\n  return hash >>> 0;\n};\nconst objectProto = Object.prototype;\nconst arrayProto = Array.prototype;\nconst getPrototypeOf = Object.getPrototypeOf;\nconst isPrimitive = (v) => typeof v !== \"object\" && typeof v !== \"function\" || v === null;\nconst isScalar = (v) => isPrimitive(v) || isDate(v) || isRegExp(v);\nconst SORT_ORDER = {\n  undefined: 1,\n  null: 2,\n  number: 3,\n  string: 4,\n  symbol: 5,\n  object: 6,\n  array: 7,\n  arraybuffer: 8,\n  boolean: 9,\n  date: 10,\n  regexp: 11,\n  function: 12\n};\nconst compare = (a, b) => {\n  if (a === MISSING) a = void 0;\n  if (b === MISSING) b = void 0;\n  const [u, v] = [a, b].map((n) => SORT_ORDER[typeOf(n)]);\n  if (u !== v) return u - v;\n  if (isEqual(a, b)) return 0;\n  if (a < b) return -1;\n  if (a > b) return 1;\n  return 0;\n};\nclass ValueMap extends Map {\n  // The hash function\n  #hashFn = DEFAULT_HASH_FUNCTION;\n  // maps the hashcode to key set\n  #keyMap = /* @__PURE__ */ new Map();\n  // returns a tuple of [<masterKey>, <hash>]. Expects an object key.\n  #unpack = (key) => {\n    const hash = this.#hashFn(key);\n    return [(this.#keyMap.get(hash) || []).find((k) => isEqual(k, key)), hash];\n  };\n  constructor() {\n    super();\n  }\n  /**\n   * Returns a new {@link ValueMap} object.\n   * @param fn An optional custom hash function\n   */\n  static init(fn) {\n    const m = new ValueMap();\n    if (fn) m.#hashFn = fn;\n    return m;\n  }\n  clear() {\n    super.clear();\n    this.#keyMap.clear();\n  }\n  /**\n   * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.\n   */\n  delete(key) {\n    if (isPrimitive(key)) return super.delete(key);\n    const [masterKey, hash] = this.#unpack(key);\n    if (!super.delete(masterKey)) return false;\n    this.#keyMap.set(\n      hash,\n      this.#keyMap.get(hash).filter((k) => !isEqual(k, masterKey))\n    );\n    return true;\n  }\n  /**\n   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.\n   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.\n   */\n  get(key) {\n    if (isPrimitive(key)) return super.get(key);\n    const [masterKey, _] = this.#unpack(key);\n    return super.get(masterKey);\n  }\n  /**\n   * @returns boolean indicating whether an element with the specified key exists or not.\n   */\n  has(key) {\n    if (isPrimitive(key)) return super.has(key);\n    const [masterKey, _] = this.#unpack(key);\n    return super.has(masterKey);\n  }\n  /**\n   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.\n   */\n  set(key, value) {\n    if (isPrimitive(key)) return super.set(key, value);\n    const [masterKey, hash] = this.#unpack(key);\n    if (super.has(masterKey)) {\n      super.set(masterKey, value);\n    } else {\n      super.set(key, value);\n      const keys = this.#keyMap.get(hash) || [];\n      keys.push(key);\n      this.#keyMap.set(hash, keys);\n    }\n    return this;\n  }\n  /**\n   * @returns the number of elements in the Map.\n   */\n  get size() {\n    return super.size;\n  }\n}\nfunction assert(condition, message) {\n  if (!condition) throw new MingoError(message);\n}\nconst typeOf = (v) => {\n  const s = objectProto.toString.call(v);\n  const t = s.substring(8, s.length - 1).toLowerCase();\n  if (t !== \"object\") return t;\n  const ctor = v.constructor;\n  return ctor == null || ctor === Object ? t : ctor.name;\n};\nconst isBoolean = (v) => typeof v === \"boolean\";\nconst isString = (v) => typeof v === \"string\";\nconst isSymbol = (v) => typeof v === \"symbol\";\nconst isNumber = (v) => !isNaN(v) && typeof v === \"number\";\nconst isNotNaN = (v) => !(isNaN(v) && typeof v === \"number\");\nconst isArray = Array.isArray;\nconst isObject = (v) => {\n  if (!v) return false;\n  const p = Object.getPrototypeOf(v);\n  return (p === Object.prototype || p === null) && typeOf(v) === \"object\";\n};\nconst isObjectLike = (v) => !isPrimitive(v);\nconst isDate = (v) => v instanceof Date;\nconst isRegExp = (v) => v instanceof RegExp;\nconst isFunction = (v) => typeof v === \"function\";\nconst isNil = (v) => v === null || v === void 0;\nconst truthy = (arg, strict = true) => !!arg || strict && arg === \"\";\nconst isEmpty = (x) => isNil(x) || isString(x) && !x || isArray(x) && x.length === 0 || isObject(x) && Object.keys(x).length === 0;\nconst ensureArray = (x) => isArray(x) ? x : [x];\nconst has = (obj, prop) => !!obj && objectProto.hasOwnProperty.call(obj, prop);\nconst isTypedArray = (v) => typeof ArrayBuffer !== \"undefined\" && ArrayBuffer.isView(v);\nconst cloneDeep = (v, refs) => {\n  if (isNil(v) || isBoolean(v) || isNumber(v) || isString(v)) return v;\n  if (isDate(v)) return new Date(v);\n  if (isRegExp(v)) return new RegExp(v);\n  if (isTypedArray(v)) {\n    const ctor = v.constructor;\n    return new ctor(v);\n  }\n  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();\n  if (refs.has(v)) throw CYCLE_FOUND_ERROR;\n  refs.add(v);\n  try {\n    if (isArray(v)) {\n      const arr = new Array(v.length);\n      for (let i = 0; i < v.length; i++) arr[i] = cloneDeep(v[i], refs);\n      return arr;\n    }\n    if (isObject(v)) {\n      const obj = {};\n      for (const k of Object.keys(v)) obj[k] = cloneDeep(v[k], refs);\n      return obj;\n    }\n  } finally {\n    refs.delete(v);\n  }\n  return v;\n};\nconst isMissing = (v) => v === MISSING;\nfunction merge(target, input) {\n  if (isMissing(target) || isNil(target)) return input;\n  if (isMissing(input) || isNil(input)) return target;\n  if (isPrimitive(target) || isPrimitive(input)) return input;\n  if (isArray(target) && isArray(input)) {\n    assert(\n      target.length === input.length,\n      \"arrays must be of equal length to merge.\"\n    );\n  }\n  for (const k in input) {\n    target[k] = merge(target[k], input[k]);\n  }\n  return target;\n}\nfunction intersection(input, hashFunction = DEFAULT_HASH_FUNCTION) {\n  const vmaps = [ValueMap.init(hashFunction), ValueMap.init(hashFunction)];\n  if (input.length === 0) return [];\n  if (input.some((arr) => arr.length === 0)) return [];\n  if (input.length === 1) return [...input];\n  input[input.length - 1].forEach((v) => vmaps[0].set(v, true));\n  for (let i = input.length - 2; i > -1; i--) {\n    input[i].forEach((v) => {\n      if (vmaps[0].has(v)) vmaps[1].set(v, true);\n    });\n    if (vmaps[1].size === 0) return [];\n    vmaps.reverse();\n    vmaps[1].clear();\n  }\n  return Array.from(vmaps[0].keys());\n}\nfunction flatten(xs, depth = 1) {\n  const arr = new Array();\n  function flatten2(ys, n) {\n    for (let i = 0, len = ys.length; i < len; i++) {\n      if (isArray(ys[i]) && (n > 0 || n < 0)) {\n        flatten2(ys[i], Math.max(-1, n - 1));\n      } else {\n        arr.push(ys[i]);\n      }\n    }\n  }\n  flatten2(xs, depth);\n  return arr;\n}\nfunction isEqual(a, b) {\n  if (a === b || Object.is(a, b)) return true;\n  const ctor = !!a && a.constructor || a;\n  if (a === null || b === null || a === void 0 || b === void 0 || ctor !== b.constructor || ctor === Function) {\n    return false;\n  }\n  if (ctor === Array || ctor === Object) {\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    if (aKeys.length !== bKeys.length) return false;\n    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length) return false;\n    for (const k of aKeys) if (!isEqual(a[k], b[k])) return false;\n    return true;\n  }\n  const proto = getPrototypeOf(a);\n  const cmp = isTypedArray(a) || proto !== objectProto && proto !== arrayProto && has(proto, \"toString\");\n  return cmp && a.toString() === b.toString();\n}\nfunction unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {\n  const m = ValueMap.init(hashFunction);\n  input.forEach((v) => m.set(v, true));\n  return Array.from(m.keys());\n}\nconst stringify = (v, refs) => {\n  if (v === null) return \"null\";\n  if (v === void 0) return \"undefined\";\n  if (isString(v) || isNumber(v) || isBoolean(v)) return JSON.stringify(v);\n  if (isDate(v)) return v.toISOString();\n  if (isRegExp(v) || isSymbol(v) || isFunction(v))\n    return v.toString();\n  if (isTypedArray(v))\n    return typeOf(v) + \"[\" + v.toString() + \"]\";\n  if (!(refs instanceof Set)) refs = /* @__PURE__ */ new Set();\n  if (refs.has(v)) throw CYCLE_FOUND_ERROR;\n  try {\n    refs.add(v);\n    if (isArray(v)) return \"[\" + v.map((s) => stringify(s, refs)).join(\",\") + \"]\";\n    if (isObject(v)) {\n      const keys = Object.keys(v).sort();\n      return \"{\" + keys.map((k) => `${k}:${stringify(v[k], refs)}`).join() + \"}\";\n    }\n    const proto = Object.getPrototypeOf(v);\n    if (proto !== objectProto && proto !== arrayProto && has(proto, \"toString\")) {\n      return typeOf(v) + \"(\" + JSON.stringify(v.toString()) + \")\";\n    }\n    throw new Error(\n      \"mingo: cannot stringify custom type without explicit toString() method.\"\n    );\n  } finally {\n    refs.delete(v);\n  }\n};\nfunction hashCode(value, hashFunction) {\n  if (isNil(value)) return null;\n  hashFunction = hashFunction || DEFAULT_HASH_FUNCTION;\n  return hashFunction(value);\n}\nfunction groupBy(collection, keyFn, hashFunction = DEFAULT_HASH_FUNCTION) {\n  if (collection.length < 1) return /* @__PURE__ */ new Map();\n  const lookup = /* @__PURE__ */ new Map();\n  const result = /* @__PURE__ */ new Map();\n  for (let i = 0; i < collection.length; i++) {\n    const obj = collection[i];\n    const key = keyFn(obj, i);\n    const hash = hashCode(key, hashFunction);\n    if (hash === null) {\n      if (result.has(null)) {\n        result.get(null).push(obj);\n      } else {\n        result.set(null, [obj]);\n      }\n    } else {\n      const existingKey = lookup.has(hash) ? lookup.get(hash).find((k) => isEqual(k, key)) : null;\n      if (isNil(existingKey)) {\n        result.set(key, [obj]);\n        if (lookup.has(hash)) {\n          lookup.get(hash).push(key);\n        } else {\n          lookup.set(hash, [key]);\n        }\n      } else {\n        result.get(existingKey).push(obj);\n      }\n    }\n  }\n  return result;\n}\nconst MAX_ARRAY_PUSH = 5e4;\nfunction into(target, ...rest) {\n  if (isArray(target)) {\n    for (const arr of rest) {\n      let i = Math.ceil(arr.length / MAX_ARRAY_PUSH);\n      let begin = 0;\n      while (i-- > 0) {\n        Array.prototype.push.apply(\n          target,\n          arr.slice(begin, begin + MAX_ARRAY_PUSH)\n        );\n        begin += MAX_ARRAY_PUSH;\n      }\n    }\n    return target;\n  } else {\n    return rest.filter(isObjectLike).reduce((acc, item) => {\n      Object.assign(acc, item);\n      return acc;\n    }, target);\n  }\n}\nfunction getValue(obj, key) {\n  return isArray(obj) || isObject(obj) ? obj[key] : void 0;\n}\nfunction unwrap(arr, depth) {\n  if (depth < 1) return arr;\n  while (depth-- && arr.length === 1) arr = arr[0];\n  return arr;\n}\nfunction resolve(obj, selector, options) {\n  let depth = 0;\n  function resolve2(o, path) {\n    let value = o;\n    for (let i = 0; i < path.length; i++) {\n      const field = path[i];\n      const isText = /^\\d+$/.exec(field) === null;\n      if (isText && isArray(value)) {\n        if (i === 0 && depth > 0) break;\n        depth += 1;\n        const subpath = path.slice(i);\n        value = value.reduce((acc, item) => {\n          const v = resolve2(item, subpath);\n          if (v !== void 0) acc.push(v);\n          return acc;\n        }, []);\n        break;\n      } else {\n        value = getValue(value, field);\n      }\n      if (value === void 0) break;\n    }\n    return value;\n  }\n  const res = isScalar(obj) ? obj : resolve2(obj, selector.split(\".\"));\n  return isArray(res) && options?.unwrapArray ? unwrap(res, depth) : res;\n}\nfunction resolveGraph(obj, selector, options) {\n  const sep = selector.indexOf(\".\");\n  const key = sep == -1 ? selector : selector.substring(0, sep);\n  const next = selector.substring(sep + 1);\n  const hasNext = sep != -1;\n  if (isArray(obj)) {\n    const isIndex = /^\\d+$/.test(key);\n    const arr = isIndex && options?.preserveIndex ? [...obj] : [];\n    if (isIndex) {\n      const index = parseInt(key);\n      let value2 = getValue(obj, index);\n      if (hasNext) {\n        value2 = resolveGraph(value2, next, options);\n      }\n      if (options?.preserveIndex) {\n        arr[index] = value2;\n      } else {\n        arr.push(value2);\n      }\n    } else {\n      for (const item of obj) {\n        const value2 = resolveGraph(item, selector, options);\n        if (options?.preserveMissing) {\n          arr.push(value2 == void 0 ? MISSING : value2);\n        } else if (value2 != void 0 || options?.preserveIndex) {\n          arr.push(value2);\n        }\n      }\n    }\n    return arr;\n  }\n  const res = options?.preserveKeys ? { ...obj } : {};\n  let value = getValue(obj, key);\n  if (hasNext) {\n    value = resolveGraph(value, next, options);\n  }\n  if (value === void 0) return void 0;\n  res[key] = value;\n  return res;\n}\nfunction filterMissing(obj) {\n  if (isArray(obj)) {\n    for (let i = obj.length - 1; i >= 0; i--) {\n      if (obj[i] === MISSING) {\n        obj.splice(i, 1);\n      } else {\n        filterMissing(obj[i]);\n      }\n    }\n  } else if (isObject(obj)) {\n    for (const k in obj) {\n      if (has(obj, k)) {\n        filterMissing(obj[k]);\n      }\n    }\n  }\n}\nconst NUMBER_RE = /^\\d+$/;\nfunction walk(obj, selector, fn, options) {\n  const names = selector.split(\".\");\n  const key = names[0];\n  const next = names.slice(1).join(\".\");\n  if (names.length === 1) {\n    if (isObject(obj) || isArray(obj) && NUMBER_RE.test(key)) {\n      fn(obj, key);\n    }\n  } else {\n    if (options?.buildGraph && isNil(obj[key])) {\n      obj[key] = {};\n    }\n    const item = obj[key];\n    if (!item) return;\n    const isNextArrayIndex = !!(names.length > 1 && NUMBER_RE.test(names[1]));\n    if (isArray(item) && options?.descendArray && !isNextArrayIndex) {\n      item.forEach((e) => walk(e, next, fn, options));\n    } else {\n      walk(item, next, fn, options);\n    }\n  }\n}\nfunction setValue(obj, selector, value) {\n  walk(\n    obj,\n    selector,\n    (item, key) => {\n      item[key] = isFunction(value) ? value(item[key]) : value;\n    },\n    { buildGraph: true }\n  );\n}\nfunction removeValue(obj, selector, options) {\n  walk(\n    obj,\n    selector,\n    (item, key) => {\n      if (isArray(item)) {\n        if (/^\\d+$/.test(key)) {\n          item.splice(parseInt(key), 1);\n        } else if (options && options.descendArray) {\n          for (const elem of item) {\n            if (isObject(elem)) {\n              delete elem[key];\n            }\n          }\n        }\n      } else if (isObject(item)) {\n        delete item[key];\n      }\n    },\n    options\n  );\n}\nconst OPERATOR_NAME_PATTERN = /^\\$[a-zA-Z0-9_]+$/;\nfunction isOperator(name) {\n  return OPERATOR_NAME_PATTERN.test(name);\n}\nfunction normalize(expr) {\n  if (isScalar(expr)) {\n    return isRegExp(expr) ? { $regex: expr } : { $eq: expr };\n  }\n  if (isObjectLike(expr)) {\n    if (!Object.keys(expr).some(isOperator)) return { $eq: expr };\n    if (has(expr, \"$regex\")) {\n      const newExpr = { ...expr };\n      newExpr[\"$regex\"] = new RegExp(\n        expr[\"$regex\"],\n        expr[\"$options\"]\n      );\n      delete newExpr[\"$options\"];\n      return newExpr;\n    }\n  }\n  return expr;\n}\nfunction findInsertIndex(sorted, item, comparator = compare) {\n  let lo = 0;\n  let hi = sorted.length - 1;\n  while (lo <= hi) {\n    const mid = Math.round(lo + (hi - lo) / 2);\n    if (comparator(item, sorted[mid]) < 0) {\n      hi = mid - 1;\n    } else if (comparator(item, sorted[mid]) > 0) {\n      lo = mid + 1;\n    } else {\n      return mid;\n    }\n  }\n  return lo;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (0);\n\n\n/***/ }),\n\n/***/ 7444:\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   decode: () => (/* binding */ decode),\n/* harmony export */   \"default\": () => (__WEBPACK_DEFAULT_EXPORT__),\n/* harmony export */   encode: () => (/* binding */ encode),\n/* harmony export */   toASCII: () => (/* binding */ toASCII),\n/* harmony export */   toUnicode: () => (/* binding */ toUnicode),\n/* harmony export */   ucs2decode: () => (/* binding */ ucs2decode),\n/* harmony export */   ucs2encode: () => (/* binding */ ucs2encode)\n/* harmony export */ });\n\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7F]/; // Note: U+007F DEL is excluded too.\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, callback) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = callback(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {String} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(domain, callback) {\n\tconst parts = domain.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tdomain = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tdomain = domain.replace(regexSeparators, '\\x2E');\n\tconst labels = domain.split('.');\n\tconst encoded = map(labels, callback).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = codePoints => String.fromCodePoint(...codePoints);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint >= 0x30 && codePoint < 0x3A) {\n\t\treturn 26 + (codePoint - 0x30);\n\t}\n\tif (codePoint >= 0x41 && codePoint < 0x5B) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint >= 0x61 && codePoint < 0x7B) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tconst oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\t\t\tif (digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tconst inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tconst basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue === n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.3.1',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\n\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (punycode);\n\n\n/***/ }),\n\n/***/ 3492:\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\n\n\nvar regex$5 = /[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\n\nvar regex$4 = /[\\0-\\x1F\\x7F-\\x9F]/;\n\nvar regex$3 = /[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u0890\\u0891\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD80D[\\uDC30-\\uDC3F]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/;\n\nvar regex$2 = /[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDEAD\\uDF55-\\uDF59\\uDF86-\\uDF89]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9]|\\uD805[\\uDC4B-\\uDC4F\\uDC5A\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDEB9\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDD44-\\uDD46\\uDDE2\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2\\uDF00-\\uDF09]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8\\uDF43-\\uDF4F\\uDFFF]|\\uD809[\\uDC70-\\uDC74]|\\uD80B[\\uDFF1\\uDFF2]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDE97-\\uDE9A\\uDFE2]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD83A[\\uDD5E\\uDD5F]/;\n\nvar regex$1 = /[\\$\\+<->\\^`\\|~\\xA2-\\xA6\\xA8\\xA9\\xAC\\xAE-\\xB1\\xB4\\xB8\\xD7\\xF7\\u02C2-\\u02C5\\u02D2-\\u02DF\\u02E5-\\u02EB\\u02ED\\u02EF-\\u02FF\\u0375\\u0384\\u0385\\u03F6\\u0482\\u058D-\\u058F\\u0606-\\u0608\\u060B\\u060E\\u060F\\u06DE\\u06E9\\u06FD\\u06FE\\u07F6\\u07FE\\u07FF\\u0888\\u09F2\\u09F3\\u09FA\\u09FB\\u0AF1\\u0B70\\u0BF3-\\u0BFA\\u0C7F\\u0D4F\\u0D79\\u0E3F\\u0F01-\\u0F03\\u0F13\\u0F15-\\u0F17\\u0F1A-\\u0F1F\\u0F34\\u0F36\\u0F38\\u0FBE-\\u0FC5\\u0FC7-\\u0FCC\\u0FCE\\u0FCF\\u0FD5-\\u0FD8\\u109E\\u109F\\u1390-\\u1399\\u166D\\u17DB\\u1940\\u19DE-\\u19FF\\u1B61-\\u1B6A\\u1B74-\\u1B7C\\u1FBD\\u1FBF-\\u1FC1\\u1FCD-\\u1FCF\\u1FDD-\\u1FDF\\u1FED-\\u1FEF\\u1FFD\\u1FFE\\u2044\\u2052\\u207A-\\u207C\\u208A-\\u208C\\u20A0-\\u20C0\\u2100\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211E-\\u2123\\u2125\\u2127\\u2129\\u212E\\u213A\\u213B\\u2140-\\u2144\\u214A-\\u214D\\u214F\\u218A\\u218B\\u2190-\\u2307\\u230C-\\u2328\\u232B-\\u2426\\u2440-\\u244A\\u249C-\\u24E9\\u2500-\\u2767\\u2794-\\u27C4\\u27C7-\\u27E5\\u27F0-\\u2982\\u2999-\\u29D7\\u29DC-\\u29FB\\u29FE-\\u2B73\\u2B76-\\u2B95\\u2B97-\\u2BFF\\u2CE5-\\u2CEA\\u2E50\\u2E51\\u2E80-\\u2E99\\u2E9B-\\u2EF3\\u2F00-\\u2FD5\\u2FF0-\\u2FFF\\u3004\\u3012\\u3013\\u3020\\u3036\\u3037\\u303E\\u303F\\u309B\\u309C\\u3190\\u3191\\u3196-\\u319F\\u31C0-\\u31E3\\u31EF\\u3200-\\u321E\\u322A-\\u3247\\u3250\\u3260-\\u327F\\u328A-\\u32B0\\u32C0-\\u33FF\\u4DC0-\\u4DFF\\uA490-\\uA4C6\\uA700-\\uA716\\uA720\\uA721\\uA789\\uA78A\\uA828-\\uA82B\\uA836-\\uA839\\uAA77-\\uAA79\\uAB5B\\uAB6A\\uAB6B\\uFB29\\uFBB2-\\uFBC2\\uFD40-\\uFD4F\\uFDCF\\uFDFC-\\uFDFF\\uFE62\\uFE64-\\uFE66\\uFE69\\uFF04\\uFF0B\\uFF1C-\\uFF1E\\uFF3E\\uFF40\\uFF5C\\uFF5E\\uFFE0-\\uFFE6\\uFFE8-\\uFFEE\\uFFFC\\uFFFD]|\\uD800[\\uDD37-\\uDD3F\\uDD79-\\uDD89\\uDD8C-\\uDD8E\\uDD90-\\uDD9C\\uDDA0\\uDDD0-\\uDDFC]|\\uD802[\\uDC77\\uDC78\\uDEC8]|\\uD805\\uDF3F|\\uD807[\\uDFD5-\\uDFF1]|\\uD81A[\\uDF3C-\\uDF3F\\uDF45]|\\uD82F\\uDC9C|\\uD833[\\uDF50-\\uDFC3]|\\uD834[\\uDC00-\\uDCF5\\uDD00-\\uDD26\\uDD29-\\uDD64\\uDD6A-\\uDD6C\\uDD83\\uDD84\\uDD8C-\\uDDA9\\uDDAE-\\uDDEA\\uDE00-\\uDE41\\uDE45\\uDF00-\\uDF56]|\\uD835[\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3]|\\uD836[\\uDC00-\\uDDFF\\uDE37-\\uDE3A\\uDE6D-\\uDE74\\uDE76-\\uDE83\\uDE85\\uDE86]|\\uD838[\\uDD4F\\uDEFF]|\\uD83B[\\uDCAC\\uDCB0\\uDD2E\\uDEF0\\uDEF1]|\\uD83C[\\uDC00-\\uDC2B\\uDC30-\\uDC93\\uDCA0-\\uDCAE\\uDCB1-\\uDCBF\\uDCC1-\\uDCCF\\uDCD1-\\uDCF5\\uDD0D-\\uDDAD\\uDDE6-\\uDE02\\uDE10-\\uDE3B\\uDE40-\\uDE48\\uDE50\\uDE51\\uDE60-\\uDE65\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDED7\\uDEDC-\\uDEEC\\uDEF0-\\uDEFC\\uDF00-\\uDF76\\uDF7B-\\uDFD9\\uDFE0-\\uDFEB\\uDFF0]|\\uD83E[\\uDC00-\\uDC0B\\uDC10-\\uDC47\\uDC50-\\uDC59\\uDC60-\\uDC87\\uDC90-\\uDCAD\\uDCB0\\uDCB1\\uDD00-\\uDE53\\uDE60-\\uDE6D\\uDE70-\\uDE7C\\uDE80-\\uDE88\\uDE90-\\uDEBD\\uDEBF-\\uDEC5\\uDECE-\\uDEDB\\uDEE0-\\uDEE8\\uDEF0-\\uDEF8\\uDF00-\\uDF92\\uDF94-\\uDFCA]/;\n\nvar regex = /[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/;\n\nexports.Any = regex$5;\nexports.Cc = regex$4;\nexports.Cf = regex$3;\nexports.P = regex$2;\nexports.S = regex$1;\nexports.Z = regex;\n\n\n/***/ }),\n\n/***/ 2008:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst State = __webpack_require__(9421);\n\n/**\n * @namespace History\n * @property {Array}    history   Array of passages and previous state.\n * @property {number}   position  Current position in the array.\n */\n\nclass History {\n  static history = [];\n  static position = 0;\n  /**\n   * Add a passage name to the history array.\n   * @function add\n   * @param {string} name - Name of the passage to add.\n   */\n  static add (name) {\n    // Append to the end\n    this.history.push({\n      passageName: name,\n      state: Object.assign({}, State.store)\n    });\n\n    // Reset the position to entry at the end.\n    this.position = this.history.length - 1;\n  }\n\n  /**\n   * Step back one index in the history array.\n   * @function undo\n   * @returns {string | null} Name of now current passage; null if undo not possible.\n   */\n  static undo () {\n    let result = null;\n\n    if (this.position >= 1 && this.history.length >= 1) {\n      // Decrease position\n      this.position -= 1;\n      // Find state.\n      const state = this.history[this.position].state;\n      // Have State update itself.\n      State.updateState(state);\n      // Return current passage name\n      result = this.history[this.position].passageName;\n    }\n\n    return result;\n  }\n\n  /**\n   * Step forward in history array, if possible.\n   * @function Redo\n   * @returns {string | null} Name of now current passage; null if redo not possible.\n   */\n  static redo () {\n    let result = null;\n\n    if (this.position >= 0 && this.position < this.history.length - 1) {\n      // Increase position\n      this.position += 1;\n      // Find state.\n      const state = this.history[this.position].state;\n      // Have State update itself.\n      State.updateState(state);\n      // Return current passage name\n      result = this.history[this.position].passageName;\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns true if the named passage exists within the history array.\n   * @function hasVisited\n   * @param {string | Array} passageName - Name(s) of passage to check.\n   * @returns {boolean} True if passage(s) in history; false otherwise.\n   */\n  static hasVisited (passageName = null) {\n    let result = false;\n\n    if (Array.isArray(passageName)) {\n      result = passageName.every((passageName) => {\n        return this.history.some(entry => {\n          return entry.passageName === passageName;\n        });\n      });\n    } else {\n      result = this.history.some((p) => {\n        return p.passageName === passageName;\n      });\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns number of visits for a single passage.\n   * @function visited\n   * @param   {string} passageName  Passage name to check.\n   * @returns {number}              Number of visits to passage.\n   */\n  static visited (passageName) {\n    let searchResults = [];\n    searchResults = this.history.filter(entry => entry.passageName === passageName);\n    return searchResults.length;\n  }\n\n  /**\n   * Resets History values to defaults.\n   * @function reset\n   */\n  static reset () {\n    this.history = [];\n    this.position = 0;\n  }\n}\n\nmodule.exports = History;\n\n\n/***/ }),\n\n/***/ 3199:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst md = __webpack_require__(383)({\n  html: true, // Enable HTML tags in source\n  xhtmlOut: true, // Use '/' to close single tags (<br />).\n  breaks: true // Convert \\n into <br />\n});\n\nclass Markdown {\n  static parse (text) {\n    const rules = [\n      // [[rename|destination][onclick]]\n      [/\\[\\[(.*?)\\|(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p2}\">${p1}</tw-link>`],\n      // [[rename|destination]]\n      // [/\\[\\[(.*?)\\|(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$2\">$1</tw-link>'],\n      // [[rename->dest][onclick]]\n      [/\\[\\[(.*?)->(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p2}\">${p1}</tw-link>`],\n      // [[rename->dest]]\n      // [/\\[\\[(.*?)->(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$2\">$1</tw-link>'],\n      // [[dest<-rename][onclick]]\n      [/\\[\\[(.*?)<-(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2, p3 = '') => `<tw-link role=\"link\" onclick=\"${p3.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p1}\">${p2}</tw-link>`],\n      // [[dest<-rename]]\n      // [/\\[\\[(.*?)<-(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$1\">$2</tw-link>'],\n      // [[destination][onclick]]\n      [/\\[\\[(.*?)\\](?:\\[(.*?)\\])?\\]/g, (m, p1, p2 = '') => `<tw-link role=\"link\" onclick=\"${p2.replaceAll('s.', 'window.Story.state.')}\" data-passage=\"${p1}\">${p1}</tw-link>`]\n      // [[destination]]\n      // [/\\[\\[(.*?)\\]\\]/g, '<tw-link role=\"link\" data-passage=\"$1\">$1</tw-link>']\n    ];\n\n    rules.forEach(([rule, template]) => {\n      text = text.replaceAll(rule, template);\n    });\n\n    return text;\n  }\n\n  static convert (text) {\n    return md.render(text);\n  }\n\n  static unescape (text) {\n    const unescapeSequences = [\n      ['&amp;', '&'],\n      ['&lt;', '<'],\n      ['&gt;', '>'],\n      ['&quot;', '\"'],\n      ['&#x27;', \"'\"],\n      ['&#x60;', '`']\n    ];\n\n    unescapeSequences.forEach(([rule, template]) => {\n      text = text.replaceAll(rule, template);\n    });\n\n    return text;\n  }\n}\n\nmodule.exports = Markdown;\n\n\n/***/ }),\n\n/***/ 3204:\n/***/ ((module) => {\n\n/**\n * An object representing a passage. The current passage will be `window.passage`.\n * @class Passage\n */\n\nclass Passage {\n  constructor (name = 'Default', tags = [], source = '') {\n    /**\n     * @property {string} name - The name of passage\n     * @type {string}\n     */\n\n    this.name = name;\n\n    /**\n     * @property {Array} tags - The tags of the passage.\n     * @type {Array}\n     */\n\n    this.tags = tags;\n\n    /**\n     * @property {string} source - The passage source code.\n     * @type {string}\n     */\n\n    this.source = source;\n  }\n}\n\nmodule.exports = Passage;\n\n\n/***/ }),\n\n/***/ 9990:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(4692);\n\nclass Screen {\n  /**\n   * Trigger screen-lock event.\n   * @function lock\n   */\n  static lock () {\n    // Append an element filling screen with CSS loading spinner.\n    $(document.body).append('<tw-screenlock><div class=\"loading\"></div></tw-screenlock>');\n  }\n\n  /**\n   * Trigger screen-unlock event.\n   * @function unlock\n   */\n  static unlock () {\n    // Remove tw-screenlock element, if there is one.\n    $('tw-screenlock').remove();\n  }\n}\n\nmodule.exports = Screen;\n\n\n/***/ }),\n\n/***/ 5465:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst ejs = __webpack_require__(4155);\nconst History = __webpack_require__(2008);\nconst Screen = __webpack_require__(9990);\nconst Utilities = __webpack_require__(5072);\n\n/**\n * @external Story\n * @see {@link Story}\n */\n\nclass Script {\n  /**\n   * Render JavaScript within a templated sandbox and return possible output.\n   * Will throw error if code does.\n   * @function run\n   * @param {string} script - Code to run.\n   * @param {Story} story - Current story object.\n   * @returns {string} Any output, if produced.\n   */\n  static run (script, story) {\n    let result = '';\n\n    try {\n      // Send in pseudo-global properties.\n      result = ejs.render(script,\n        {\n          s: story.store,\n          Storage: story.storage,\n          Storylets: story.storylets,\n          History: {\n            hasVisited: History.hasVisited.bind(History),\n            visited: History.visited.bind(History),\n            length: History.history.length\n          },\n          Screen: {\n            lock: Screen.lock.bind(),\n            unlock: Screen.unlock.bind()\n          },\n          Sidebar: {\n            hide: story.sidebar.hide.bind(),\n            show: story.sidebar.show.bind()\n          },\n          Utils: {\n            delay: Utilities.delay.bind(),\n            either: Utilities.either.bind(),\n            applyExternalStyles: Utilities.applyExternalStyles.bind(),\n            randomInt: Utilities.randomInt.bind()\n          }\n        },\n        {\n          outputFunctionName: 'print'\n        }\n      );\n    } catch (e) {\n      // Throw error if rendering fails.\n      throw new Error(`Error compiling template code: ${e}`);\n    }\n\n    return result;\n  }\n}\n\nmodule.exports = Script;\n\n\n/***/ }),\n\n/***/ 7936:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(4692);\nconst State = __webpack_require__(9421);\n\nclass Sidebar {\n  constructor () {\n    /**\n     * Reference to undo icon.\n     * @property {Element} undoIcon - Undo element.\n     * @type {Element}\n     */\n    this.undoIcon = $('tw-icon[title=\"Undo\"]');\n\n    /**\n     * Reference to redo icon.\n     * @property {Element} redoIcon - Redo element.\n     * @type {Element}\n     */\n    this.redoIcon = $('tw-icon[title=\"Redo\"]');\n\n    // Listen for user click interactions.\n    this.undoIcon.on('click', () => {\n      // If undo is ever used, redo becomes available.\n      this.showRedo();\n      // Emit 'undo'\n      State.events.emit('undo');\n    });\n\n    // Listen for user click interactions.\n    this.redoIcon.on('click', () => {\n      State.events.emit('redo');\n    });\n\n    // Start with undo hidden.\n    this.hideUndo();\n\n    // Start with redo hidden.\n    this.hideRedo();\n  }\n\n  /**\n   * Show undo icon.\n   * @function showUndo\n   */\n  showUndo () {\n    this.undoIcon.css('visibility', 'visible');\n  }\n\n  /**\n   * Hide undo icon.\n   * @function hideUndo\n   */\n  hideUndo () {\n    this.undoIcon.css('visibility', 'hidden');\n  }\n\n  /**\n   * Show redo icon.\n   * @function showRedo\n   */\n  showRedo () {\n    this.redoIcon.css('visibility', 'visible');\n  }\n\n  /**\n   * Hide redo icon.\n   * @function hideRedo\n   */\n  hideRedo () {\n    this.redoIcon.css('visibility', 'hidden');\n  }\n\n  /**\n   * Trigger undo event.\n   * @function undo\n   */\n  undo () {\n    State.events.emit('undo');\n  }\n\n  /**\n   * Trigger redo event.\n   * @function redo\n   */\n  redo () {\n    State.events.emit('redo');\n  }\n\n  /**\n   * Shows sidebar.\n   * @function show\n   */\n  show () {\n    // Show tw-sidebar.\n    $('tw-sidebar').css('visibility', 'visible');\n  }\n\n  /**\n   * Hides sidebar.\n   * @function hide\n   */\n  hide () {\n    // Hide tw-sidebar.\n    $('tw-sidebar').css('visibility', 'hidden');\n  }\n}\n\nmodule.exports = Sidebar;\n\n\n/***/ }),\n\n/***/ 9421:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst EventEmitter = __webpack_require__(7007);\n\nconst handler = {\n  get: (target, property) => {\n    return target[property];\n  },\n  set: (target, property, value) => {\n    // Make change.\n    target[property] = value;\n    // Emit change.\n    State.events.emit('change', property, value);\n    // Return true.\n    return true;\n  },\n  ownKeys (target) {\n    return Object.keys(target);\n  },\n  has (target, prop) {\n    return prop in target;\n  },\n  deleteProperty (target, prop) {\n    // Set default.\n    let result = false;\n\n    // Test for inclusion as property.\n    if (prop in target) {\n      // Emit deletion event.\n      State.events.emit('deletion', prop);\n      // Delete via Reflection.\n      result = Reflect.deleteProperty(target, prop);\n    }\n\n    // Return default or reflection result.\n    return result;\n  }\n};\n\n/**\n * @class State\n */\nclass State {\n  static events = new EventEmitter();\n  static store = new Proxy({}, handler);\n  /**\n   * Update current state properties to previous state values.\n   * @param {object} state - Object containing state properties.\n   */\n  static updateState (state) {\n    for (const property in state) {\n      this.store[property] = state[property];\n    }\n  }\n\n  /**\n   * Resets State properties to default values.\n   */\n  static reset () {\n    this.events = new EventEmitter();\n    this.store = new Proxy({}, handler);\n  }\n}\n\nmodule.exports = State;\n\n\n/***/ }),\n\n/***/ 3325:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst History = __webpack_require__(2008);\nconst State = __webpack_require__(9421);\n\nclass Storage {\n  /**\n   * Remove save by name from the localStorage.\n   * @function removeSave\n   * @param {string} save Name of save string.\n   * @returns {boolean} True if remove was successful.\n   */\n  static removeSave (save = 'default') {\n    let result = false;\n\n    if (Storage.available()) {\n      window.localStorage.removeItem(`${save}.snowman.history`);\n      result = true;\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns if save string exists in localStorage\n   * @function doesSaveExist\n   * @param {string} save Name of save string\n   * @returns {boolean} True if save string exists\n   */\n  static doesSaveExist (save = 'default') {\n    let history = null;\n\n    if (Storage.available()) {\n      history = window.localStorage.getItem(`${save}.snowman.history`);\n    }\n\n    return (history !== null);\n  }\n\n  /**\n   * Save history using optional string prefix\n   * @function createSave\n   * @param {string} save Optional name of save string\n   * @returns {boolean} Returns true if save was successful\n   */\n  static createSave (save = 'default') {\n    let result = false;\n\n    if (Storage.available()) {\n      window.localStorage.setItem(`${save}.snowman.history`, JSON.stringify(History.history));\n      result = true;\n    }\n\n    return result;\n  }\n\n  /**\n   * Attempts to restore the history and store based on optional save name\n   * @function restoreSave\n   * @param {string} save Optional name of save string\n   * @returns {boolean} Returns true if restore was successful\n   */\n  static restoreSave (save = 'default') {\n    let history = null;\n    let result = false;\n\n    if (Storage.available()) {\n      history = window.localStorage.getItem(`${save}.snowman.history`);\n      result = true;\n    }\n\n    if (history !== null) {\n      // Restore history\n      History.history = JSON.parse(history);\n      // Find current state.\n      const state = History.history[History.position].state;\n      // Have State update itself.\n      State.updateState(state);\n    }\n\n    return result;\n  }\n\n  /**\n   * Returns if localStorage is available or not in browser context.\n   * @function available\n   * @returns {boolean} Returns true if localStorage can be used.\n   */\n  static available () {\n    // Set default value to false.\n    let result = false;\n\n    try {\n      window.localStorage.setItem('testKey', 'test');\n      window.localStorage.removeItem('testKey');\n      result = true;\n    } catch(error) {\n      console.info('Info: localStorage is not available. Error:', error);\n    }\n\n    // Return result\n    return result;\n  }\n\n  /**\n   * Clears localStorage, if available.\n   * @function removeAll\n   * @returns {boolean} Returns true if removal was possible.\n   */\n  static removeAll () {\n    // Set default value to false.\n    let result = false;\n    // Is localStorage available?\n    if (Storage.available()) {\n      // Clear the localStorage\n      window.localStorage.clear();\n      // Record result\n      result = true;\n    }\n    // Return result\n    return result;\n  }\n}\n\nmodule.exports = Storage;\n\n\n/***/ }),\n\n/***/ 2577:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n/**\n * @external Element\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Element}\n */\nconst $ = __webpack_require__(4692);\nconst Passage = __webpack_require__(3204);\nconst Markdown = __webpack_require__(3199);\nconst State = __webpack_require__(9421);\nconst History = __webpack_require__(2008);\nconst Storylets = __webpack_require__(9715);\nconst Script = __webpack_require__(5465);\nconst Sidebar = __webpack_require__(7936);\nconst Screen = __webpack_require__(9990);\nconst Storage = __webpack_require__(3325);\n\n/**\n * An object representing the entire story. After the document has completed\n * loading, an instance of this class will be available at `window.Story`.\n * @class Story\n */\nclass Story {\n  constructor () {\n    /**\n     * @property {string} name - The name of the story.\n     * @type {string}\n     * @readonly\n     */\n    this.name = $('tw-storydata').attr('name');\n\n    /**\n     * An array of all passages.\n     * @property {Array} passages - Passages array.\n     * @type {Array}\n     */\n    this.passages = [];\n\n    // For each child element of the `<tw-storydata>` element,\n    //  create a new Passage object based on its attributes.\n    $('tw-storydata').children('tw-passagedata').each((index, element) => {\n      // Convert Element into jQuery Element.\n      const elementReference = $(element);\n      // Access any potential tags.\n      let tags = elementReference.attr('tags');\n\n      // Does the 'tags' attribute exist?\n      if (tags !== '' && tags !== undefined) {\n        // Attempt to split by space.\n        tags = tags.split(' ');\n      } else {\n        // It did not exist, so we create it as an empty array.\n        tags = [];\n      }\n\n      // Push the new passage.\n      this.passages.push(new Passage(\n        elementReference.attr('name'),\n        tags,\n        Markdown.unescape(elementReference.html())\n      ));\n    });\n\n    /**\n     * Passage element.\n     * @property {Element} passageElement Passage element.\n     * @type {Element}\n     */\n    this.passageElement = $('tw-passage');\n\n    /**\n     * Sidebar.\n     * @property {Element} sidebar Sidebar instance.\n     * @type {Element}\n     */\n    this.sidebar = new Sidebar();\n\n    // Reset History.\n    History.reset();\n\n    /**\n     * History reference.\n     * @property {History} history Reference to History.\n     * @type {History}\n     */\n    this.history = History;\n\n    /**\n     * Screen reference.\n     * @property {Screen} screen Reference to Screen.\n     * @type {Screen}\n     */\n    this.screen = Screen;\n\n    /**\n     * Storage reference.\n     * @property {Storage} screen Reference to Storage.\n     * @type {Storage}\n     */\n    this.storage = Storage;\n\n    // Reset State.\n    State.reset();\n\n    /**\n     * State.events reference.\n     * @property {EventEmitter} events Reference to State.events.\n     * @type {EventEmitter}\n     */\n    this.events = State.events;\n\n    /**\n     * State.store reference.\n     * @property {Proxy} store Reference to State.store.\n     * @type {Proxy}\n     */\n    this.store = State.store;\n\n    // Listen for redo events.\n    State.events.on('redo', () => {\n      // Attempt to redo history.\n      const passageName = History.redo();\n      // If redo failed, name will be null.\n      if (passageName !== null) {\n        // Check if at end of collection.\n        if (History.position === History.history.length - 1) {\n          // Hide redo.\n          this.sidebar.hideRedo();\n          // Show undo.\n          this.sidebar.showUndo();\n        }\n        // Not null, show previous passage.\n        this.show(passageName);\n      }\n    });\n\n    // Listen for undo events.\n    State.events.on('undo', () => {\n      // Show redo if undo is clicked.\n      this.sidebar.showRedo();\n      // Attempt to undo history.\n      const passageName = History.undo();\n      // If undo failed, name will be null.\n      if (passageName !== null) {\n        // Check if at beginning of collection.\n        if (History.position === 0) {\n          // Hide undo\n          this.sidebar.hideUndo();\n        }\n        // Not null, show previous passage.\n        this.show(passageName);\n      }\n    });\n\n    /**\n     * The current passage.\n     * @property {Passage|null} currentPassage Currently showing passage, if any.\n     * @type {Passage|null}\n     */\n    this.currentPassage = null;\n\n    /**\n     * Reference to internal Storylets object.\n     *\n     * Starts as null. During Story.start(), a new object is\n     * created based on initial passages.\n     * @property {Storylets} storylets Internal reference to Storylets\n     * @type {Storylets|null}\n     */\n    this.storylets = null;\n  }\n\n  /**\n   * Begins playing this story based on data from tw-storydata.\n   * 1. Apply all user styles\n   * 2. Run all user scripts\n   * 3. Find starting passage\n   * 4. Add to starting passage to History.history\n   * 5. Show starting passage\n   * 6. Trigger 'start' event\n   * @function start\n   */\n  start () {\n    // Find all passages with the tag 'storylet'.\n    const passageList = this.getPassagesByTag('storylet');\n    // Generate initial Storylets collection.\n    this.storylets = new Storylets(passageList);\n\n    // For each Twine style, add them to the body as extra style elements.\n    $('*[type=\"text/twine-css\"]').each((index, element) => {\n      // Convert from Element into jQuery Element.\n      const twineStyleElement = $(element);\n      // Append a new `<style>` with text from old.\n      $(document.body).append(`<style>${twineStyleElement.text()}</style>`);\n    });\n\n    /**\n     * Note: Browsers prevent error catching from scripts\n     *  added after the initial loading.\n     *\n     * window.onerror will have error, but it cannot\n     *  be caught.\n     */\n    $('*[type=\"text/twine-javascript\"]').each((index, element) => {\n      // Convert Element into jQuery Element.\n      const twineScriptElement = $(element);\n      // Create a new `<script>`.\n      const newScriptElement = $('<script>');\n      // Set the text of new from old.\n      newScriptElement.text(twineScriptElement.text());\n      // Append the new `<script>` with text to document body.\n      $(document.body).append(newScriptElement);\n    });\n\n    // Get the startnode value (which is a number).\n    const startingPassageID = parseInt($('tw-storydata').attr('startnode'));\n    // Use the PID to find the name of the starting passage based on elements.\n    const startPassage = $(`[pid=\"${startingPassageID}\"]`).attr('name');\n    // Search for the starting passage.\n    const passage = this.getPassageByName(startPassage);\n\n    // Does the starting passage exist?\n    if (passage === null) {\n      // It does not exist.\n      // Throw an error.\n      throw new Error('Starting passage does not exist!');\n    }\n\n    // Add to the history.\n    History.add(passage.name);\n\n    // Set the global passage to the one about to be shown.\n    this.currentPassage = passage;\n\n    // Overwrite current tags\n    this.passageElement.attr('tags', passage.tags);\n\n    // Get passage source.\n    const passageSource = this.include(passage.name);\n\n    // Overwrite the parsed with the rendered.\n    this.passageElement.html(passageSource);\n\n    // Listen for any reader clicking on `<tw-link>`.\n    $('tw-link[data-passage]').on('click', (event) => {\n      // Convert Element into jQuery Element.\n      const jEl = $(event.target);\n      // Retrieve data-passage value.\n      const passageName = jEl.attr('data-passage');\n      // Add to the history.\n      History.add(passageName);\n      // Hide the redo icon.\n      this.sidebar.hideRedo();\n      // Show the undo icon.\n      this.sidebar.showUndo();\n      // Show the passage by name.\n      this.show(passageName);\n    });\n\n    /**\n     * Triggered when the story starts.\n     * @event State#start\n     * @type {string}\n     */\n    State.events.emit('start', passage.name);\n  }\n\n  /**\n   * Returns an array of none, one, or many passages matching a specific tag.\n   * @function getPassagesByTag\n   * @param {string} tag - Tag to search for.\n   * @returns {Array} Array containing none, one, or many passage objects.\n   */\n  getPassagesByTag (tag) {\n    // Search internal passages\n    return this.passages.filter((p) => {\n      return p.tags.includes(tag);\n    });\n  }\n\n  /**\n   * Returns a Passage object by name from internal collection. If none exists, returns null.\n   * The Twine editor prevents multiple passages from having the same name, so\n   * this always returns the first search result.\n   * @function getPassageByName\n   * @param {string} name - name of the passage\n   * @returns {Passage|null} Passage object or null\n   */\n  getPassageByName (name) {\n    // Create default value\n    let passage = null;\n\n    // Search for any passages with the name\n    const result = this.passages.filter((p) => p.name === name);\n\n    // Were any found?\n    if (result.length !== 0) {\n      // Grab the first result.\n      passage = result[0];\n    }\n\n    // Return either null or first result found.\n    return passage;\n  }\n\n  /**\n   * Replaces current passage shown to reader with rendered source of named passage.\n   * If the named passage does not exist, an error is thrown.\n   * @function show\n   * @param {string} name name of the passage.\n   */\n  show (name) {\n    // Look for passage by name.\n    const passage = this.getPassageByName(name);\n\n    // passage will be null if it was not found.\n    if (passage === null) {\n      // Passage was not found.\n      // Throw error.\n      throw new Error(`There is no passage with the name ${name}`);\n    }\n\n    // Set currentPassage to the one about to be shown.\n    this.currentPassage = passage;\n\n    // Overwrite current tags.\n    this.passageElement.attr('tags', passage.tags);\n\n    // Get passage source by name.\n    const passageSource = this.include(passage.name);\n\n    // Overwrite any existing HTML.\n    this.passageElement.html(passageSource);\n\n    // Listen for any reader clicking on `<tw-link>`.\n    $('tw-link[data-passage]').on('click', (event) => {\n      // Convert Element into jQuery Element.\n      const jEl = $(event.target);\n      // Retrieve data-passage value.\n      const passageName = jEl.attr('data-passage');\n      // Add to the history.\n      History.add(passageName);\n      // Hide the redo icon.\n      this.sidebar.hideRedo();\n      // Show the undo icon.\n      this.sidebar.showUndo();\n      // Show the passage by name.\n      this.show(passageName);\n    });\n\n    /**\n     * Triggered when a passage is shown.\n     * @event State#show\n     * @type {string}\n     */\n    State.events.emit('show', passage.name);\n  }\n\n  /**\n   * Returns the rendered source of a passage by name.\n   * @function include\n   * @param {string} name - name of the passage.\n   * @returns {string} Rendered passage source.\n   */\n  include (name) {\n    // Search for passage by name.\n    const passage = this.getPassageByName(name);\n\n    // Does this passage exist?\n    if (passage === null) {\n      // It does not exist.\n      // Throw error.\n      throw new Error('There is no passage with name ' + name);\n    }\n\n    // Get passage source.\n    let passageSource = passage.source;\n\n    // Run any script.\n    passageSource = Script.run(passageSource, this);\n\n    // Parse any Markdown.\n    passageSource = Markdown.parse(passageSource);\n\n    // Run the Markdown conversion.\n    passageSource = Markdown.convert(passageSource);\n\n    // Return the passage source.\n    return passageSource;\n  }\n\n  /**\n   * Render a passage to any/all element(s) matching query selector\n   * @function renderPassageToSelector\n   * @param {object} passageName - The passage to render\n   * @param {string} selector - jQuery selector\n   */\n  renderPassageToSelector (passageName, selector) {\n    // Get passage source\n    const passageSource = this.include(passageName);\n\n    // Replace the HTML of the selector (if valid).\n    $(selector).html(passageSource);\n  }\n\n  /**\n   * Add a new passage to the story.\n   * @function addPassage\n   * @param {string} name name\n   * @param {Array} tags tags\n   * @param {string} source source\n   */\n  addPassage (name = '', tags = [], source = '') {\n    // Look for name.\n    const nameSearch = this.getPassageByName(name);\n\n    // Confirm name does not already exist.\n    if (nameSearch !== null) {\n      throw new Error('Cannot add two passages with the same name!');\n    }\n\n    // Confirm tags is an array.\n    if (!Array.isArray(tags)) {\n      // Ignore and set to empty array.\n      tags = [];\n    }\n\n    // Confirm if source is string.\n    if (Object.prototype.toString.call(source) !== '[object String]') {\n      // Ignore and set to empty string.\n      source = '';\n    }\n\n    // Add to the existing passages.\n    this.passages.push(new Passage(\n      name,\n      tags,\n      Markdown.unescape(source)\n    ));\n  }\n\n  /**\n   * Remove a passage from the story internal collection.\n   * Removing a passage and then attempting to visit the passage will\n   * throw an error.\n   *\n   * Note: Does not affect HTML elements.\n   * @function removePassage\n   * @param {string} name name\n   */\n  removePassage (name = '') {\n    this.passages = this.passages.filter(passage => {\n      return passage.name !== name;\n    });\n  }\n\n  /**\n   * Go to an existing passage in the story. Unlike `Story.show()`, this will add to the history.\n   *\n   * Throws error if passage does not exist.\n   * @function goto\n   * @param {string} name name of passage\n   */\n  goto (name = '') {\n    // Look for passage.\n    const passage = this.getPassageByName(name);\n\n    // Does passage exist?\n    if (passage === null) {\n      // Throw error.\n      throw new Error(`There is no passage with the name ${name}`);\n    }\n\n    // Add to the history.\n    History.add(name);\n\n    // Hide the redo icon.\n    this.sidebar.hideRedo();\n\n    // Show the passage by name.\n    this.show(name);\n  }\n}\n\nmodule.exports = Story;\n\n\n/***/ }),\n\n/***/ 9715:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst { Query } = __webpack_require__(8543);\nconst State = __webpack_require__(9421);\n\n/**\n * An object containing none, one, or multiple passages based\n * on their use of the 'storylet' passage tag and `<requirements>` element.\n * @class Storylets\n */\nclass Storylets {\n  constructor (storyPassages = []) {\n    // Internal array of passages.\n    this.passages = [];\n\n    // Is storyPassages an array?\n    if (!Array.isArray(storyPassages)) {\n      // If not, make it an empty array.\n      storyPassages = [];\n    }\n\n    // For each, look for the <requirements> element in their source.\n    for (const passageEntry of storyPassages) {\n      // Double-check each object has a 'source' property.\n      if (Object.prototype.hasOwnProperty.call(passageEntry, 'source')) {\n        // Find the element and replace it with an empty string.\n        const searchedSource = passageEntry.source.replace(/<requirements>([^>]*?)<\\/requirements>/gmi, (match, captured) => {\n          // Set a default object if JSON parsing fails.\n          let passageRequirements = {};\n\n          // Attempt JSON parsing, which can throw error on failure.\n          try {\n            // Try to parse string into object\n            passageRequirements = JSON.parse(captured);\n          } catch (error) {\n            console.info('INFO: Failed to parse passage requirements. Error:', error);\n            // Ignore the error\n          }\n\n          // Set default priority for all cards.\n          let passagePriority = 0;\n\n          // Look for priority property.\n          // First, are there any keys?\n          if (Object.keys(passageRequirements).length > 0) {\n            // Second, does the 'priority' property exist?\n            if (Object.prototype.hasOwnProperty.call(passageRequirements, 'priority')) {\n              // Update priority.\n              passagePriority = passageRequirements.priority;\n              // Remove priority.\n              delete passageRequirements.priority;\n            }\n          }\n\n          // Add the passage to the internal array.\n          this.passages.push(\n            {\n              passage: passageEntry,\n              requirements: passageRequirements,\n              priority: passagePriority\n            }\n          );\n\n          // Return empty string, removing it from the passage source.\n          return '';\n        });\n\n        // Overwrite previous source with removed <requirements> element.\n        passageEntry.source = searchedSource;\n      }\n    }\n  }\n\n  /**\n   * For each passage in the internal collection,\n   * test their requirements against State.store.\n   *\n   * Returns highest priority passages first.\n   * @function getAvailablePassages\n   * @param {number} limit Number of passages to return\n   * @returns {Array} Array of none, one, or many available passages.\n   */\n  getAvailablePassages (limit = 0) {\n    // Create results array.\n    let results = [];\n\n    // Force argument into number.\n    limit = parseInt(limit);\n\n    // For each passage, test its requirements against State.store.\n    this.passages.forEach(entry => {\n      // Pull the requirements.\n      const requirements = entry.requirements;\n      // Create a query based on requirements.\n      const query = new Query(requirements);\n      // Test against State.store AND make sure there are search properties.\n      // As requirements can be an empty object, we need to protect against it.\n      if (query.test(State.store) && Object.keys(requirements).length > 0) {\n        // Add the element to the results.\n        results.push(entry);\n      }\n    });\n\n    // Sort results by priority.\n    results.sort((a, b) => b.priority - a.priority);\n\n    // Slice the results based on limit argument.\n    if (limit !== 0) {\n      results = results.slice(0, limit);\n    }\n\n    // Return either all or sliced results.\n    return results;\n  }\n\n  /**\n   * Add a passage to the Storylets collection.\n   * @function addPassage\n   * @param {string} newName Name of existing passage to add.\n   * @param {object} newRequirements Requirements of passage.\n   * @param {number} newPriority Priority of passage compared to other available.\n   */\n  addPassage (newName = '', newRequirements = {}, newPriority = 0) {\n    // Check if passage exists in Story.\n    const newPassage = window.Story.getPassageByName(newName);\n\n    // If the passage was not found, throw an error.\n    if (newPassage == null) {\n      throw new Error('Passage must exist in Story to be added to Storylets collection');\n    }\n\n    // Test if passage exists in Storylets collection.\n    if (this.includes(newName)) {\n      throw new Error('Cannot add same passage twice to Storylets collection.');\n    }\n\n    // Verify newRequirements is an object.\n    if (!(newRequirements && typeof newRequirements === 'object' && newRequirements.constructor === Object)) {\n      // Ignore and set to empty object.\n      newRequirements = {};\n    }\n\n    // Force parse newPriority into a number.\n    newPriority = parseInt(newPriority);\n\n    // Add the new, existing passage along with its requirements and priority.\n    this.passages.push(\n      {\n        passage: newPassage,\n        requirements: newRequirements,\n        priority: newPriority\n      }\n    );\n  }\n\n  /**\n   * Returns if Storylets collection already contains passage name or not.\n   *\n   * As passage names are unique to a story, the Storylets collection\n   * cannot hold two entries with the same name.\n   * @function includes\n   * @param {string} name Name of passage to search.\n   * @returns {boolean} True if passage is in collection.\n   */\n  includes (name = '') {\n    // Filter for passage name.\n    const passageList = this.passages.filter((entry) => {\n      return entry.passage.name === name;\n    });\n\n    // Return if passage was found.\n    return (passageList.length > 0);\n  }\n\n  /**\n   * Remove a passage from the collection by name.\n   * @function removePassage\n   * @param {string} name Name of existing passage to remove.\n   */\n  removePassage (name = '') {\n    this.passages = this.passages.filter((entry) => {\n      return entry.passage.name !== name;\n    });\n  }\n}\n\nmodule.exports = Storylets;\n\n\n/***/ }),\n\n/***/ 5072:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\nconst $ = __webpack_require__(4692);\n\nclass Utilities {\n  /**\n   * Accepts a function, wait, and optional set of arguments.\n   * After the wait, the function will run with the passed arguments.\n   * @function delay\n   * @param {Function}    func    Function to run.\n   * @param {number}      wait    Number of milliseconds to wait.\n   * @param {any}         [args]  Optional arguments to pass to the function.\n   * @returns {number}            Identification of timer returned from setTimeout().\n   */\n  static delay (func, wait, ...args) {\n    const boundFunction = func.bind(func);\n    return setTimeout(boundFunction, wait, ...args);\n  }\n\n  /**\n   * Accepts mixed input of arrays or comma-separated list of values and returns a random entry.\n   * Will return null when given no arguments.\n   *\n   * Examples:\n   * - either(1,2,3);\n   * - either(1,[2],[4,5]);\n   * @function either\n   * @param   {object|Array} args Array or comma-separated list.\n   * @returns {object|null}       Random entry or null.\n   */\n  static either (...args) {\n    let tempArray = [];\n    let result = null;\n\n    // For every entry...\n    for (const entry of args) {\n      // If it is not an array...\n      if (!(entry instanceof Array)) {\n        // push the entry into the temporary array.\n        tempArray.push(entry);\n      } else {\n        // Spread out any subentries and add them to temporary array.\n        tempArray = [...tempArray, ...entry];\n      }\n    }\n\n    // Check if any entries were added.\n    if (tempArray.length > 0) {\n      // If they were, grab one of them.\n      result = tempArray[Math.floor(Math.random() * tempArray.length)];\n    }\n\n    // Return either null (no entries) or random entry.\n    return result;\n  }\n\n  /**\n   * Applies external CSS files.\n   * @function applyExternalStyles\n   * @param {Array} files Array of one or more external files to load.\n   */\n  static applyExternalStyles (files) {\n    if (Array.isArray(files)) {\n      files.forEach(location => {\n        $('<link/>', {\n          rel: 'stylesheet',\n          type: 'text/css',\n          href: location\n        }).appendTo('head');\n      });\n    } else {\n      throw new Error('Method only accepts an array!');\n    }\n  }\n\n  /**\n   * Return random integer within range.\n   * @function randomInt\n   * @param   {number}  min   Start of range (default 0).\n   * @param   {number}  max   End of range (default 0).\n   * @returns {number}        Number in range.\n   */\n  static randomInt (min = 0, max = 0) {\n    // Round up to min.\n    min = Math.ceil(min);\n    // Round down to max.\n    max = Math.floor(max);\n\n    // Is min greater than max?\n    if (min > max) {\n      max = min;\n      min = 0;\n    }\n\n    return Math.floor(Math.random() * (max - min)) + min;\n  }\n}\n\nmodule.exports = Utilities;\n\n\n/***/ }),\n\n/***/ 7280:\n/***/ (() => {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ 7024:\n/***/ (() => {\n\n/* (ignored) */\n\n/***/ }),\n\n/***/ 3840:\n/***/ ((module) => {\n\n\"use strict\";\nmodule.exports = {\"rE\":\"3.1.10\"};\n\n/***/ })\n\n/******/ \t});\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tvar cachedModule = __webpack_module_cache__[moduleId];\n/******/ \t\tif (cachedModule !== undefined) {\n/******/ \t\t\treturn cachedModule.exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\t// no module.id needed\n/******/ \t\t\t// no module.loaded needed\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t(() => {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = (exports, definition) => {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/make namespace object */\n/******/ \t(() => {\n/******/ \t\t// define __esModule on exports\n/******/ \t\t__webpack_require__.r = (exports) => {\n/******/ \t\t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t\t}\n/******/ \t\t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/************************************************************************/\nvar __webpack_exports__ = {};\n// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.\n(() => {\n\"use strict\";\n// Require normalize.css.\n\n// Require local CSS.\n\n// Require jQuery.\nconst $ = __webpack_require__(4692);\n// Setup global jQuery.\nwindow.$ = $;\nwindow.jQuery = $;\n// Require Story.\nconst Story = __webpack_require__(2577);\n// Create new Story instance.\nwindow.Story = new Story();\n// Create global store shortcut.\nwindow.s = window.Story.store;\n// Start story.\nwindow.Story.start();\n\n})();\n\n/******/ })()\n;</script>\n\t</body>\n</html>\n"});
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 3e65221a..73c0c67b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,32 +12,32 @@
         "ejs": "^3.1.10",
         "jquery": "^3.7.1",
         "markdown-it": "^14.1.0",
-        "mingo": "^6.4.15",
+        "mingo": "^6.5.1",
         "normalize.css": "^8.0.1",
         "underscore": "^1.13.7"
       },
       "devDependencies": {
-        "@eslint/js": "^9.9.1",
+        "@eslint/js": "^9.17.0",
         "@types/expect-puppeteer": "^5.0.6",
         "@types/jest-environment-puppeteer": "^5.0.6",
         "@types/puppeteer": "^7.0.4",
         "css-loader": "^7.1.2",
         "css-minimizer-webpack-plugin": "^7.0.0",
-        "eslint": "^9.9.1",
-        "eslint-plugin-jest": "^28.8.2",
-        "eslint-plugin-jsdoc": "^50.2.2",
-        "extwee": "^2.2.3",
-        "globals": "^15.9.0",
+        "eslint": "^9.17.0",
+        "eslint-plugin-jest": "^28.9.0",
+        "eslint-plugin-jsdoc": "^50.6.1",
+        "extwee": "^2.2.4",
+        "globals": "^15.13.0",
         "jest": "^29.7.0",
         "jest-environment-jsdom": "^29.7.0",
-        "jest-puppeteer": "^10.1.0",
-        "mini-css-extract-plugin": "^2.9.1",
+        "jest-puppeteer": "^10.1.4",
+        "mini-css-extract-plugin": "^2.9.2",
         "open": "^10.1.0",
         "open-cli": "^8.0.0",
-        "puppeteer": "^23.2.1",
+        "puppeteer": "^23.10.4",
         "shelljs": "^0.8.5",
         "style-loader": "^4.0.0",
-        "webpack": "^5.94.0",
+        "webpack": "^5.97.1",
         "webpack-cli": "^5.1.4"
       }
     },
@@ -728,9 +728,9 @@
       }
     },
     "node_modules/@es-joy/jsdoccomment": {
-      "version": "0.48.0",
-      "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.48.0.tgz",
-      "integrity": "sha512-G6QUWIcC+KvSwXNsJyDTHvqUdNoAVJPPgkc3+Uk4WBKqZvoXhlvazOgm9aL0HwihJLQf0l+tOE2UFzXBqCqgDw==",
+      "version": "0.49.0",
+      "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.49.0.tgz",
+      "integrity": "sha512-xjZTSFgECpb9Ohuk5yMX5RhUEbfeQcuOp8IF60e+wyzWEF0M5xeSgqsfLtvPEX8BIyOX9saZqzuGPmZ8oWc+5Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -758,9 +758,9 @@
       }
     },
     "node_modules/@eslint-community/regexpp": {
-      "version": "4.11.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.0.tgz",
-      "integrity": "sha512-G/M/tIiMrTAxEWRfLfQJMmGNX28IxBg4PBz8XqQhqUHLFI6TL2htpIB1iQCj144V5ee/JaKyT9/WZ0MGZWfA7A==",
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -768,13 +768,13 @@
       }
     },
     "node_modules/@eslint/config-array": {
-      "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.18.0.tgz",
-      "integrity": "sha512-fTxvnS1sRMu3+JjXwJG0j/i4RT9u4qJ+lqS/yCGap4lH4zZGzQ7tu+xZqQmcMZq5OBZDL4QRxQzRjkWcGt8IVw==",
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.19.1.tgz",
+      "integrity": "sha512-fo6Mtm5mWyKjA/Chy1BYTdn5mGJoDNjC7C64ug20ADsRDGrA85bN3uK3MaKbeRkRuuIEAR5N33Jr1pbm411/PA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@eslint/object-schema": "^2.1.4",
+        "@eslint/object-schema": "^2.1.5",
         "debug": "^4.3.1",
         "minimatch": "^3.1.2"
       },
@@ -782,10 +782,23 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@eslint/core": {
+      "version": "0.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.9.1.tgz",
+      "integrity": "sha512-GuUdqkyyzQI5RMIWkHhvTWLCyLo1jNK3vzkSyaExH5kHPDHcuL2VOpHjmMY+y3+NC69qAKToBqldTBgYeLSr9Q==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
     "node_modules/@eslint/eslintrc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.1.0.tgz",
-      "integrity": "sha512-4Bfj15dVJdoy3RfZmmo86RK1Fwzn6SstsvK9JS+BaVKqC6QQQQyXekNaC+g+LKNgkQ+2VhGAzm6hO40AhMR3zQ==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.2.0.tgz",
+      "integrity": "sha512-grOjVNN8P3hjJn/eIETF1wwd12DdnwFDoyceUJLYYdkpbwq3nLi+4fqrTAONx7XDALqlL220wC/RHSC/QTI/0w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -820,9 +833,9 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.9.1",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.9.1.tgz",
-      "integrity": "sha512-xIDQRsfg5hNBqHz04H1R3scSVwmI+KUbqjsQKHKQ1DAUSaUjYPReZZmS/5PNiKu1fUvzDd6H7DEDKACSEhu+TQ==",
+      "version": "9.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.17.0.tgz",
+      "integrity": "sha512-Sxc4hqcs1kTu0iID3kcZDW3JHq2a77HO9P8CP6YEA/FpH3Ll8UXE2r/86Rz9YJLKme39S9vU5OWNjC6Xl0Cr3w==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -830,11 +843,24 @@
       }
     },
     "node_modules/@eslint/object-schema": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.4.tgz",
-      "integrity": "sha512-BsWiH1yFGjXXS2yvrf5LyuoSIIbPrGUWob917o+BTKuZ7qJdxX8aJLRxs1fS9n6r7vESrq1OUqb68dANcFXuQQ==",
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.5.tgz",
+      "integrity": "sha512-o0bhxnL89h5Bae5T318nFoFzGy+YE5i/gGkoPAgkmTVdRKTiv3p8JHevPiPaMwoloKfEiiaHlawCqaZMqRm+XQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.2.4.tgz",
+      "integrity": "sha512-zSkKow6H5Kdm0ZUQUB2kV5JIXqoG0+uH5YADhaEHswm664N9Db8dXSi0nMJpacpMf+MyyglF1vnZohpEg5yUtg==",
       "dev": true,
       "license": "Apache-2.0",
+      "dependencies": {
+        "levn": "^0.4.1"
+      },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
@@ -856,6 +882,44 @@
         "@hapi/hoek": "^9.0.0"
       }
     },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.6",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz",
+      "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.3.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz",
+      "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
     "node_modules/@humanwhocodes/module-importer": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
@@ -870,9 +934,9 @@
       }
     },
     "node_modules/@humanwhocodes/retry": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.0.tgz",
-      "integrity": "sha512-d2CGZR2o7fS6sWB7DG/3a95bGKQyHMACZ5aW8qGkkqQpUoZV6C0X7Pc7l4ZNMZkfNBf4VWNe9E1jRsf0G146Ew==",
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.1.tgz",
+      "integrity": "sha512-c7hNEllBlenFTHBky65mhq8WD2kbN9Q6gk0bTk8lSBvc554jpXSkST1iePudpt7+A/AQvuHs9EMqjHDXMY1lrA==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
@@ -1584,16 +1648,16 @@
       }
     },
     "node_modules/@puppeteer/browsers": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.3.1.tgz",
-      "integrity": "sha512-uK7o3hHkK+naEobMSJ+2ySYyXtQkBxIH8Gn4MK9ciePjNV+Pf+PgY/W7iPzn2MTjl3stcYB5AlcTmPYw7AXDwA==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.6.1.tgz",
+      "integrity": "sha512-aBSREisdsGH890S2rQqK82qmQYU3uFpSH8wcZWHgHzl3LfzsxAKbLNiAG9mO8v1Y0UICBeClICxPJvyr0rcuxg==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "debug": "^4.3.6",
+        "debug": "^4.4.0",
         "extract-zip": "^2.0.1",
         "progress": "^2.0.3",
-        "proxy-agent": "^6.4.0",
+        "proxy-agent": "^6.5.0",
         "semver": "^7.6.3",
         "tar-fs": "^3.0.6",
         "unbzip2-stream": "^1.4.3",
@@ -1727,11 +1791,34 @@
         "@babel/types": "^7.20.7"
       }
     },
+    "node_modules/@types/eslint": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz",
+      "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*",
+        "@types/json-schema": "*"
+      }
+    },
+    "node_modules/@types/eslint-scope": {
+      "version": "3.7.7",
+      "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+      "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/eslint": "*",
+        "@types/estree": "*"
+      }
+    },
     "node_modules/@types/estree": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
-      "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
-      "dev": true
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
+      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@types/expect-puppeteer": {
       "version": "5.0.6",
@@ -1827,10 +1914,11 @@
       }
     },
     "node_modules/@types/json-schema": {
-      "version": "7.0.12",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz",
-      "integrity": "sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==",
-      "dev": true
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@types/node": {
       "version": "20.4.8",
@@ -2015,148 +2103,163 @@
       }
     },
     "node_modules/@webassemblyjs/ast": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
-      "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/helper-numbers": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
+        "@webassemblyjs/helper-numbers": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
       }
     },
     "node_modules/@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
-      "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
-      "dev": true
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+      "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@webassemblyjs/helper-api-error": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
-      "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
-      "dev": true
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+      "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@webassemblyjs/helper-buffer": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
-      "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
-      "dev": true
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+      "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@webassemblyjs/helper-numbers": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
-      "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+      "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
+        "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+        "@webassemblyjs/helper-api-error": "1.13.2",
         "@xtuc/long": "4.2.2"
       }
     },
     "node_modules/@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
-      "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
-      "dev": true
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+      "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@webassemblyjs/helper-wasm-section": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
-      "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+      "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.12.1"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/wasm-gen": "1.14.1"
       }
     },
     "node_modules/@webassemblyjs/ieee754": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
-      "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+      "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@xtuc/ieee754": "^1.2.0"
       }
     },
     "node_modules/@webassemblyjs/leb128": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
-      "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+      "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
       "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
         "@xtuc/long": "4.2.2"
       }
     },
     "node_modules/@webassemblyjs/utf8": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
-      "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
-      "dev": true
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+      "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@webassemblyjs/wasm-edit": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
-      "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+      "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.12.1",
-        "@webassemblyjs/wasm-gen": "1.12.1",
-        "@webassemblyjs/wasm-opt": "1.12.1",
-        "@webassemblyjs/wasm-parser": "1.12.1",
-        "@webassemblyjs/wast-printer": "1.12.1"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/helper-wasm-section": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-opt": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1",
+        "@webassemblyjs/wast-printer": "1.14.1"
       }
     },
     "node_modules/@webassemblyjs/wasm-gen": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
-      "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+      "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
       }
     },
     "node_modules/@webassemblyjs/wasm-opt": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
-      "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+      "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/wasm-gen": "1.12.1",
-        "@webassemblyjs/wasm-parser": "1.12.1"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1"
       }
     },
     "node_modules/@webassemblyjs/wasm-parser": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
-      "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+      "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
       }
     },
     "node_modules/@webassemblyjs/wast-printer": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
-      "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+      "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/ast": "1.14.1",
         "@xtuc/long": "4.2.2"
       }
     },
@@ -2208,13 +2311,15 @@
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
       "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
-      "dev": true
+      "dev": true,
+      "license": "BSD-3-Clause"
     },
     "node_modules/@xtuc/long": {
       "version": "4.2.2",
       "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
       "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
-      "dev": true
+      "dev": true,
+      "license": "Apache-2.0"
     },
     "node_modules/abab": {
       "version": "2.0.6",
@@ -2223,9 +2328,9 @@
       "dev": true
     },
     "node_modules/acorn": {
-      "version": "8.12.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
-      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
+      "version": "8.14.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
+      "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -2245,15 +2350,6 @@
         "acorn-walk": "^8.0.2"
       }
     },
-    "node_modules/acorn-import-attributes": {
-      "version": "1.9.5",
-      "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
-      "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
-      "dev": true,
-      "peerDependencies": {
-        "acorn": "^8"
-      }
-    },
     "node_modules/acorn-jsx": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
@@ -2451,9 +2547,9 @@
       "dev": true
     },
     "node_modules/axios": {
-      "version": "1.7.7",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
-      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
+      "version": "1.7.9",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz",
+      "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2463,9 +2559,9 @@
       }
     },
     "node_modules/b4a": {
-      "version": "1.6.6",
-      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.6.tgz",
-      "integrity": "sha512-5Tk1HLk6b6ctmjIkAcU/Ujv/1WqiDl0F0JdRCR80VsOcUlHcu7pWeWRlOqQLHfDEsVx9YH/aif5AG4ehoCtTmg==",
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
+      "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
       "dev": true,
       "license": "Apache-2.0"
     },
@@ -2591,17 +2687,17 @@
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
     },
     "node_modules/bare-events": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.4.2.tgz",
-      "integrity": "sha512-qMKFd2qG/36aA4GwvKq8MxnPgCQAmBWmSyLWsJcbn8v03wvIPQ/hG1Ms8bPzndZxMDoHpxez5VOS+gC9Yi24/Q==",
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.5.0.tgz",
+      "integrity": "sha512-/E8dDe9dsbLyh2qrZ64PEPadOQ0F4gbl1sUJOrmph7xOiIxfY8vwab/4bFLh4Y88/Hk/ujKcrQKc+ps0mv873A==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true
     },
     "node_modules/bare-fs": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-2.3.3.tgz",
-      "integrity": "sha512-7RYKL+vZVCyAsMLi5SPu7QGauGGT8avnP/HO571ndEuV4MYdGXvLhtW67FuLPeEI8EiIY7zbbRR9x7x7HU0kgw==",
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-2.3.5.tgz",
+      "integrity": "sha512-SlE9eTxifPDJrT6YgemQ1WGFleevzwY+XAP1Xqgl56HtcrisC2CHCZ2tq6dBpcH2TnNxwUEUGhweo+lrQtYuiw==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
@@ -2612,9 +2708,9 @@
       }
     },
     "node_modules/bare-os": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-2.4.2.tgz",
-      "integrity": "sha512-HZoJwzC+rZ9lqEemTMiO0luOePoGYNBgsLLgegKR/cljiJvcDNhDZQkzC+NC5Oh0aHbdBNSOHpghwMuB5tqhjg==",
+      "version": "2.4.4",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-2.4.4.tgz",
+      "integrity": "sha512-z3UiI2yi1mK0sXeRdc4O1Kk8aOa/e+FNWZcTiPB/dfTWyLypuE99LibgRaQki914Jq//yAWylcAt+mknKdixRQ==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true
@@ -2631,14 +2727,14 @@
       }
     },
     "node_modules/bare-stream": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.2.0.tgz",
-      "integrity": "sha512-+o9MG5bPRRBlkVSpfFlMag3n7wMaIZb4YZasU2+/96f+3HTQ4F9DKQeu3K/Sjz1W0umu6xvVq1ON0ipWdMlr3A==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.1.tgz",
+      "integrity": "sha512-eVZbtKM+4uehzrsj49KtCy3Pbg7kO1pJ3SKZ1SFrIH/0pnj9scuGGgUlNDf/7qS8WKtGdiJY5Kyhs/ivYPTB/g==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {
-        "streamx": "^2.18.0"
+        "streamx": "^2.21.0"
       }
     },
     "node_modules/base64-js": {
@@ -2700,9 +2796,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.23.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-      "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+      "version": "4.24.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz",
+      "integrity": "sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==",
       "dev": true,
       "funding": [
         {
@@ -2720,10 +2816,10 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001646",
-        "electron-to-chromium": "^1.5.4",
-        "node-releases": "^2.0.18",
-        "update-browserslist-db": "^1.1.0"
+        "caniuse-lite": "^1.0.30001688",
+        "electron-to-chromium": "^1.5.73",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.1"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -2829,9 +2925,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001655",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001655.tgz",
-      "integrity": "sha512-jRGVy3iSGO5Uutn2owlb5gR6qsGngTw9ZTb4ali9f3glshcNmJ2noam4Mo9zia5P9Dk3jNNydy7vQjuE5dQmfg==",
+      "version": "1.0.30001689",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001689.tgz",
+      "integrity": "sha512-CmeR2VBycfa+5/jOfnp/NpWPGd06nf1XYiefUvhXFfZE4GkRc9jv+eGPS4nT558WS/8lYCzV8SlANCIPvbWP1g==",
       "dev": true,
       "funding": [
         {
@@ -2883,9 +2979,9 @@
       }
     },
     "node_modules/chromium-bidi": {
-      "version": "0.6.4",
-      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.6.4.tgz",
-      "integrity": "sha512-8zoq6ogmhQQkAKZVKO2ObFTl4uOkqoX1PlKQX3hZQ5E9cbUotcAb7h4pTNVAGGv8Z36PF3CtdOriEp/Rz82JqQ==",
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.8.0.tgz",
+      "integrity": "sha512-uJydbGdTw0DEUjhoogGveneJVWX/9YuqkWePzMmkBYwtdAqo5d3J/ovNKFr+/2hWXYmYCr6it8mSSTIj6SS6Ug==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -3109,10 +3205,11 @@
       }
     },
     "node_modules/cross-spawn": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
         "shebang-command": "^2.0.0",
@@ -3475,13 +3572,13 @@
       }
     },
     "node_modules/debug": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz",
-      "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ms": "2.1.2"
+        "ms": "^2.1.3"
       },
       "engines": {
         "node": ">=6.0"
@@ -3601,9 +3698,9 @@
       }
     },
     "node_modules/devtools-protocol": {
-      "version": "0.0.1330662",
-      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1330662.tgz",
-      "integrity": "sha512-pzh6YQ8zZfz3iKlCvgzVCu22NdpZ8hNmwU6WnQjNVquh0A9iVosPtNLWDwaWVGyrntQlltPFztTMK5Cg6lfCuw==",
+      "version": "0.0.1367902",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1367902.tgz",
+      "integrity": "sha512-XxtPuC3PGakY6PD7dG66/o8KwJ/LkH2/EKe19Dcw58w53dv4/vSQEkn/SzuyhHE2q4zPgCkxQBxus3VV4ql+Pg==",
       "dev": true,
       "license": "BSD-3-Clause"
     },
@@ -3702,9 +3799,9 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.13",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.13.tgz",
-      "integrity": "sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==",
+      "version": "1.5.73",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.73.tgz",
+      "integrity": "sha512-8wGNxG9tAG5KhGd3eeA0o6ixhiNdgr0DcHWm85XPCphwZgD1lIEoi6t3VERayWao7SF7AAZTw6oARGJeVjH8Kg==",
       "dev": true,
       "license": "ISC"
     },
@@ -3842,28 +3939,32 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.9.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.9.1.tgz",
-      "integrity": "sha512-dHvhrbfr4xFQ9/dq+jcVneZMyRYLjggWjk6RVsIiHsP8Rz6yZ8LvZ//iU4TrZF+SXWG+JkNF2OyiZRvzgRDqMg==",
+      "version": "9.17.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.17.0.tgz",
+      "integrity": "sha512-evtlNcpJg+cZLcnVKwsai8fExnqjGPicK7gnUtlNuzu+Fv9bI0aLpND5T44VLQtoMEnI57LoXO9XAkIXwohKrA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.11.0",
-        "@eslint/config-array": "^0.18.0",
-        "@eslint/eslintrc": "^3.1.0",
-        "@eslint/js": "9.9.1",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.19.0",
+        "@eslint/core": "^0.9.0",
+        "@eslint/eslintrc": "^3.2.0",
+        "@eslint/js": "9.17.0",
+        "@eslint/plugin-kit": "^0.2.3",
+        "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
-        "@humanwhocodes/retry": "^0.3.0",
-        "@nodelib/fs.walk": "^1.2.8",
+        "@humanwhocodes/retry": "^0.4.1",
+        "@types/estree": "^1.0.6",
+        "@types/json-schema": "^7.0.15",
         "ajv": "^6.12.4",
         "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.2",
+        "cross-spawn": "^7.0.6",
         "debug": "^4.3.2",
         "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.0.2",
-        "eslint-visitor-keys": "^4.0.0",
-        "espree": "^10.1.0",
+        "eslint-scope": "^8.2.0",
+        "eslint-visitor-keys": "^4.2.0",
+        "espree": "^10.3.0",
         "esquery": "^1.5.0",
         "esutils": "^2.0.2",
         "fast-deep-equal": "^3.1.3",
@@ -3873,15 +3974,11 @@
         "ignore": "^5.2.0",
         "imurmurhash": "^0.1.4",
         "is-glob": "^4.0.0",
-        "is-path-inside": "^3.0.3",
         "json-stable-stringify-without-jsonify": "^1.0.1",
-        "levn": "^0.4.1",
         "lodash.merge": "^4.6.2",
         "minimatch": "^3.1.2",
         "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3",
-        "strip-ansi": "^6.0.1",
-        "text-table": "^0.2.0"
+        "optionator": "^0.9.3"
       },
       "bin": {
         "eslint": "bin/eslint.js"
@@ -3902,9 +3999,9 @@
       }
     },
     "node_modules/eslint-plugin-jest": {
-      "version": "28.8.2",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jest/-/eslint-plugin-jest-28.8.2.tgz",
-      "integrity": "sha512-mC3OyklHmS5i7wYU1rGId9EnxRI8TVlnFG56AE+8U9iRy6zwaNygZR+DsdZuCL0gRG0wVeyzq+uWcPt6yJrrMA==",
+      "version": "28.9.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-jest/-/eslint-plugin-jest-28.9.0.tgz",
+      "integrity": "sha512-rLu1s1Wf96TgUUxSw6loVIkNtUjq1Re7A9QdCCHSohnvXEBAjuL420h0T/fMmkQlNsQP2GhQzEUpYHPfxBkvYQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3928,13 +4025,13 @@
       }
     },
     "node_modules/eslint-plugin-jsdoc": {
-      "version": "50.2.2",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.2.2.tgz",
-      "integrity": "sha512-i0ZMWA199DG7sjxlzXn5AeYZxpRfMJjDPUl7lL9eJJX8TPRoIaxJU4ys/joP5faM5AXE1eqW/dslCj3uj4Nqpg==",
+      "version": "50.6.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-50.6.1.tgz",
+      "integrity": "sha512-UWyaYi6iURdSfdVVqvfOs2vdCVz0J40O/z/HTsv2sFjdjmdlUI/qlKLOTmwbPQ2tAfQnE5F9vqx+B+poF71DBQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
-        "@es-joy/jsdoccomment": "~0.48.0",
+        "@es-joy/jsdoccomment": "~0.49.0",
         "are-docs-informative": "^0.0.2",
         "comment-parser": "1.4.1",
         "debug": "^4.3.6",
@@ -3964,9 +4061,9 @@
       }
     },
     "node_modules/eslint-scope": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.0.2.tgz",
-      "integrity": "sha512-6E4xmrTw5wtxnLA5wYL3WDfhZ/1bUBGOXV0zQvVRDOtrR8D0p6W7fs3JweNYhwRYeGvd/1CKX2se0/2s7Q/nJA==",
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.2.0.tgz",
+      "integrity": "sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -3993,9 +4090,9 @@
       }
     },
     "node_modules/eslint/node_modules/eslint-visitor-keys": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.0.0.tgz",
-      "integrity": "sha512-OtIRv/2GyiF6o/d8K7MYKKbXrOUBIK6SfkIRM4Z0dY3w+LiQ0vy3F57m0Z71bjbyeiWFiHJ8brqnmE6H6/jEuw==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz",
+      "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
@@ -4006,15 +4103,15 @@
       }
     },
     "node_modules/espree": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.1.0.tgz",
-      "integrity": "sha512-M1M6CpiE6ffoigIOWYO9UDP8TMUw9kqb21tf+08IgDYjCsOvCuDt4jQcZmoYxx+w7zlKw9/N0KXfto+I8/FrXA==",
+      "version": "10.3.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz",
+      "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
-        "acorn": "^8.12.0",
+        "acorn": "^8.14.0",
         "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.0.0"
+        "eslint-visitor-keys": "^4.2.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -4024,9 +4121,9 @@
       }
     },
     "node_modules/espree/node_modules/eslint-visitor-keys": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.0.0.tgz",
-      "integrity": "sha512-OtIRv/2GyiF6o/d8K7MYKKbXrOUBIK6SfkIRM4Z0dY3w+LiQ0vy3F57m0Z71bjbyeiWFiHJ8brqnmE6H6/jEuw==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz",
+      "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
@@ -4163,10 +4260,11 @@
       }
     },
     "node_modules/expect-puppeteer": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/expect-puppeteer/-/expect-puppeteer-10.1.0.tgz",
-      "integrity": "sha512-d+RS+LWxlEq4RxWb2ifkXYg6/IS3VaZogAye0o2TZaf2qCFT8LN5yVLKfcYI54RQDBn/wMDRFySP+QMMFq+ZIg==",
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/expect-puppeteer/-/expect-puppeteer-10.1.4.tgz",
+      "integrity": "sha512-zNVzk/+TkPS/CuTlGSK7SjXuUpQiakXtUJhbTRrcPHop4jCWydPx9RlvHhQELzZYgXlLhIP+hvBzUNiN8WNAow==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=16"
       }
@@ -4209,19 +4307,19 @@
       }
     },
     "node_modules/extwee": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/extwee/-/extwee-2.2.3.tgz",
-      "integrity": "sha512-3knf1U6cWDn5jk4tCy2F5vZZZ9CFZX8p9ILeDs8Hc4q1pdpFawgRlKe3sw7o28xAU1ALFexCqbU1yUr4AommVQ==",
+      "version": "2.2.4",
+      "resolved": "https://registry.npmjs.org/extwee/-/extwee-2.2.4.tgz",
+      "integrity": "sha512-V4pTpgd+i4WcqbweZNZ71an7igxMPYW2LORxI1IfPS9bedAnokH0QWN3PnPVmEtlKX+SHkx4qUc0EtKfty1nnQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "commander": "^12.0.0",
+        "commander": "^12.1.0",
         "graphemer": "^1.4.0",
         "html-entities": "^2.5.2",
         "node-html-parser": "^6.1.13",
         "pickleparser": "^0.2.1",
-        "semver": "^7.6.0",
-        "uuid": "^9.0.1"
+        "semver": "^7.6.2",
+        "uuid": "^10.0.0"
       },
       "bin": {
         "extwee": "src/extwee.js"
@@ -4478,9 +4576,9 @@
       "license": "ISC"
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.6",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz",
-      "integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==",
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
       "dev": true,
       "funding": [
         {
@@ -4522,21 +4620,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/fs-extra": {
-      "version": "11.2.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
-      "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=14.14"
-      }
-    },
     "node_modules/fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
@@ -4615,16 +4698,15 @@
       }
     },
     "node_modules/get-uri": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.3.tgz",
-      "integrity": "sha512-BzUrJBS9EcUb4cFol8r4W3v1cPsSyajLSthNkz5BxbpDcHN5tIrM10E2eNvfnvBn3DaT3DUgx0OpsBKkaOpanw==",
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.4.tgz",
+      "integrity": "sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "basic-ftp": "^5.0.2",
         "data-uri-to-buffer": "^6.0.2",
-        "debug": "^4.3.4",
-        "fs-extra": "^11.2.0"
+        "debug": "^4.3.4"
       },
       "engines": {
         "node": ">= 14"
@@ -4712,9 +4794,9 @@
       }
     },
     "node_modules/globals": {
-      "version": "15.9.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-15.9.0.tgz",
-      "integrity": "sha512-SmSKyLLKFbSr6rptvP8izbyxJL4ILwqO9Jg23UA0sDlGlu58V59D1//I3vlc0KJphVdUR7vMjHIplYnzBxorQA==",
+      "version": "15.13.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-15.13.0.tgz",
+      "integrity": "sha512-49TewVEz0UxZjr1WYYsWpPrhyC/B/pA8Bq0fUmet2n+eR7yn0IvNzNaoBwnK6mdkzcN+se7Ez9zUgULTz2QH4g==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4896,10 +4978,11 @@
       ]
     },
     "node_modules/ignore": {
-      "version": "5.2.4",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz",
-      "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==",
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">= 4"
       }
@@ -5100,15 +5183,6 @@
         "node": ">=0.12.0"
       }
     },
-    "node_modules/is-path-inside": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
-      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/is-plain-object": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
@@ -5507,18 +5581,19 @@
       }
     },
     "node_modules/jest-dev-server": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/jest-dev-server/-/jest-dev-server-10.1.0.tgz",
-      "integrity": "sha512-zB5phqImkP1w6ANhRPrpr4oW84SDRRAhQhCEJ+NGGET4yapNf0Fu8ymS7inNPNQ8zQYgm8IfqyUGgEforPt8pg==",
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/jest-dev-server/-/jest-dev-server-10.1.4.tgz",
+      "integrity": "sha512-bGQ6sedNGtT6AFHhCVqGTXMPz7UyJi/ZrhNBgyqsP0XU9N8acCEIfqZEA22rOaZ+NdEVsaltk6tL7UT6aXfI7w==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "chalk": "^4.1.2",
         "cwd": "^0.10.0",
         "find-process": "^1.4.7",
         "prompts": "^2.4.2",
-        "spawnd": "^10.1.0",
+        "spawnd": "^10.1.4",
         "tree-kill": "^1.2.2",
-        "wait-on": "^7.2.0"
+        "wait-on": "^8.0.1"
       },
       "engines": {
         "node": ">=16"
@@ -5796,15 +5871,16 @@
       "dev": true
     },
     "node_modules/jest-environment-puppeteer": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/jest-environment-puppeteer/-/jest-environment-puppeteer-10.1.0.tgz",
-      "integrity": "sha512-bP1L64wGPQJMVKcH3XIw1X0R+s8VQ5yYqi/5aRFlqwXerUoop+FFlKBeGWfCxpGwo1ICpVymhP0bfV1S0yzfWA==",
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/jest-environment-puppeteer/-/jest-environment-puppeteer-10.1.4.tgz",
+      "integrity": "sha512-cx2jzf1qZb6/vdmLbRccF0k/zSsoWlrXi8bg10GzrODxiwsRomVDszTfoOCRsQ+C1sbJ+ubI1PlryIvvYjITrA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "chalk": "^4.1.2",
         "cosmiconfig": "^8.3.6",
         "deepmerge": "^4.3.1",
-        "jest-dev-server": "^10.1.0",
+        "jest-dev-server": "^10.1.4",
         "jest-environment-node": "^29.7.0"
       },
       "engines": {
@@ -6049,13 +6125,14 @@
       }
     },
     "node_modules/jest-puppeteer": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/jest-puppeteer/-/jest-puppeteer-10.1.0.tgz",
-      "integrity": "sha512-jQY3GfOq5eTi4YEHFqueQtRmOvEmkfqDJPpoU9Y16Gyo73b9xtSd3tlQz9o4pEfDQdmOeTt0FjQSVn2Ydl50ig==",
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/jest-puppeteer/-/jest-puppeteer-10.1.4.tgz",
+      "integrity": "sha512-I9bADDn9EzpaL9QgzEtyJhd29PBv45rZJFPROUC2KWZHUs+5OGjzBOZKBzmqECdGv2GV/JL+NMdjqRJde2A36Q==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "expect-puppeteer": "^10.1.0",
-        "jest-environment-puppeteer": "^10.1.0"
+        "expect-puppeteer": "^10.1.4",
+        "jest-environment-puppeteer": "^10.1.4"
       },
       "engines": {
         "node": ">=16"
@@ -6644,19 +6721,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/jsonfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
-      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "universalify": "^2.0.0"
-      },
-      "optionalDependencies": {
-        "graceful-fs": "^4.1.6"
-      }
-    },
     "node_modules/keyv": {
       "version": "4.5.4",
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -6920,15 +6984,15 @@
       }
     },
     "node_modules/mingo": {
-      "version": "6.4.15",
-      "resolved": "https://registry.npmjs.org/mingo/-/mingo-6.4.15.tgz",
-      "integrity": "sha512-fKUCGr7fUxrb7YBK6whm5O5VouXfKAVtxnb+6g3Xuwsj9Jt9u8hhMOgiUoKO4kp3DmuiN0qgpYX2H/nP3zD1Hw==",
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/mingo/-/mingo-6.5.1.tgz",
+      "integrity": "sha512-txCqo2abwgA+oG5QyzPdvv/lYdN8rptMbvVqN87Ao73vA8r2xG0XT3Rj4R5o+YeQ4hImq4PsLzqsRQ/qVyXBPw==",
       "license": "MIT"
     },
     "node_modules/mini-css-extract-plugin": {
-      "version": "2.9.1",
-      "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.1.tgz",
-      "integrity": "sha512-+Vyi+GCCOHnrJ2VPS+6aPoXN2k2jgUzDRhTFLjjTBn23qyXJXkjUWQgTL+mXpF5/A8ixLdCc6kWsoeOjKGejKQ==",
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.2.tgz",
+      "integrity": "sha512-GJuACcS//jtq4kCtd5ii/M0SZf7OZRH+BxdqXZHaJfb8TJiVl+NgQRPwiYt2EuqeSkNydn/7vP+bcE27C5mb9w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -6975,10 +7039,11 @@
       "license": "MIT"
     },
     "node_modules/ms": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
-      "dev": true
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/nanoid": {
       "version": "3.3.7",
@@ -7038,9 +7103,9 @@
       "dev": true
     },
     "node_modules/node-releases": {
-      "version": "2.0.18",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
-      "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
       "dev": true,
       "license": "MIT"
     },
@@ -7220,34 +7285,31 @@
       }
     },
     "node_modules/pac-proxy-agent": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.0.2.tgz",
-      "integrity": "sha512-BFi3vZnO9X5Qt6NRz7ZOaPja3ic0PhlsmCRYLOpN11+mWBCR6XJDqW5RF3j8jm4WGGQZtBA+bTfxYzeKW73eHg==",
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.1.0.tgz",
+      "integrity": "sha512-Z5FnLVVZSnX7WjBg0mhDtydeRZ1xMcATZThjySQUHqr+0ksP8kqaw23fNKkaaN/Z8gwLUs/W7xdl0I75eP2Xyw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@tootallnate/quickjs-emscripten": "^0.23.0",
-        "agent-base": "^7.0.2",
+        "agent-base": "^7.1.2",
         "debug": "^4.3.4",
         "get-uri": "^6.0.1",
         "http-proxy-agent": "^7.0.0",
-        "https-proxy-agent": "^7.0.5",
+        "https-proxy-agent": "^7.0.6",
         "pac-resolver": "^7.0.1",
-        "socks-proxy-agent": "^8.0.4"
+        "socks-proxy-agent": "^8.0.5"
       },
       "engines": {
         "node": ">= 14"
       }
     },
     "node_modules/pac-proxy-agent/node_modules/agent-base": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz",
-      "integrity": "sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==",
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
+      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.4"
-      },
       "engines": {
         "node": ">= 14"
       }
@@ -7267,13 +7329,13 @@
       }
     },
     "node_modules/pac-proxy-agent/node_modules/https-proxy-agent": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.5.tgz",
-      "integrity": "sha512-1e4Wqeblerz+tMKPIq2EMGiiWW1dIjZOksyHWSUm1rmuvw/how9hBHZ38lAGj5ID4Ik6EdkOw7NmWPy6LAwalw==",
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "agent-base": "^7.0.2",
+        "agent-base": "^7.1.2",
         "debug": "4"
       },
       "engines": {
@@ -7435,9 +7497,9 @@
       }
     },
     "node_modules/picocolors": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.1.tgz",
-      "integrity": "sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
       "dev": true,
       "license": "ISC"
     },
@@ -8131,34 +8193,31 @@
       }
     },
     "node_modules/proxy-agent": {
-      "version": "6.4.0",
-      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.4.0.tgz",
-      "integrity": "sha512-u0piLU+nCOHMgGjRbimiXmA9kM/L9EHh3zL81xCdp7m+Y2pHIsnmbdDoEDoAz5geaonNR6q6+yOPQs6n4T6sBQ==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+      "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "agent-base": "^7.0.2",
+        "agent-base": "^7.1.2",
         "debug": "^4.3.4",
         "http-proxy-agent": "^7.0.1",
-        "https-proxy-agent": "^7.0.3",
+        "https-proxy-agent": "^7.0.6",
         "lru-cache": "^7.14.1",
-        "pac-proxy-agent": "^7.0.1",
+        "pac-proxy-agent": "^7.1.0",
         "proxy-from-env": "^1.1.0",
-        "socks-proxy-agent": "^8.0.2"
+        "socks-proxy-agent": "^8.0.5"
       },
       "engines": {
         "node": ">= 14"
       }
     },
     "node_modules/proxy-agent/node_modules/agent-base": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz",
-      "integrity": "sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==",
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
+      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.4"
-      },
       "engines": {
         "node": ">= 14"
       }
@@ -8178,13 +8237,13 @@
       }
     },
     "node_modules/proxy-agent/node_modules/https-proxy-agent": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.5.tgz",
-      "integrity": "sha512-1e4Wqeblerz+tMKPIq2EMGiiWW1dIjZOksyHWSUm1rmuvw/how9hBHZ38lAGj5ID4Ik6EdkOw7NmWPy6LAwalw==",
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "agent-base": "^7.0.2",
+        "agent-base": "^7.1.2",
         "debug": "4"
       },
       "engines": {
@@ -8205,7 +8264,8 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
       "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/psl": {
       "version": "1.9.0",
@@ -8214,9 +8274,9 @@
       "dev": true
     },
     "node_modules/pump": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
-      "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz",
+      "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -8242,18 +8302,18 @@
       }
     },
     "node_modules/puppeteer": {
-      "version": "23.2.1",
-      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-23.2.1.tgz",
-      "integrity": "sha512-IvJOBP2APjcIR2k0xKYYpAs/hAa39e6sn7y+qMlSWJDRraEc4JLfgCKlkXopzD5jrSc1iTANHWw7Rrj/w7bgpw==",
+      "version": "23.10.4",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-23.10.4.tgz",
+      "integrity": "sha512-i0sYIAIjdO9MoRfFqbkoWFnQYZVmNp8msbztTgG46KbOdoYAv4f56MFzdFwtC0lyZHtkP+yl0H7tP0dNg3RQYA==",
       "dev": true,
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.3.1",
-        "chromium-bidi": "0.6.4",
+        "@puppeteer/browsers": "2.6.1",
+        "chromium-bidi": "0.8.0",
         "cosmiconfig": "^9.0.0",
-        "devtools-protocol": "0.0.1330662",
-        "puppeteer-core": "23.2.1",
+        "devtools-protocol": "0.0.1367902",
+        "puppeteer-core": "23.10.4",
         "typed-query-selector": "^2.12.0"
       },
       "bin": {
@@ -8264,16 +8324,16 @@
       }
     },
     "node_modules/puppeteer-core": {
-      "version": "23.2.1",
-      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-23.2.1.tgz",
-      "integrity": "sha512-AIFWfQ4Sq+En+OgqIUy8VJmD8yJHMDyt+qEmEVKW07zu5DKDNqysO7fzBZp0W85ShJTUlUf+RleKl4XLwFpUPA==",
+      "version": "23.10.4",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-23.10.4.tgz",
+      "integrity": "sha512-pQAY7+IFAndWDkDodsQGguW1/ifV5OMlGXJDspwtK49Asb7poJZ/V5rXJxVSpq57bWrJasjQBZ1X27z1oWVq4Q==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@puppeteer/browsers": "2.3.1",
-        "chromium-bidi": "0.6.4",
-        "debug": "^4.3.6",
-        "devtools-protocol": "0.0.1330662",
+        "@puppeteer/browsers": "2.6.1",
+        "chromium-bidi": "0.8.0",
+        "debug": "^4.4.0",
+        "devtools-protocol": "0.0.1367902",
         "typed-query-selector": "^2.12.0",
         "ws": "^8.18.0"
       },
@@ -8781,13 +8841,13 @@
       }
     },
     "node_modules/socks-proxy-agent": {
-      "version": "8.0.4",
-      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.4.tgz",
-      "integrity": "sha512-GNAq/eg8Udq2x0eNiFkr9gRg5bA7PXEWagQdeRX4cPSG+X/8V38v637gim9bjFptMk1QWsCTr0ttrJEiXbNnRw==",
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "agent-base": "^7.1.1",
+        "agent-base": "^7.1.2",
         "debug": "^4.3.4",
         "socks": "^2.8.3"
       },
@@ -8796,14 +8856,11 @@
       }
     },
     "node_modules/socks-proxy-agent/node_modules/agent-base": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz",
-      "integrity": "sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==",
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
+      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.4"
-      },
       "engines": {
         "node": ">= 14"
       }
@@ -8838,10 +8895,11 @@
       }
     },
     "node_modules/spawnd": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/spawnd/-/spawnd-10.1.0.tgz",
-      "integrity": "sha512-QeRBuEIUVPHQ908BoyeiLw+MyB78vztbzH+C+Gfd4OfFTLE1PBPqhyN8smkct4esF+uyDr+TZ9mCwZPcQ1krhA==",
+      "version": "10.1.4",
+      "resolved": "https://registry.npmjs.org/spawnd/-/spawnd-10.1.4.tgz",
+      "integrity": "sha512-drqHc0mKJmtMsiGMOCwzlc5eZ0RPtRvT7tQAluW2A0qUc0G7TQ8KLcn3E6K5qzkLkH2UkS3nYQiVGULvvsD9dw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "signal-exit": "^4.1.0",
         "tree-kill": "^1.2.2"
@@ -8903,9 +8961,9 @@
       }
     },
     "node_modules/streamx": {
-      "version": "2.20.0",
-      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.20.0.tgz",
-      "integrity": "sha512-ZGd1LhDeGFucr1CUCTBOS58ZhEendd0ttpGT3usTvosS4ntIwKN9LJFp+OeCSprsCPL14BXVRZlHGRY1V9PVzQ==",
+      "version": "2.21.1",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.21.1.tgz",
+      "integrity": "sha512-PhP9wUnFLa+91CPy3N6tiQsK+gnYyUNuk15S3YG/zjYE7RuPeCjJngqnzpC31ow0lzBHQ+QGO4cNJnd0djYUsw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -9345,21 +9403,15 @@
       }
     },
     "node_modules/text-decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.1.1.tgz",
-      "integrity": "sha512-8zll7REEv4GDD3x4/0pW+ppIxSNs7H1J10IKFZsuOMscumCdM2a+toDGLPA3T+1+fLBql4zbt5z83GEQGGV5VA==",
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "b4a": "^1.6.4"
       }
     },
-    "node_modules/text-table": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
-      "dev": true
-    },
     "node_modules/through": {
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
@@ -9557,20 +9609,10 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/universalify": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
-      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.0.0"
-      }
-    },
     "node_modules/update-browserslist-db": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-      "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
+      "integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
       "dev": true,
       "funding": [
         {
@@ -9588,8 +9630,8 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "escalade": "^3.1.2",
-        "picocolors": "^1.0.1"
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.0"
       },
       "bin": {
         "update-browserslist-db": "cli.js"
@@ -9631,9 +9673,9 @@
       "dev": true
     },
     "node_modules/uuid": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
-      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
       "dev": true,
       "funding": [
         "https://github.com/sponsors/broofa",
@@ -9677,14 +9719,14 @@
       }
     },
     "node_modules/wait-on": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/wait-on/-/wait-on-7.2.0.tgz",
-      "integrity": "sha512-wCQcHkRazgjG5XoAq9jbTMLpNIjoSlZslrJ2+N9MxDsGEv1HnFoVjOCexL0ESva7Y9cu350j+DWADdk54s4AFQ==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/wait-on/-/wait-on-8.0.1.tgz",
+      "integrity": "sha512-1wWQOyR2LVVtaqrcIL2+OM+x7bkpmzVROa0Nf6FryXkS+er5Sa1kzFGjzZRqLnHa3n1rACFLeTwUqE1ETL9Mig==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "axios": "^1.6.1",
-        "joi": "^17.11.0",
+        "axios": "^1.7.7",
+        "joi": "^17.13.3",
         "lodash": "^4.17.21",
         "minimist": "^1.2.8",
         "rxjs": "^7.8.1"
@@ -9728,18 +9770,19 @@
       }
     },
     "node_modules/webpack": {
-      "version": "5.94.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
-      "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
-      "dev": true,
-      "dependencies": {
-        "@types/estree": "^1.0.5",
-        "@webassemblyjs/ast": "^1.12.1",
-        "@webassemblyjs/wasm-edit": "^1.12.1",
-        "@webassemblyjs/wasm-parser": "^1.12.1",
-        "acorn": "^8.7.1",
-        "acorn-import-attributes": "^1.9.5",
-        "browserslist": "^4.21.10",
+      "version": "5.97.1",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.97.1.tgz",
+      "integrity": "sha512-EksG6gFY3L1eFMROS/7Wzgrii5mBAFe4rIr3r2BTfo7bcc+DWwFZ4OJ/miOuHJO/A85HwyI4eQ0F6IKXesO7Fg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/eslint-scope": "^3.7.7",
+        "@types/estree": "^1.0.6",
+        "@webassemblyjs/ast": "^1.14.1",
+        "@webassemblyjs/wasm-edit": "^1.14.1",
+        "@webassemblyjs/wasm-parser": "^1.14.1",
+        "acorn": "^8.14.0",
+        "browserslist": "^4.24.0",
         "chrome-trace-event": "^1.0.2",
         "enhanced-resolve": "^5.17.1",
         "es-module-lexer": "^1.2.1",
diff --git a/package.json b/package.json
index 2276cfc5..5cd5f6d8 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": "https://github.com/videlais/snowman/",
   "scripts": {
-    "test": "jest --coverage",
+    "test": "jest test/jsdom/* --coverage",
     "lint": "eslint src/*.js test/*.js --fix",
     "build": "webpack",
     "package": "npm run build && node build-format.js",
@@ -21,32 +21,32 @@
     "ejs": "^3.1.10",
     "jquery": "^3.7.1",
     "markdown-it": "^14.1.0",
-    "mingo": "^6.4.15",
+    "mingo": "^6.5.1",
     "normalize.css": "^8.0.1",
     "underscore": "^1.13.7"
   },
   "devDependencies": {
-    "@eslint/js": "^9.9.1",
+    "@eslint/js": "^9.17.0",
     "@types/expect-puppeteer": "^5.0.6",
     "@types/jest-environment-puppeteer": "^5.0.6",
     "@types/puppeteer": "^7.0.4",
     "css-loader": "^7.1.2",
     "css-minimizer-webpack-plugin": "^7.0.0",
-    "eslint": "^9.9.1",
-    "eslint-plugin-jest": "^28.8.2",
-    "eslint-plugin-jsdoc": "^50.2.2",
-    "extwee": "^2.2.3",
-    "globals": "^15.9.0",
+    "eslint": "^9.17.0",
+    "eslint-plugin-jest": "^28.9.0",
+    "eslint-plugin-jsdoc": "^50.6.1",
+    "extwee": "^2.2.4",
+    "globals": "^15.13.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "jest-puppeteer": "^10.1.0",
-    "mini-css-extract-plugin": "^2.9.1",
+    "jest-puppeteer": "^10.1.4",
+    "mini-css-extract-plugin": "^2.9.2",
     "open": "^10.1.0",
     "open-cli": "^8.0.0",
-    "puppeteer": "^23.2.1",
+    "puppeteer": "^23.10.4",
     "shelljs": "^0.8.5",
     "style-loader": "^4.0.0",
-    "webpack": "^5.94.0",
+    "webpack": "^5.97.1",
     "webpack-cli": "^5.1.4"
   }
 }
diff --git a/src/Storage.js b/src/Storage.js
index c90ad42b..a7b3eb22 100644
--- a/src/Storage.js
+++ b/src/Storage.js
@@ -92,9 +92,8 @@ class Storage {
       window.localStorage.setItem('testKey', 'test');
       window.localStorage.removeItem('testKey');
       result = true;
-    } finally {
-      // If an error was thrown, we do nothing.
-      // The method will return false if it did not work.
+    } catch(error) {
+      console.info('Info: localStorage is not available. Error:', error);
     }
 
     // Return result
diff --git a/src/Storylets.js b/src/Storylets.js
index e348697f..cc18c2ec 100644
--- a/src/Storylets.js
+++ b/src/Storylets.js
@@ -30,7 +30,8 @@ class Storylets {
           try {
             // Try to parse string into object
             passageRequirements = JSON.parse(captured);
-          } finally {
+          } catch (error) {
+            console.info('INFO: Failed to parse passage requirements. Error:', error);
             // Ignore the error
           }
 
diff --git a/test/setup.js b/test/setup.js
index 536e360a..9a3dd2c8 100644
--- a/test/setup.js
+++ b/test/setup.js
@@ -1,3 +1,3 @@
-const { jest } = require('@jest/globals');
+//const { jest } = require('@jest/globals');
 
-global.jest = jest;
\ No newline at end of file
+//global.jest = jest;
\ No newline at end of file