diff --git a/.github/workflows/test_build.yml b/.github/workflows/test_build.yml new file mode 100644 index 00000000..2241c6c8 --- /dev/null +++ b/.github/workflows/test_build.yml @@ -0,0 +1,42 @@ +# This is a basic workflow to help you get started with Actions + +name: test_build + +# Controls when the action will run. +on: + # Triggers the workflow on push or pull request events but only for the main branch + push: + branches: [dev, develop ] + # pull_request: + # branches: [ main ] + + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "build" + build: + # The type of runner that the job will run on + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.8", "3.9", "3.10"] + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it + - uses: actions/checkout@v2 + + # Runs a set of commands using the runners shell + - name: build doc test + run: | + pip3 install setuptools + pip3 install teedoc + ls -al ~/.local/bin/ + export PATH=~/.local/bin/:$PATH + teedoc install + teedoc build + out_dir=out`python3 -c 'import json; f=open("site_config.json");config=json.load(f);print(config["site_root_url"])'` + echo "out dir: ${out_dir}" + echo "test build complte" diff --git a/docs/hardware/assets/maixface/mf0/mf0_back.jpg b/docs/hardware/assets/maixface/mf0/mf0_back.jpg new file mode 100644 index 00000000..9d48b1bf Binary files /dev/null and b/docs/hardware/assets/maixface/mf0/mf0_back.jpg differ diff --git a/docs/hardware/assets/maixface/mf0/mf0_front.jpg b/docs/hardware/assets/maixface/mf0/mf0_front.jpg new file mode 100644 index 00000000..e33a9f56 Binary files /dev/null and b/docs/hardware/assets/maixface/mf0/mf0_front.jpg differ diff --git a/docs/hardware/assets/maixface/mf1/mf1.jpg b/docs/hardware/assets/maixface/mf1/mf1.jpg new file mode 100644 index 00000000..45b7c949 Binary files /dev/null and b/docs/hardware/assets/maixface/mf1/mf1.jpg differ diff --git a/docs/hardware/assets/maixface/mf1/mf1_front.jpg b/docs/hardware/assets/maixface/mf1/mf1_front.jpg new file mode 100644 index 00000000..0736e78d Binary files /dev/null and b/docs/hardware/assets/maixface/mf1/mf1_front.jpg differ diff --git a/docs/hardware/assets/maixface/mf1/mf1_front_led.jpg b/docs/hardware/assets/maixface/mf1/mf1_front_led.jpg new file mode 100644 index 00000000..c2484bac Binary files /dev/null and b/docs/hardware/assets/maixface/mf1/mf1_front_led.jpg differ diff --git a/docs/hardware/assets/maixface/mf5/mf5.jpg b/docs/hardware/assets/maixface/mf5/mf5.jpg new file mode 100644 index 00000000..bdee5916 Binary files /dev/null and b/docs/hardware/assets/maixface/mf5/mf5.jpg differ diff --git a/docs/hardware/assets/maixface/mf5/mf5_black_background.jpg.jpg b/docs/hardware/assets/maixface/mf5/mf5_black_background.jpg.jpg new file mode 100644 index 00000000..e04c83ec Binary files /dev/null and b/docs/hardware/assets/maixface/mf5/mf5_black_background.jpg.jpg differ diff --git a/docs/hardware/assets/maixface/mf5/mf5_white_background.jpg b/docs/hardware/assets/maixface/mf5/mf5_white_background.jpg new file mode 100644 index 00000000..fef4364c Binary files /dev/null and b/docs/hardware/assets/maixface/mf5/mf5_white_background.jpg differ diff --git a/layout/home.html b/layout/home.html index f31de176..bf4c7661 100644 --- a/layout/home.html +++ b/layout/home.html @@ -1,562 +1,959 @@ - + {% extends "page_base.html" %} -{% extends "page_base.html" %} + {% block content %} + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + {[ $t(product.rbtn_text) ]} + + + + + + + + + + + + + +
+ + -{% block content %} - - + {{ body|safe }} -
-

{[ $t("Sipeed Wiki") ]}

- -
-
-
x
-
-
-
-
-
- - -{{ body|safe }} - -{% endblock%} + {% endblock%} \ No newline at end of file diff --git a/static/home/maixpy.jpeg b/static/home/maixpy.jpeg new file mode 100644 index 00000000..54fd0e33 Binary files /dev/null and b/static/home/maixpy.jpeg differ diff --git a/static/home/maixpy3.jpeg b/static/home/maixpy3.jpeg new file mode 100644 index 00000000..622310c4 Binary files /dev/null and b/static/home/maixpy3.jpeg differ diff --git a/static/home/maixpy_scripts.png b/static/home/maixpy_scripts.png new file mode 100644 index 00000000..9e10dceb Binary files /dev/null and b/static/home/maixpy_scripts.png differ diff --git a/static/js/naive-ui.js b/static/js/naive-ui.js new file mode 100644 index 00000000..ada41726 --- /dev/null +++ b/static/js/naive-ui.js @@ -0,0 +1,104102 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) : + typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.naive = {}, global.Vue)); +})(this, (function (exports, vue) { 'use strict'; + + let onceCbs = []; + const paramsMap = new WeakMap(); + + function flushOnceCallbacks() { + onceCbs.forEach(cb => cb(...paramsMap.get(cb))); + onceCbs = []; + } + + function beforeNextFrameOnce(cb) { + for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + params[_key - 1] = arguments[_key]; + } + + paramsMap.set(cb, params); + if (onceCbs.includes(cb)) return; + onceCbs.push(cb) === 1 && requestAnimationFrame(flushOnceCallbacks); + } + + function getParentNode$1(node) { + // document type + if (node.nodeType === 9) { + return null; + } + + return node.parentNode; + } + + function getScrollParent$1(node) { + if (node === null) return null; + const parentNode = getParentNode$1(node); + + if (parentNode === null) { + return null; + } // Document + + + if (parentNode.nodeType === 9) { + return document.documentElement; + } // Element + + + if (parentNode.nodeType === 1) { + // Firefox want us to check `-x` and `-y` variations as well + const { + overflow, + overflowX, + overflowY + } = getComputedStyle(parentNode); + + if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { + return parentNode; + } + } + + return getScrollParent$1(parentNode); + } + + function unwrapElement(target) { + if (typeof target === 'string') return document.querySelector(target); + if (typeof target === 'function') return target(); + return target; + } + + function happensIn(e, dataSetPropName) { + let { + target + } = e; + + while (target) { + if (target.dataset) { + if (target.dataset[dataSetPropName] !== undefined) return true; + } + + target = target.parentElement; + } + + return false; + } + + function getPreciseEventTarget(event) { + return event.composedPath()[0] || null; + } + + function parseResponsiveProp(reponsiveProp) { + if (typeof reponsiveProp === "number") { + return { + '': reponsiveProp.toString() + }; + } + + const params = {}; + reponsiveProp.split(/ +/).forEach(pairLiteral => { + if (pairLiteral === '') return; + const [prefix, value] = pairLiteral.split(':'); + + if (value === undefined) { + params[''] = prefix; + } else { + params[prefix] = value; + } + }); + return params; + } + + function parseResponsivePropValue(reponsiveProp, activeKeyOrSize) { + var _a; + + if (reponsiveProp === undefined || reponsiveProp === null) return undefined; + const classObj = parseResponsiveProp(reponsiveProp); + if (activeKeyOrSize === undefined) return classObj['']; + + if (typeof activeKeyOrSize === 'string') { + return (_a = classObj[activeKeyOrSize]) !== null && _a !== void 0 ? _a : classObj['']; + } else if (Array.isArray(activeKeyOrSize)) { + for (let i = activeKeyOrSize.length - 1; i >= 0; --i) { + const key = activeKeyOrSize[i]; + if (key in classObj) return classObj[key]; + } + + return classObj['']; + } else { + // Here we suppose all the keys are number formatted + let activeValue = undefined; + let activeKey = -1; + Object.keys(classObj).forEach(key => { + const keyAsNum = Number(key); + + if (!Number.isNaN(keyAsNum) && activeKeyOrSize >= keyAsNum && keyAsNum >= activeKey) { + activeKey = keyAsNum; + activeValue = classObj[key]; + } + }); + return activeValue; + } + } + + function depx(value) { + if (typeof value === 'string') { + if (value.endsWith('px')) { + return Number(value.slice(0, value.length - 2)); + } + + return Number(value); + } + + return value; + } + + function pxfy(value) { + if (value === undefined || value === null) return undefined; + if (typeof value === 'number') return `${value}px`; + if (value.endsWith('px')) return value; + return `${value}px`; + } + + function getMargin(value, position) { + const parts = value.trim().split(/\s+/g); + const margin = { + top: parts[0] + }; + + switch (parts.length) { + case 1: + margin.right = parts[0]; + margin.bottom = parts[0]; + margin.left = parts[0]; + break; + + case 2: + margin.right = parts[1]; + margin.left = parts[1]; + margin.bottom = parts[0]; + break; + + case 3: + margin.right = parts[1]; + margin.bottom = parts[2]; + margin.left = parts[1]; + break; + + case 4: + margin.right = parts[1]; + margin.bottom = parts[2]; + margin.left = parts[3]; + break; + + default: + throw new Error('[seemly/getMargin]:' + value + ' is not a valid value.'); + } + + if (position === undefined) return margin; + return margin[position]; + } + + function getGap(value, orient) { + const [rowGap, colGap] = value.split(' '); + if (!orient) return { + row: rowGap, + col: colGap || rowGap + }; + return orient === 'row' ? rowGap : colGap; + } + + var colors = { + black: '#000', + silver: '#C0C0C0', + gray: '#808080', + white: '#FFF', + maroon: '#800000', + red: '#F00', + purple: '#800080', + fuchsia: '#F0F', + green: '#008000', + lime: '#0F0', + olive: '#808000', + yellow: '#FF0', + navy: '#000080', + blue: '#00F', + teal: '#008080', + aqua: '#0FF', + transparent: '#0000' + }; + + // All the algorithms credit to https://stackoverflow.com/questions/36721830/convert-hsl-to-rgb-and-hex/54014428#54014428 + // original author: Kamil Kiełczewski + + /** + * @param h 360 + * @param s 100 + * @param l 100 + * @returns [h, s, v] 360, 100, 100 + */ + function hsl2hsv(h, s, l) { + s /= 100; + l /= 100; + const v = s * Math.min(l, 1 - l) + l; + return [h, v ? (2 - 2 * l / v) * 100 : 0, v * 100]; + } + /** + * @param h 360 + * @param s 100 + * @param v 100 + * @returns [h, s, l] 360, 100, 100 + */ + + function hsv2hsl(h, s, v) { + s /= 100; + v /= 100; + const l = v - v * s / 2; + const m = Math.min(l, 1 - l); + return [h, m ? (v - l) / m * 100 : 0, l * 100]; + } + /** + * @param h 360 + * @param s 100 + * @param v 100 + * @returns [r, g, b] 255, 255, 255 + */ + + function hsv2rgb(h, s, v) { + s /= 100; + v /= 100; + + let f = function (n) { + let k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 60) % 6; + return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0); + }; + + return [f(5) * 255, f(3) * 255, f(1) * 255]; + } + /** + * @param r 255 + * @param g 255 + * @param b 255 + * @returns [360, 100, 100] + */ + + function rgb2hsv(r, g, b) { + r /= 255; + g /= 255; + b /= 255; + let v = Math.max(r, g, b), + c = v - Math.min(r, g, b); + let h = c && (v == r ? (g - b) / c : v == g ? 2 + (b - r) / c : 4 + (r - g) / c); + return [60 * (h < 0 ? h + 6 : h), v && c / v * 100, v * 100]; + } + /** + * @param r 255 + * @param g 255 + * @param b 255 + * @returns [360, 100, 100] + */ + + function rgb2hsl(r, g, b) { + r /= 255; + g /= 255; + b /= 255; + let v = Math.max(r, g, b), + c = v - Math.min(r, g, b), + f = 1 - Math.abs(v + v - c - 1); + let h = c && (v == r ? (g - b) / c : v == g ? 2 + (b - r) / c : 4 + (r - g) / c); + return [60 * (h < 0 ? h + 6 : h), f ? c / f * 100 : 0, (v + v - c) * 50]; + } + /** + * @param h 360 + * @param s 100 + * @param l 100 + * @returns [255, 255, 255] + */ + + function hsl2rgb(h, s, l) { + s /= 100; + l /= 100; + let a = s * Math.min(l, 1 - l); + + let f = function (n) { + let k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 30) % 12; + return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1); + }; + + return [f(0) * 255, f(8) * 255, f(4) * 255]; + } + + const prefix$1 = '^\\s*'; + const suffix = '\\s*$'; + const percent = '\\s*((\\.\\d+)|(\\d+(\\.\\d*)?))%\\s*'; // 4 offset + + const float = '\\s*((\\.\\d+)|(\\d+(\\.\\d*)?))\\s*'; // 4 offset + + const hex = '([0-9A-Fa-f])'; + const dhex = '([0-9A-Fa-f]{2})'; + const hslRegex = new RegExp(`${prefix$1}hsl\\s*\\(${float},${percent},${percent}\\)${suffix}`); + const hsvRegex = new RegExp(`${prefix$1}hsv\\s*\\(${float},${percent},${percent}\\)${suffix}`); + const hslaRegex = new RegExp(`${prefix$1}hsla\\s*\\(${float},${percent},${percent},${float}\\)${suffix}`); + const hsvaRegex = new RegExp(`${prefix$1}hsva\\s*\\(${float},${percent},${percent},${float}\\)${suffix}`); + const rgbRegex = new RegExp(`${prefix$1}rgb\\s*\\(${float},${float},${float}\\)${suffix}`); + const rgbaRegex = new RegExp(`${prefix$1}rgba\\s*\\(${float},${float},${float},${float}\\)${suffix}`); + const sHexRegex = new RegExp(`${prefix$1}#${hex}${hex}${hex}${suffix}`); + const hexRegex = new RegExp(`${prefix$1}#${dhex}${dhex}${dhex}${suffix}`); + const sHexaRegex = new RegExp(`${prefix$1}#${hex}${hex}${hex}${hex}${suffix}`); + const hexaRegex = new RegExp(`${prefix$1}#${dhex}${dhex}${dhex}${dhex}${suffix}`); + + function parseHex(value) { + return parseInt(value, 16); + } + /** + * Convert color string to hsla array + * @param color format like hsl(180, 100%, 100%), hsla(180, 100%, 100%, 1) + * @returns + */ + + + function hsla(color) { + try { + let i; + + if (i = hslaRegex.exec(color)) { + return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), roundAlpha(i[13])]; + } else if (i = hslRegex.exec(color)) { + return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1]; + } + + throw new Error(`[seemly/hsla]: Invalid color value ${color}.`); + } catch (e) { + throw e; + } + } + /** + * Convert color string to hsva array + * @param color format like hsv(180, 100%, 100%), hsva(180, 100%, 100%, 1) + * @returns + */ + + function hsva(color) { + try { + let i; + + if (i = hsvaRegex.exec(color)) { + return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), roundAlpha(i[13])]; + } else if (i = hsvRegex.exec(color)) { + return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1]; + } + + throw new Error(`[seemly/hsva]: Invalid color value ${color}.`); + } catch (e) { + throw e; + } + } + /** + * Convert color string to rgba array. + * @param color format like #000[0], #000000[00], rgb(0, 0, 0), rgba(0, 0, 0, 0) and basic color keywords https://www.w3.org/TR/css-color-3/#html4 and transparent + * @returns + */ + + function rgba(color) { + try { + let i; + + if (i = hexRegex.exec(color)) { + return [parseHex(i[1]), parseHex(i[2]), parseHex(i[3]), 1]; + } else if (i = rgbRegex.exec(color)) { + return [roundChannel(i[1]), roundChannel(i[5]), roundChannel(i[9]), 1]; + } else if (i = rgbaRegex.exec(color)) { + return [roundChannel(i[1]), roundChannel(i[5]), roundChannel(i[9]), roundAlpha(i[13])]; + } else if (i = sHexRegex.exec(color)) { + return [parseHex(i[1] + i[1]), parseHex(i[2] + i[2]), parseHex(i[3] + i[3]), 1]; + } else if (i = hexaRegex.exec(color)) { + return [parseHex(i[1]), parseHex(i[2]), parseHex(i[3]), roundAlpha(parseHex(i[4]) / 255)]; + } else if (i = sHexaRegex.exec(color)) { + return [parseHex(i[1] + i[1]), parseHex(i[2] + i[2]), parseHex(i[3] + i[3]), roundAlpha(parseHex(i[4] + i[4]) / 255)]; + } else if (color in colors) { + return rgba(colors[color]); + } + + throw new Error(`[seemly/rgba]: Invalid color value ${color}.`); + } catch (e) { + throw e; + } + } + + function normalizeAlpha$1(alphaValue) { + return alphaValue > 1 ? 1 : alphaValue < 0 ? 0 : alphaValue; + } + + function stringifyRgb(r, g, b) { + return `rgb(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)})`; + } + + function stringifyRgba(r, g, b, a) { + return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, ${normalizeAlpha$1(a)})`; + } + + function compositeChannel(v1, a1, v2, a2, a) { + return roundChannel((v1 * a1 * (1 - a2) + v2 * a2) / a); + } + + function composite(background, overlay) { + if (!Array.isArray(background)) background = rgba(background); + if (!Array.isArray(overlay)) overlay = rgba(overlay); + const a1 = background[3]; + const a2 = overlay[3]; + const alpha = roundAlpha(a1 + a2 - a1 * a2); + return stringifyRgba(compositeChannel(background[0], a1, overlay[0], a2, alpha), compositeChannel(background[1], a1, overlay[1], a2, alpha), compositeChannel(background[2], a1, overlay[2], a2, alpha), alpha); + } + function changeColor(base, options) { + const [r, g, b, a = 1] = Array.isArray(base) ? base : rgba(base); + + if (options.alpha) { + return stringifyRgba(r, g, b, options.alpha); + } + + return stringifyRgba(r, g, b, a); + } + function scaleColor(base, options) { + const [r, g, b, a = 1] = Array.isArray(base) ? base : rgba(base); + const { + lightness = 1, + alpha = 1 + } = options; + return toRgbaString([r * lightness, g * lightness, b * lightness, a * alpha]); + } + function roundAlpha(value) { + const v = Math.round(Number(value) * 100) / 100; + if (v > 1) return 1; + if (v < 0) return 0; + return v; + } + function roundDeg(value) { + const v = Math.round(Number(value)); + if (v >= 360) return 0; + if (v < 0) return 0; + return v; + } + function roundChannel(value) { + const v = Math.round(Number(value)); + if (v > 255) return 255; + if (v < 0) return 0; + return v; + } + function roundPercent(value) { + const v = Math.round(Number(value)); + if (v > 100) return 100; + if (v < 0) return 0; + return v; + } + function toRgbString(base) { + const [r, g, b] = Array.isArray(base) ? base : rgba(base); + return stringifyRgb(r, g, b); + } + function toRgbaString(base) { + const [r, g, b] = base; + + if (3 in base) { + return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, ${roundAlpha(base[3])})`; + } + + return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, 1)`; + } + function toHsvString(base) { + return `hsv(${roundDeg(base[0])}, ${roundPercent(base[1])}%, ${roundPercent(base[2])}%)`; + } + function toHsvaString(base) { + const [h, s, v] = base; + + if (3 in base) { + return `hsva(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(v)}%, ${roundAlpha(base[3])})`; + } + + return `hsva(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(v)}%, 1)`; + } + function toHslString(base) { + return `hsl(${roundDeg(base[0])}, ${roundPercent(base[1])}%, ${roundPercent(base[2])}%)`; + } + function toHslaString(base) { + const [h, s, l] = base; + + if (3 in base) { + return `hsla(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(l)}%, ${roundAlpha(base[3])})`; + } + + return `hsla(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(l)}%, 1)`; + } + /** + * + * @param base [255, 255, 255, 255], [255, 255, 255], any hex string + * @returns + */ + + function toHexaString(base) { + if (typeof base === 'string') { + let i; + + if (i = hexRegex.exec(base)) { + return `${i[0]}FF`; + } else if (i = hexaRegex.exec(base)) { + return i[0]; + } else if (i = sHexRegex.exec(base)) { + return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}FF`; + } else if (i = sHexaRegex.exec(base)) { + return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}${i[4]}${i[4]}`; + } + + throw new Error(`[seemly/toHexString]: Invalid hex value ${base}.`); + } + + const hex = `#${base.slice(0, 3).map(unit => roundChannel(unit).toString(16).toUpperCase().padStart(2, '0')).join('')}`; + const a = base.length === 3 ? 'FF' : roundChannel(base[3] * 255).toString(16).padStart(2, '0').toUpperCase(); + return hex + a; + } + /** + * + * @param base [255, 255, 255, 255], [255, 255, 255], any hex string + * @returns + */ + + function toHexString(base) { + if (typeof base === 'string') { + let i; + + if (i = hexRegex.exec(base)) { + return i[0]; + } else if (i = hexaRegex.exec(base)) { + return i[0].slice(0, 7); + } else if (i = sHexRegex.exec(base) || sHexaRegex.exec(base)) { + return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}`; + } + + throw new Error(`[seemly/toHexString]: Invalid hex value ${base}.`); + } + + return `#${base.slice(0, 3).map(unit => roundChannel(unit).toString(16).toUpperCase().padStart(2, '0')).join('')}`; + } + + function createId() { + let length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 8; + return Math.random().toString(16).slice(2, 2 + length); + } + function repeat(count, v) { + const ret = []; + + for (let i = 0; i < count; ++i) { + ret.push(v); + } + + return ret; + } + + function indexMap(count, createValue) { + const ret = []; + + if (!createValue) { + for (let i = 0; i < count; ++i) { + ret.push(i); + } + + return ret; + } + + for (let i = 0; i < count; ++i) { + ret.push(createValue(i)); + } + + return ret; + } + + function getSlot$1(instance) { + let slotName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default"; + let fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + const slots = instance.$slots; + const slot = slots[slotName]; + if (slot === void 0) return fallback; + return slot(); + } + + function getVNodeChildren(vNode) { + let slotName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default"; + let fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + const { + children + } = vNode; + + if (children !== null && typeof children === "object" && !Array.isArray(children)) { + const slot = children[slotName]; + + if (typeof slot === "function") { + return slot(); + } + } + + return fallback; + } + + function keep(object) { + let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + let rest = arguments.length > 2 ? arguments[2] : undefined; + const keepedObject = {}; + keys.forEach(key => { + keepedObject[key] = object[key]; + }); + return Object.assign(keepedObject, rest); + } + + function omit(object) { + let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + let rest = arguments.length > 2 ? arguments[2] : undefined; + const omitedObject = {}; + const originalKeys = Object.getOwnPropertyNames(object); + originalKeys.forEach(originalKey => { + if (!keys.includes(originalKey)) { + omitedObject[originalKey] = object[originalKey]; + } + }); + return Object.assign(omitedObject, rest); + } + + function flatten$3(vNodes) { + let filterCommentNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + let result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + vNodes.forEach(vNode => { + if (vNode === null) return; + + if (typeof vNode !== "object") { + if (typeof vNode === "string" || typeof vNode === "number") { + result.push(vue.createTextVNode(String(vNode))); + } + + return; + } + + if (Array.isArray(vNode)) { + flatten$3(vNode, filterCommentNode, result); + return; + } + + if (vNode.type === vue.Fragment) { + if (vNode.children === null) return; + + if (Array.isArray(vNode.children)) { + flatten$3(vNode.children, filterCommentNode, result); + } + } else if (vNode.type !== vue.Comment) { + result.push(vNode); + } + }); + return result; + } + + function call(funcs) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + if (Array.isArray(funcs)) { + funcs.forEach(func => call(func, ...args)); + } else return funcs(...args); + } + + function keysOf(obj) { + return Object.keys(obj); + } + + const render$1 = function (r) { + if (typeof r === "function") { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return r(...args); + } else if (typeof r === "string") { + return vue.createTextVNode(r); + } else if (typeof r === "number") { + return vue.createTextVNode(String(r)); + } else { + return null; + } + }; + + const warnedMessages = /* @__PURE__ */new Set(); + function warnOnce(location, message) { + const mergedMessage = `[naive/${location}]: ${message}`; + if (warnedMessages.has(mergedMessage)) return; + warnedMessages.add(mergedMessage); + console.error(mergedMessage); + } + function warn$2(location, message) { + console.error(`[naive/${location}]: ${message}`); + } + function throwError(location, message) { + throw new Error(`[naive/${location}]: ${message}`); + } + + function smallerSize(size) { + switch (size) { + case "tiny": + return "mini"; + + case "small": + return "tiny"; + + case "medium": + return "small"; + + case "large": + return "medium"; + + case "huge": + return "large"; + } + + throw Error(`${size} has no smaller size.`); + } + + function getTitleAttribute(value) { + switch (typeof value) { + case "string": + return value || void 0; + + case "number": + return String(value); + + default: + return void 0; + } + } + + function getFirstSlotVNode(slots) { + let slotName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default"; + let props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : void 0; + const slot = slots[slotName]; + + if (!slot) { + warn$2("getFirstSlotVNode", `slot[${slotName}] is empty`); + return null; + } + + const slotContent = flatten$3(slot(props)); + + if (slotContent.length === 1) { + return slotContent[0]; + } else { + warn$2("getFirstSlotVNode", `slot[${slotName}] should have exactly one child`); + return null; + } + } + + function createDataKey(key) { + return typeof key === "string" ? `s-${key}` : `n-${key}`; + } + + function createRefSetter(ref) { + return inst => { + if (inst) { + ref.value = inst.$el; + } else { + ref.value = null; + } + }; + } + + function createInjectionKey(key) { + return key; + } + + function ensureValidVNode(vnodes) { + return vnodes.some(child => { + if (!vue.isVNode(child)) { + return true; + } + + if (child.type === vue.Comment) { + return false; + } + + if (child.type === vue.Fragment && !ensureValidVNode(child.children)) { + return false; + } + + return true; + }) ? vnodes : null; + } + + function resolveSlot(slot, fallback) { + return slot && ensureValidVNode(slot()) || fallback(); + } + function resolveSlotWithProps(slot, props, fallback) { + return slot && ensureValidVNode(slot(props)) || fallback(props); + } + function resolveWrappedSlot(slot, wrapper) { + const children = slot && ensureValidVNode(slot()); + return wrapper(children || null); + } + function isSlotEmpty(slot) { + return !(slot && ensureValidVNode(slot())); + } + + function mergeEventHandlers(handlers) { + const filteredHandlers = handlers.filter(handler => handler !== void 0); + if (filteredHandlers.length === 0) return void 0; + if (filteredHandlers.length === 1) return filteredHandlers[0]; + return e => { + handlers.forEach(handler => { + if (handler) { + handler(e); + } + }); + }; + } + + function isNodeVShowFalse(vNode) { + var _vNode$dirs; + + const showDir = (_vNode$dirs = vNode.dirs) === null || _vNode$dirs === void 0 ? void 0 : _vNode$dirs.find(_ref => { + let { + dir + } = _ref; + return dir === vue.vShow; + }); + return !!(showDir && showDir.value === false); + } + + const Wrapper = vue.defineComponent({ + render() { + return this.$slots.default?.(); + } + }); + + const pureNumberRegex = /^(\d|\.)+$/; + const numberRegex = /(\d|\.)+/; + function formatLength(length) { + let { + c = 1, + offset = 0, + attachPx = true + } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (typeof length === "number") { + const result = (length + offset) * c; + if (result === 0) return "0"; + return `${result}px`; + } else if (typeof length === "string") { + if (pureNumberRegex.test(length)) { + const result = (Number(length) + offset) * c; + + if (attachPx) { + if (result === 0) return "0"; + return `${result}px`; + } else { + return `${result}`; + } + } else { + const result = numberRegex.exec(length); + if (!result) return length; + return length.replace(numberRegex, String((Number(result[0]) + offset) * c)); + } + } + + return length; + } + + function color2Class(color) { + return color.replace(/#|\(|\)|,|\s/g, "_"); + } + + function ampCount(selector) { + let cnt = 0; + + for (let i = 0; i < selector.length; ++i) { + if (selector[i] === '&') ++cnt; + } + + return cnt; + } + /** + * Don't just use ',' to separate css selector. For example: + * x:(a, b) {} will be split into 'x:(a' and 'b)', which is not expected. + * Make sure comma doesn't exist inside parentheses. + */ + + + const separatorRegex = /\s*,(?![^(]*\))\s*/g; + const extraSpaceRegex = /\s+/g; + /** + * selector must includes '&' + * selector is trimmed + * every part of amp is trimmed + */ + + function resolveSelectorWithAmp(amp, selector) { + const nextAmp = []; + selector.split(separatorRegex).forEach(partialSelector => { + let round = ampCount(partialSelector); // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + if (!round) { + amp.forEach(partialAmp => { + nextAmp.push( // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + (partialAmp && partialAmp + ' ') + partialSelector); + }); + return; + } else if (round === 1) { + amp.forEach(partialAmp => { + nextAmp.push(partialSelector.replace('&', partialAmp)); + }); + return; + } + + let partialNextAmp = [partialSelector]; // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + while (round--) { + const nextPartialNextAmp = []; + partialNextAmp.forEach(selectorItr => { + amp.forEach(partialAmp => { + nextPartialNextAmp.push(selectorItr.replace('&', partialAmp)); + }); + }); + partialNextAmp = nextPartialNextAmp; + } + + partialNextAmp.forEach(part => nextAmp.push(part)); + }); + return nextAmp; + } + /** + * selector mustn't includes '&' + * selector is trimmed + */ + + + function resolveSelector(amp, selector) { + const nextAmp = []; + selector.split(separatorRegex).forEach(partialSelector => { + amp.forEach(partialAmp => { + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + nextAmp.push((partialAmp && partialAmp + ' ') + partialSelector); + }); + }); + return nextAmp; + } + + function parseSelectorPath(selectorPaths) { + let amp = ['']; + selectorPaths.forEach(selector => { + // eslint-disable-next-line + selector = selector && selector.trim(); + + if ( // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + !selector) { + /** + * if it's a empty selector, do nothing + */ + return; + } // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + + if (selector.includes('&')) { + amp = resolveSelectorWithAmp(amp, selector); + } else { + amp = resolveSelector(amp, selector); + } + }); + return amp.join(', ').replace(extraSpaceRegex, ' '); + } + + function removeElement(el) { + /* istanbul ignore if */ + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + if (!el) return; + const parentElement = el.parentElement; + /* istanbul ignore else */ + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + if (parentElement) parentElement.removeChild(el); + } + function queryElement(id) { + return document.querySelector(`style[cssr-id="${id}"]`); + } + function createElement(id) { + const el = document.createElement('style'); + el.setAttribute('cssr-id', id); + return el; + } + function isMediaOrSupports(selector) { + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + if (!selector) return false; + return /^\s*@(s|m)/.test(selector); + } + + const kebabRegex = /[A-Z]/g; + + function kebabCase(pattern) { + return pattern.replace(kebabRegex, match => '-' + match.toLowerCase()); + } + /** TODO: refine it to solve nested object */ + + + function unwrapProperty(prop) { + let indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' '; + + if (typeof prop === 'object' && prop !== null) { + return ' {\n' + Object.entries(prop).map(v => { + return indent + ` ${kebabCase(v[0])}: ${v[1]};`; + }).join('\n') + '\n' + indent + '}'; + } + + return `: ${prop};`; + } + /** unwrap properties */ + + + function unwrapProperties(props, instance, params) { + if (typeof props === 'function') { + return props({ + context: instance.context, + props: params + }); + } + + return props; + } + + function createStyle(selector, props, instance, params) { + if (!props) return ''; // eslint-disable-next-line + + const unwrappedProps = unwrapProperties(props, instance, params); + if (!unwrappedProps) return ''; + + if (typeof unwrappedProps === 'string') { + return `${selector} {\n${unwrappedProps}\n}`; + } + + const propertyNames = Object.keys(unwrappedProps); + + if (propertyNames.length === 0) { + if (instance.config.keepEmptyBlock) return selector + ' {\n}'; + return ''; + } + + const statements = selector ? [selector + ' {'] : []; + propertyNames.forEach(propertyName => { + const property = unwrappedProps[propertyName]; + + if (propertyName === 'raw') { + statements.push('\n' + property + '\n'); + return; + } + + propertyName = kebabCase(propertyName); + + if (property !== null && property !== undefined) { + statements.push(` ${propertyName}${unwrapProperty(property)}`); + } + }); + + if (selector) { + statements.push('}'); + } + + return statements.join('\n'); + } + + function loopCNodeListWithCallback(children, options, callback) { + /* istanbul ignore if */ + if (!children) return; + children.forEach(child => { + if (Array.isArray(child)) { + loopCNodeListWithCallback(child, options, callback); + } else if (typeof child === 'function') { + const grandChildren = child(options); + + if (Array.isArray(grandChildren)) { + loopCNodeListWithCallback(grandChildren, options, callback); + } else if (grandChildren) { + callback(grandChildren); + } + } else if (child) { + callback(child); + } + }); + } + + function traverseCNode(node, selectorPaths, styles, instance, params, styleSheet) { + const $ = node.$; + let blockSelector = ''; + + if (!$ || typeof $ === 'string') { + if (isMediaOrSupports($)) { + blockSelector = $; + } else { + // as a string selector + selectorPaths.push($); + } + } else if (typeof $ === 'function') { + const selector = $({ + context: instance.context, + props: params + }); + + if (isMediaOrSupports(selector)) { + blockSelector = selector; + } else { + // as a lazy selector + selectorPaths.push(selector); + } + } else { + // as a option selector + if ($.before) $.before(instance.context); + + if (!$.$ || typeof $.$ === 'string') { + if (isMediaOrSupports($.$)) { + blockSelector = $.$; + } else { + // as a string selector + selectorPaths.push($.$); + } + } else + /* istanbul ignore else */ + if ($.$) { + const selector = $.$({ + context: instance.context, + props: params + }); + + if (isMediaOrSupports(selector)) { + blockSelector = selector; + } else { + // as a lazy selector + selectorPaths.push(selector); + } + } + } + + const selector = parseSelectorPath(selectorPaths); + const style = createStyle(selector, node.props, instance, params); + + if (blockSelector) { + styles.push(`${blockSelector} {`); + + if (styleSheet && style) { + styleSheet.insertRule(`${blockSelector} {\n${style}\n}\n`); + } + } else { + if (styleSheet && style) { + styleSheet.insertRule(style); + } + + if (!styleSheet && style.length) styles.push(style); + } + + if (node.children) { + loopCNodeListWithCallback(node.children, { + context: instance.context, + props: params + }, childNode => { + if (typeof childNode === 'string') { + const style = createStyle(selector, { + raw: childNode + }, instance, params); + + if (styleSheet) { + styleSheet.insertRule(style); + } else { + styles.push(style); + } + } else { + traverseCNode(childNode, selectorPaths, styles, instance, params, styleSheet); + } + }); + } + + selectorPaths.pop(); + + if (blockSelector) { + styles.push('}'); + } + + if ($ && $.after) $.after(instance.context); + } + + function render(node, instance, props) { + let insertRule = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + const styles = []; + traverseCNode(node, [], styles, instance, props, insertRule ? node.instance.__styleSheet : undefined); + if (insertRule) return ''; + return styles.join('\n\n'); + } + + /* eslint-disable */ + // Inspired by https://github.com/garycourt/murmurhash-js + // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86 + function murmur2(str) { + // 'm' and 'r' are mixing constants generated offline. + // They're not really 'magic', they just happen to work well. + // const m = 0x5bd1e995; + // const r = 24; + // Initialize the hash + var h = 0; // Mix 4 bytes at a time into the hash + + var k, + i = 0, + len = str.length; + + for (; len >= 4; ++i, len -= 4) { + k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24; + k = + /* Math.imul(k, m): */ + (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16); + k ^= + /* k >>> r: */ + k >>> 24; + h = + /* Math.imul(k, m): */ + (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^ + /* Math.imul(h, m): */ + (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); + } // Handle the last few bytes of the input array + + + switch (len) { + case 3: + h ^= (str.charCodeAt(i + 2) & 0xff) << 16; + + case 2: + h ^= (str.charCodeAt(i + 1) & 0xff) << 8; + + case 1: + h ^= str.charCodeAt(i) & 0xff; + h = + /* Math.imul(h, m): */ + (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); + } // Do a few final mixes of the hash to ensure the last few + // bytes are well-incorporated. + + + h ^= h >>> 13; + h = + /* Math.imul(h, m): */ + (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); + return ((h ^ h >>> 15) >>> 0).toString(36); + } + + /* eslint-disable @typescript-eslint/prefer-ts-expect-error */ + + if (typeof window !== 'undefined') { + window.__cssrContext = {}; + } + + function unmount(intance, node, id) { + const { + els + } = node; // If id is undefined, unmount all styles + + if (id === undefined) { + els.forEach(removeElement); + node.els = []; + } else { + const target = queryElement(id); // eslint-disable-next-line + + if (target && els.includes(target)) { + removeElement(target); + node.els = els.filter(el => el !== target); + } + } + } + + function addElementToList(els, target) { + els.push(target); + } + + function mount(instance, node, id, props, head, silent, force, anchorMetaName, ssrAdapter // eslint-disable-next-line @typescript-eslint/no-invalid-void-type + ) { + if (silent && !ssrAdapter) { + if (id === undefined) { + // it is possible to use hash to get rid of the requirements of id + // if you are interested in it, please create a pr + // i have no time to impl it + console.error('[css-render/mount]: `id` is required in `silent` mode.'); + return; + } + + const cssrContext = window.__cssrContext; + + if (!cssrContext[id]) { + cssrContext[id] = true; + render(node, instance, props, silent); + } + + return; + } + + let style; + + if (id === undefined) { + style = node.render(props); + id = murmur2(style); + } + + if (ssrAdapter) { + ssrAdapter.adapter(id, style !== null && style !== void 0 ? style : node.render(props)); + return; + } + + const queriedTarget = queryElement(id); + + if (queriedTarget !== null && !force) { + return queriedTarget; + } + + const target = queriedTarget !== null && queriedTarget !== void 0 ? queriedTarget : createElement(id); + if (style === undefined) style = node.render(props); + target.textContent = style; + if (queriedTarget !== null) return queriedTarget; + + if (anchorMetaName) { + const anchorMetaEl = document.head.querySelector(`meta[name="${anchorMetaName}"]`); + + if (anchorMetaEl) { + document.head.insertBefore(target, anchorMetaEl); + addElementToList(node.els, target); + return target; + } + } + + if (head) { + document.head.insertBefore(target, document.head.querySelector('style, link')); + } else { + document.head.appendChild(target); + } + + addElementToList(node.els, target); + return target; + } + + function wrappedRender(props) { + return render(this, this.instance, props); + } // do not guard node calling, it should throw an error. + + + function wrappedMount() { + let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + const { + id, + ssr, + props, + head = false, + silent = false, + force = false, + anchorMetaName + } = options; + const targetElement = mount(this.instance, this, id, props, head, silent, force, anchorMetaName, ssr); + return targetElement; + } + + function wrappedUnmount() { + let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + /* istanbul ignore next */ + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + const { + id + } = options; + unmount(this.instance, this, id); + } + + const createCNode = function (instance, $, props, children) { + return { + instance, + $, + props, + children, + els: [], + render: wrappedRender, + mount: wrappedMount, + unmount: wrappedUnmount + }; + }; + + const c$2 = function (instance, $, props, children) { + if (Array.isArray($)) { + return createCNode(instance, { + $: null + }, null, $); + } else if (Array.isArray(props)) { + return createCNode(instance, $, null, props); + } else if (Array.isArray(children)) { + return createCNode(instance, $, props, children); + } else { + return createCNode(instance, $, props, null); + } + }; + + function CssRender() { + let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + let styleSheet = null; + const cssr = { + c: function () { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return c$2(cssr, ...args); + }, + use: function (plugin) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + return plugin.install(cssr, ...args); + }, + find: queryElement, + context: {}, + config, + + get __styleSheet() { + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + if (!styleSheet) { + const style = document.createElement('style'); + document.head.appendChild(style); + styleSheet = document.styleSheets[document.styleSheets.length - 1]; + return styleSheet; + } + + return styleSheet; + } + + }; + return cssr; + } + + function exists(id, ssr) { + if (id === undefined) return false; + + if (ssr) { + const { + context: { + ids + } + } = ssr; + return ids.has(id); + } + + return queryElement(id) !== null; + } + + /* eslint-disable @typescript-eslint/restrict-template-expressions */ + + /* eslint-disable @typescript-eslint/strict-boolean-expressions */ + function plugin$1(options) { + let _bPrefix = '.'; + let _ePrefix = '__'; + let _mPrefix = '--'; + let c; + + if (options) { + let t = options.blockPrefix; + + if (t) { + _bPrefix = t; + } + + t = options.elementPrefix; + + if (t) { + _ePrefix = t; + } + + t = options.modifierPrefix; + + if (t) { + _mPrefix = t; + } + } + + const _plugin = { + install(instance) { + c = instance.c; + const ctx = instance.context; + ctx.bem = {}; + ctx.bem.b = null; + ctx.bem.els = null; + } + + }; + + function b(arg) { + let memorizedB; + let memorizedE; + return { + before(ctx) { + memorizedB = ctx.bem.b; + memorizedE = ctx.bem.els; + ctx.bem.els = null; + }, + + after(ctx) { + ctx.bem.b = memorizedB; + ctx.bem.els = memorizedE; + }, + + $(_ref) { + let { + context, + props + } = _ref; + arg = typeof arg === 'string' ? arg : arg({ + context, + props + }); + context.bem.b = arg; + return `${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}`; + } + + }; + } + + function e(arg) { + let memorizedE; + return { + before(ctx) { + memorizedE = ctx.bem.els; + }, + + after(ctx) { + ctx.bem.els = memorizedE; + }, + + $(_ref2) { + let { + context, + props + } = _ref2; + arg = typeof arg === 'string' ? arg : arg({ + context, + props + }); + context.bem.els = arg.split(',').map(v => v.trim()); + return context.bem.els.map(el => `${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${_ePrefix}${el}`).join(', '); + } + + }; + } + + function m(arg) { + return { + $(_ref3) { + let { + context, + props + } = _ref3; + arg = typeof arg === 'string' ? arg : arg({ + context, + props + }); + const modifiers = arg.split(',').map(v => v.trim()); + + function elementToSelector(el) { + return modifiers.map(modifier => `&${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${el !== undefined ? `${_ePrefix}${el}` : ''}${_mPrefix}${modifier}`).join(', '); + } + + const els = context.bem.els; + + if (els !== null) { + if (els.length >= 2) { + throw Error(`[css-render/plugin-bem]: m(${arg}) is invalid, using modifier inside multiple elements is not allowed`); + } + + return elementToSelector(els[0]); + } else { + return elementToSelector(); + } + } + + }; + } + + function notM(arg) { + return { + $(_ref4) { + let { + context, + props + } = _ref4; + arg = typeof arg === 'string' ? arg : arg({ + context, + props + }); + const els = context.bem.els; + + if (els !== null && els.length >= 2) { + throw Error(`[css-render/plugin-bem]: notM(${arg}) is invalid, using modifier inside multiple elements is not allowed`); + } + + return `&:not(${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${els !== null && els.length > 0 ? `${_ePrefix}${els[0]}` : ''}${_mPrefix}${arg})`; + } + + }; + } + + const cB = function () { + return c(b(arguments.length <= 0 ? undefined : arguments[0]), arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]); + }; + + const cE = function () { + return c(e(arguments.length <= 0 ? undefined : arguments[0]), arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]); + }; + + const cM = function () { + return c(m(arguments.length <= 0 ? undefined : arguments[0]), arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]); + }; + + const cNotM = function () { + return c(notM(arguments.length <= 0 ? undefined : arguments[0]), arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]); + }; + + Object.assign(_plugin, { + cB, + cE, + cM, + cNotM + }); + return _plugin; + } + + function createKey(prefix, suffix) { + return prefix + (suffix === "default" ? "" : suffix.replace(/^[a-z]/, startChar => startChar.toUpperCase())); + } + createKey("abc", "def"); + + const namespace = "n"; + const prefix = `.${namespace}-`; + const elementPrefix = "__"; + const modifierPrefix = "--"; + const cssr = CssRender(); + const plugin = plugin$1({ + blockPrefix: prefix, + elementPrefix, + modifierPrefix + }); + cssr.use(plugin); + const { + c: c$1, + find + } = cssr; + const { + cB, + cE, + cM, + cNotM + } = plugin; + + function insideModal(style) { + return c$1(_ref => { + let { + props: { + bPrefix + } + } = _ref; + return `${bPrefix || prefix}modal, ${bPrefix || prefix}drawer`; + }, [style]); + } + + function insidePopover(style) { + return c$1(_ref2 => { + let { + props: { + bPrefix + } + } = _ref2; + return `${bPrefix || prefix}popover`; + }, [style]); + } + + function asModal(style) { + return c$1(_ref3 => { + let { + props: { + bPrefix + } + } = _ref3; + return `&${bPrefix || prefix}modal`; + }, style); + } + + const cCB = function () { + return c$1(">", [cB(...arguments)]); + }; + + let _isJsdom; + + function isJsdom() { + if (_isJsdom === void 0) { + _isJsdom = navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"); + } + + return _isJsdom; + } + + const isBrowser$2 = typeof document !== "undefined" && typeof window !== "undefined"; + + const eventSet = /* @__PURE__ */new WeakSet(); + function markEventEffectPerformed(event) { + eventSet.add(event); + } + function eventEffectNotPerformed(event) { + return !eventSet.has(event); + } + + function useInjectionInstanceCollection(injectionName, collectionKey, registerKeyRef) { + var _getCurrentInstance; + + const injection = vue.inject(injectionName, null); + if (injection === null) return; + const vm = (_getCurrentInstance = vue.getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy; + vue.watch(registerKeyRef, registerInstance); + registerInstance(registerKeyRef.value); + vue.onBeforeUnmount(() => { + registerInstance(void 0, registerKeyRef.value); + }); + + function registerInstance(key, oldKey) { + const collection = injection[collectionKey]; + if (oldKey !== void 0) removeInstance(collection, oldKey); + if (key !== void 0) addInstance(collection, key); + } + + function removeInstance(collection, key) { + if (!collection[key]) collection[key] = []; + collection[key].splice(collection[key].findIndex(instance => instance === vm), 1); + } + + function addInstance(collection, key) { + if (!collection[key]) collection[key] = []; + + if (!~collection[key].findIndex(instance => instance === vm)) { + collection[key].push(vm); + } + } + } + function useInjectionCollection(injectionName, collectionKey, valueRef) { + const injection = vue.inject(injectionName, null); + if (injection === null) return; + + if (!(collectionKey in injection)) { + injection[collectionKey] = []; + } + + injection[collectionKey].push(valueRef.value); + vue.watch(valueRef, (value, prevValue) => { + const collectionArray = injection[collectionKey]; + const index = collectionArray.findIndex(collectionValue => collectionValue === prevValue); + if (~index) collectionArray.splice(index, 1); + collectionArray.push(value); + }); + vue.onBeforeUnmount(() => { + const collectionArray = injection[collectionKey]; + const index = collectionArray.findIndex(collectionValue => collectionValue === valueRef.value); + if (~index) collectionArray.splice(index, 1); + }); + } + function useInjectionElementCollection(injectionName, collectionKey, getElement) { + const injection = vue.inject(injectionName, null); + if (injection === null) return; + + if (!(collectionKey in injection)) { + injection[collectionKey] = []; + } + + vue.onMounted(() => { + const el = getElement(); + if (!el) return; + injection[collectionKey].push(el); + }); + vue.onBeforeUnmount(() => { + const collectionArray = injection[collectionKey]; + const element = getElement(); + const index = collectionArray.findIndex(collectionElement => collectionElement === element); + if (~index) collectionArray.splice(index, 1); + }); + } + + function useDeferredTrue(valueRef, delay, shouldDelayRef) { + if (!delay) return valueRef; + const delayedRef = vue.ref(valueRef.value); + let timerId = null; + vue.watch(valueRef, value => { + if (timerId !== null) window.clearTimeout(timerId); + + if (value === true) { + if (shouldDelayRef && !shouldDelayRef.value) { + delayedRef.value = true; + } else { + timerId = window.setTimeout(() => { + delayedRef.value = true; + }, delay); + } + } else { + delayedRef.value = false; + } + }); + return delayedRef; + } + + function useFalseUntilTruthy(originalRef) { + const currentRef = vue.ref(!!originalRef.value); + if (currentRef.value) return vue.readonly(currentRef); + const stop = vue.watch(originalRef, value => { + if (value) { + currentRef.value = true; + stop(); + } + }); + return vue.readonly(currentRef); + } + + function useMemo(getterOrOptions) { + const computedValueRef = vue.computed(getterOrOptions); // Maybe it's not possible to lazy evaluate the value, since we can't make + // render phase capture the deps behind useMemo + + const valueRef = vue.ref(computedValueRef.value); + vue.watch(computedValueRef, value => { + valueRef.value = value; + }); + + if (typeof getterOrOptions === 'function') { + return valueRef; + } else { + return { + __v_isRef: true, + + get value() { + return valueRef.value; + }, + + set value(v) { + getterOrOptions.set(v); + } + + }; + } + } + + function hasInstance() { + return vue.getCurrentInstance() !== null; + } + const isBrowser$1 = typeof window !== 'undefined'; + + let fontsReady; + let isFontReady; + + const init$1 = () => { + var _a, _b; + + fontsReady = isBrowser$1 ? (_b = (_a = document) === null || _a === void 0 ? void 0 : _a.fonts) === null || _b === void 0 ? void 0 : _b.ready : undefined; + isFontReady = false; + /* istanbul ignore if */ + + if (fontsReady !== undefined) { + void fontsReady.then(() => { + isFontReady = true; + }); + } else { + isFontReady = true; + } + }; + + init$1(); // For testing + /** + * Call callback on fontsReady is resolved. If fontsReady is already resolved, + * callback won't be called. + */ + + function onFontsReady(cb) { + /* istanbul ignore next */ + if (isFontReady) return; + let deactivated = false; + vue.onMounted(() => { + /* istanbul ignore next */ + if (!isFontReady) { + fontsReady === null || fontsReady === void 0 ? void 0 : fontsReady.then(() => { + if (deactivated) return; + cb(); + }); + } + }); + vue.onBeforeUnmount(() => { + deactivated = true; + }); + } + + function getEventTarget(e) { + const path = e.composedPath(); + return path[0]; + } + + const traps = { + mousemoveoutside: new WeakMap(), + clickoutside: new WeakMap() + }; + + function createTrapHandler(name, el, originalHandler) { + if (name === 'mousemoveoutside') { + const moveHandler = e => { + if (el.contains(getEventTarget(e))) return; + originalHandler(e); + }; + + return { + mousemove: moveHandler, + touchstart: moveHandler + }; + } else if (name === 'clickoutside') { + let mouseDownOutside = false; + + const downHandler = e => { + mouseDownOutside = !el.contains(getEventTarget(e)); + }; + + const upHanlder = e => { + if (!mouseDownOutside) return; + if (el.contains(getEventTarget(e))) return; + originalHandler(e); + }; + + return { + mousedown: downHandler, + mouseup: upHanlder, + touchstart: downHandler, + touchend: upHanlder + }; + } + + console.error( // eslint-disable-next-line @typescript-eslint/restrict-template-expressions + `[evtd/create-trap-handler]: name \`${name}\` is invalid. This could be a bug of evtd.`); + return {}; + } + + function ensureTrapHandlers(name, el, handler) { + const handlers = traps[name]; + let elHandlers = handlers.get(el); + + if (elHandlers === undefined) { + handlers.set(el, elHandlers = new WeakMap()); + } + + let trapHandler = elHandlers.get(handler); + + if (trapHandler === undefined) { + elHandlers.set(handler, trapHandler = createTrapHandler(name, el, handler)); + } + + return trapHandler; + } + + function trapOn(name, el, handler, options) { + if (name === 'mousemoveoutside' || name === 'clickoutside') { + const trapHandlers = ensureTrapHandlers(name, el, handler); + Object.keys(trapHandlers).forEach(key => { + on(key, document, trapHandlers[key], options); + }); + return true; + } + + return false; + } + + function trapOff(name, el, handler, options) { + if (name === 'mousemoveoutside' || name === 'clickoutside') { + const trapHandlers = ensureTrapHandlers(name, el, handler); + Object.keys(trapHandlers).forEach(key => { + off(key, document, trapHandlers[key], options); + }); + return true; + } + + return false; + } + + function createDelegate() { + if (typeof window === 'undefined') { + return { + on: () => {}, + off: () => {} + }; + } + + const propagationStopped = new WeakMap(); + const immediatePropagationStopped = new WeakMap(); + + function trackPropagation() { + propagationStopped.set(this, true); + } + + function trackImmediate() { + propagationStopped.set(this, true); + immediatePropagationStopped.set(this, true); + } + + function spy(event, propName, fn) { + const source = event[propName]; + + event[propName] = function () { + fn.apply(event, arguments); + return source.apply(event, arguments); + }; + + return event; + } + + function unspy(event, propName) { + event[propName] = Event.prototype[propName]; + } + + const currentTargets = new WeakMap(); + const currentTargetDescriptor = Object.getOwnPropertyDescriptor(Event.prototype, 'currentTarget'); + + function getCurrentTarget() { + var _a; + + return (_a = currentTargets.get(this)) !== null && _a !== void 0 ? _a : null; + } + + function defineCurrentTarget(event, getter) { + if (currentTargetDescriptor === undefined) return; + Object.defineProperty(event, 'currentTarget', { + configurable: true, + enumerable: true, + get: getter !== null && getter !== void 0 ? getter : currentTargetDescriptor.get + }); + } + + const phaseToTypeToElToHandlers = { + bubble: {}, + capture: {} + }; + const typeToWindowEventHandlers = {}; + + function createUnifiedHandler() { + const delegeteHandler = function (e) { + const { + type, + eventPhase, + bubbles + } = e; + const target = getEventTarget(e); + if (eventPhase === 2) return; + const phase = eventPhase === 1 ? 'capture' : 'bubble'; + let cursor = target; + const path = []; // collecting bubble path + + while (true) { + if (cursor === null) cursor = window; + path.push(cursor); + + if (cursor === window) { + break; + } // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + + cursor = cursor.parentNode || null; + } + + const captureElToHandlers = phaseToTypeToElToHandlers.capture[type]; + const bubbleElToHandlers = phaseToTypeToElToHandlers.bubble[type]; + spy(e, 'stopPropagation', trackPropagation); + spy(e, 'stopImmediatePropagation', trackImmediate); + defineCurrentTarget(e, getCurrentTarget); + + if (phase === 'capture') { + if (captureElToHandlers === undefined) return; // capture + + for (let i = path.length - 1; i >= 0; --i) { + if (propagationStopped.has(e)) break; + const target = path[i]; + const handlers = captureElToHandlers.get(target); + + if (handlers !== undefined) { + currentTargets.set(e, target); + + for (const handler of handlers) { + if (immediatePropagationStopped.has(e)) break; + handler(e); + } + } + + if (i === 0 && !bubbles && bubbleElToHandlers !== undefined) { + const bubbleHandlers = bubbleElToHandlers.get(target); + + if (bubbleHandlers !== undefined) { + for (const handler of bubbleHandlers) { + if (immediatePropagationStopped.has(e)) break; + handler(e); + } + } + } + } + } else if (phase === 'bubble') { + if (bubbleElToHandlers === undefined) return; // bubble + + for (let i = 0; i < path.length; ++i) { + if (propagationStopped.has(e)) break; + const target = path[i]; + const handlers = bubbleElToHandlers.get(target); + + if (handlers !== undefined) { + currentTargets.set(e, target); + + for (const handler of handlers) { + if (immediatePropagationStopped.has(e)) break; + handler(e); + } + } + } + } + + unspy(e, 'stopPropagation'); + unspy(e, 'stopImmediatePropagation'); + defineCurrentTarget(e); + }; + + delegeteHandler.displayName = 'evtdUnifiedHandler'; + return delegeteHandler; + } + + function createUnifiedWindowEventHandler() { + const delegateHandler = function (e) { + const { + type, + eventPhase + } = e; + if (eventPhase !== 2) return; + const handlers = typeToWindowEventHandlers[type]; + if (handlers === undefined) return; + handlers.forEach(handler => handler(e)); + }; + + delegateHandler.displayName = 'evtdUnifiedWindowEventHandler'; + return delegateHandler; + } + + const unifiedHandler = createUnifiedHandler(); + const unfiendWindowEventHandler = createUnifiedWindowEventHandler(); + + function ensureElToHandlers(phase, type) { + const phaseHandlers = phaseToTypeToElToHandlers[phase]; + + if (phaseHandlers[type] === undefined) { + phaseHandlers[type] = new Map(); + window.addEventListener(type, unifiedHandler, phase === 'capture'); + } + + return phaseHandlers[type]; + } + + function ensureWindowEventHandlers(type) { + const windowEventHandlers = typeToWindowEventHandlers[type]; + + if (windowEventHandlers === undefined) { + typeToWindowEventHandlers[type] = new Set(); + window.addEventListener(type, unfiendWindowEventHandler); + } + + return typeToWindowEventHandlers[type]; + } + + function ensureHandlers(elToHandlers, el) { + let elHandlers = elToHandlers.get(el); + + if (elHandlers === undefined) { + elToHandlers.set(el, elHandlers = new Set()); + } + + return elHandlers; + } + + function handlerExist(el, phase, type, handler) { + const elToHandlers = phaseToTypeToElToHandlers[phase][type]; // phase ${type} event has handlers + + if (elToHandlers !== undefined) { + const handlers = elToHandlers.get(el); // phase using el with ${type} event has handlers + + if (handlers !== undefined) { + if (handlers.has(handler)) return true; + } + } + + return false; + } + + function windowEventHandlerExist(type, handler) { + const handlers = typeToWindowEventHandlers[type]; + + if (handlers !== undefined) { + if (handlers.has(handler)) { + return true; + } + } + + return false; + } + + function on(type, el, handler, options) { + let mergedHandler; + + if (typeof options === 'object' && options.once === true) { + mergedHandler = e => { + off(type, el, mergedHandler, options); + handler(e); + }; + } else { + mergedHandler = handler; + } + + const trapped = trapOn(type, el, mergedHandler, options); + if (trapped) return; + const phase = options === true || typeof options === 'object' && options.capture === true ? 'capture' : 'bubble'; + const elToHandlers = ensureElToHandlers(phase, type); + const handlers = ensureHandlers(elToHandlers, el); + if (!handlers.has(mergedHandler)) handlers.add(mergedHandler); + + if (el === window) { + const windowEventHandlers = ensureWindowEventHandlers(type); + + if (!windowEventHandlers.has(mergedHandler)) { + windowEventHandlers.add(mergedHandler); + } + } + } + + function off(type, el, handler, options) { + const trapped = trapOff(type, el, handler, options); + if (trapped) return; + const capture = options === true || typeof options === 'object' && options.capture === true; + const phase = capture ? 'capture' : 'bubble'; + const elToHandlers = ensureElToHandlers(phase, type); + const handlers = ensureHandlers(elToHandlers, el); + + if (el === window) { + const mirrorPhase = capture ? 'bubble' : 'capture'; + + if (!handlerExist(el, mirrorPhase, type, handler) && windowEventHandlerExist(type, handler)) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const windowEventHandlers = typeToWindowEventHandlers[type]; + windowEventHandlers.delete(handler); + + if (windowEventHandlers.size === 0) { + window.removeEventListener(type, unfiendWindowEventHandler); + typeToWindowEventHandlers[type] = undefined; + } + } + } + + if (handlers.has(handler)) handlers.delete(handler); + + if (handlers.size === 0) { + elToHandlers.delete(el); + } + + if (elToHandlers.size === 0) { + window.removeEventListener(type, unifiedHandler, phase === 'capture'); + phaseToTypeToElToHandlers[phase][type] = undefined; + } + } + + return { + on: on, + off: off + }; + } + + const { + on, + off + } = createDelegate(); + + const mousePositionRef = vue.ref(null); + + function clickHandler(e) { + if (e.clientX > 0 || e.clientY > 0) { + mousePositionRef.value = { + x: e.clientX, + y: e.clientY + }; + } else { + // x = 0 & y = 0 + const { + target + } = e; + + if (target instanceof Element) { + const { + left, + top, + width, + height + } = target.getBoundingClientRect(); + + if (left > 0 || top > 0) { + // impossible to be triggered by real click + mousePositionRef.value = { + x: left + width / 2, + y: top + height / 2 + }; + } else { + mousePositionRef.value = { + x: 0, + y: 0 + }; + } + } else { + mousePositionRef.value = null; + } + } + } + + let usedCount$2 = 0; + let managable$2 = true; + function useClickPosition() { + if (!isBrowser$1) return vue.readonly(vue.ref(null)); + if (usedCount$2 === 0) on('click', document, clickHandler, true); + + const setup = () => { + usedCount$2 += 1; + }; + + if (managable$2 && (managable$2 = hasInstance())) { + vue.onBeforeMount(setup); + vue.onBeforeUnmount(() => { + usedCount$2 -= 1; + if (usedCount$2 === 0) off('click', document, clickHandler, true); + }); + } else { + setup(); + } + + return vue.readonly(mousePositionRef); + } + + const clickedTimeRef = vue.ref(undefined); + let usedCount$1 = 0; + + function handleClick() { + clickedTimeRef.value = Date.now(); + } + + let managable$1 = true; + function useClicked(timeout) { + if (!isBrowser$1) return vue.readonly(vue.ref(false)); + const clickedRef = vue.ref(false); + let timerId = null; + + function clearTimer() { + if (timerId !== null) window.clearTimeout(timerId); + } + + function clickedHandler() { + clearTimer(); + clickedRef.value = true; + timerId = window.setTimeout(() => { + clickedRef.value = false; + }, timeout); + } + + if (usedCount$1 === 0) { + on('click', window, handleClick, true); + } + + const setup = () => { + usedCount$1 += 1; + on('click', window, clickedHandler, true); + }; + + if (managable$1 && (managable$1 = hasInstance())) { + vue.onBeforeMount(setup); + vue.onBeforeUnmount(() => { + usedCount$1 -= 1; + + if (usedCount$1 === 0) { + off('click', window, handleClick, true); + } + + off('click', window, clickedHandler, true); + clearTimer(); + }); + } else { + setup(); + } + + return vue.readonly(clickedRef); + } + + /* eslint-disable @typescript-eslint/strict-boolean-expressions */ + let usedCount = 0; // Mql means media query list + + const supportMatchMedia = typeof window !== 'undefined' && window.matchMedia !== undefined; + const osTheme = vue.ref(null); + let darkMql; + let lightMql; + + function handleDarkMqlChange(e) { + if (e.matches) { + osTheme.value = 'dark'; + } + } + + function handleLightMqlChange(e) { + if (e.matches) { + osTheme.value = 'light'; + } + } + + function init() { + darkMql = window.matchMedia('(prefers-color-scheme: dark)'); + lightMql = window.matchMedia('(prefers-color-scheme: light)'); + + if (darkMql.matches) { + osTheme.value = 'dark'; + } else if (lightMql.matches) { + osTheme.value = 'light'; + } else { + osTheme.value = null; + } + + if (darkMql.addEventListener) { + darkMql.addEventListener('change', handleDarkMqlChange); + lightMql.addEventListener('change', handleLightMqlChange); + } else if (darkMql.addListener) { + darkMql.addListener(handleDarkMqlChange); + lightMql.addListener(handleLightMqlChange); + } + } + + function clean() { + if ('removeEventListener' in darkMql) { + darkMql.removeEventListener('change', handleDarkMqlChange); + lightMql.removeEventListener('change', handleLightMqlChange); + } else if ('removeListener' in darkMql) { + darkMql.removeListener(handleDarkMqlChange); + lightMql.removeListener(handleLightMqlChange); + } + + darkMql = undefined; + lightMql = undefined; + } + + let managable = true; + function useOsTheme() { + /* istanbul ignore next */ + if (!supportMatchMedia) { + return vue.readonly(osTheme); + } + + if (usedCount === 0) init(); + + if (managable && (managable = hasInstance())) { + vue.onBeforeMount(() => { + usedCount += 1; + }); + vue.onBeforeUnmount(() => { + usedCount -= 1; + if (usedCount === 0) clean(); + }); + } + + return vue.readonly(osTheme); + } + + function useMergedState(controlledStateRef, uncontrolledStateRef) { + vue.watch(controlledStateRef, value => { + if (value !== undefined) { + uncontrolledStateRef.value = value; + } + }); + return vue.computed(() => { + if (controlledStateRef.value === undefined) { + return uncontrolledStateRef.value; + } + + return controlledStateRef.value; + }); + } + + function isMounted() { + const isMounted = vue.ref(false); + vue.onMounted(() => { + isMounted.value = true; + }); + return vue.readonly(isMounted); + } + + function useCompitable(reactive, keys) { + // @ts-expect-error + return vue.computed(() => { + for (const key of keys) { + if (reactive[key] !== undefined) return reactive[key]; + } + + return reactive[keys[keys.length - 1]]; + }); + } + + const isIos = (typeof window === 'undefined' ? false : /iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1) && // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + !window.MSStream; + function useIsIos() { + return isIos; + } + + /* eslint-disable @typescript-eslint/consistent-type-assertions */ + const defaultBreakpointOptions = { + // mobile + // 0 ~ 640 doesn't mean it should display well in all the range, + // but means you should treat it like a mobile phone.) + xs: 0, + s: 640, + m: 1024, + l: 1280, + xl: 1536, + '2xl': 1920 // normal desktop display + + }; + + function createMediaQuery(screenWidth) { + return `(min-width: ${screenWidth}px)`; + } + + const mqlMap = {}; + + function useBreakpoints() { + let screens = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultBreakpointOptions; + if (!isBrowser$1) return vue.computed(() => []); // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + if (typeof window.matchMedia !== 'function') return vue.computed(() => []); + const breakpointStatusRef = vue.ref({}); + const breakpoints = Object.keys(screens); + + const updateBreakpoints = (e, breakpointName) => { + if (e.matches) breakpointStatusRef.value[breakpointName] = true;else breakpointStatusRef.value[breakpointName] = false; + }; + + breakpoints.forEach(key => { + const breakpointValue = screens[key]; + let mql; + let cbs; + + if (mqlMap[breakpointValue] === undefined) { + mql = window.matchMedia(createMediaQuery(breakpointValue)); // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + if (mql.addEventListener) { + mql.addEventListener('change', e => { + cbs.forEach(cb => { + cb(e, key); + }); + }); // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + } else if (mql.addListener) { + mql.addListener(e => { + cbs.forEach(cb => { + cb(e, key); + }); + }); + } + + cbs = new Set(); + mqlMap[breakpointValue] = { + mql, + cbs + }; + } else { + mql = mqlMap[breakpointValue].mql; + cbs = mqlMap[breakpointValue].cbs; + } + + cbs.add(updateBreakpoints); + + if (mql.matches) { + cbs.forEach(cb => { + cb(mql, key); + }); + } + }); + vue.onBeforeUnmount(() => { + breakpoints.forEach(breakpoint => { + const { + cbs + } = mqlMap[screens[breakpoint]]; + + if (cbs.has(updateBreakpoints)) { + cbs.delete(updateBreakpoints); + } + }); + }); + return vue.computed(() => { + const { + value + } = breakpointStatusRef; + return breakpoints.filter(key => value[key]); + }); + } + + function useKeyboard$1() { + let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + let enabledRef = arguments.length > 1 ? arguments[1] : undefined; + const state = vue.reactive({ + ctrl: false, + command: false, + win: false, + shift: false, + tab: false + }); + const { + keydown, + keyup + } = options; + + const keydownHandler = e => { + switch (e.key) { + case 'Control': + state.ctrl = true; + break; + + case 'Meta': + state.command = true; + state.win = true; + break; + + case 'Shift': + state.shift = true; + break; + + case 'Tab': + state.tab = true; + break; + } + + if (keydown !== undefined) { + Object.keys(keydown).forEach(key => { + if (key !== e.key) return; + const handler = keydown[key]; + + if (typeof handler === 'function') { + handler(e); + } else { + const { + stop = false, + prevent = false + } = handler; + if (stop) e.stopPropagation(); + if (prevent) e.preventDefault(); + handler.handler(e); + } + }); + } + }; + + const keyupHandler = e => { + switch (e.key) { + case 'Control': + state.ctrl = false; + break; + + case 'Meta': + state.command = false; + state.win = false; + break; + + case 'Shift': + state.shift = false; + break; + + case 'Tab': + state.tab = false; + break; + } + + if (keyup !== undefined) { + Object.keys(keyup).forEach(key => { + if (key !== e.key) return; + const handler = keyup[key]; + + if (typeof handler === 'function') { + handler(e); + } else { + const { + stop = false, + prevent = false + } = handler; + if (stop) e.stopPropagation(); + if (prevent) e.preventDefault(); + handler.handler(e); + } + }); + } + }; + + const setup = () => { + if (enabledRef === undefined || enabledRef.value) { + on('keydown', document, keydownHandler); + on('keyup', document, keyupHandler); + } + + if (enabledRef !== undefined) { + vue.watch(enabledRef, value => { + if (value) { + on('keydown', document, keydownHandler); + on('keyup', document, keyupHandler); + } else { + off('keydown', document, keydownHandler); + off('keyup', document, keyupHandler); + } + }); + } + }; + + if (hasInstance()) { + vue.onBeforeMount(setup); + vue.onBeforeUnmount(() => { + if (enabledRef === undefined || enabledRef.value) { + off('keydown', document, keydownHandler); + off('keyup', document, keyupHandler); + } + }); + } else { + setup(); + } + + return vue.readonly(state); + } + + const internalSelectionMenuInjectionKey = createInjectionKey("n-internal-select-menu"); + const internalSelectionMenuBodyInjectionKey = createInjectionKey("n-internal-select-menu-body"); + + const modalBodyInjectionKey = createInjectionKey("n-modal-body"); + const modalInjectionKey = createInjectionKey("n-modal"); + + const drawerBodyInjectionKey = createInjectionKey("n-drawer-body"); + const drawerInjectionKey = createInjectionKey("n-drawer"); + + const popoverBodyInjectionKey = createInjectionKey("n-popover-body"); + + const teleportDisabled = "__disabled__"; + + function useAdjustedTo(props) { + const modal = vue.inject(modalBodyInjectionKey, null); + const drawer = vue.inject(drawerBodyInjectionKey, null); + const popover = vue.inject(popoverBodyInjectionKey, null); + const selectMenu = vue.inject(internalSelectionMenuBodyInjectionKey, null); + const fullscreenElementRef = vue.ref(); + + if (typeof document !== "undefined") { + fullscreenElementRef.value = document.fullscreenElement; + + const handleFullscreenChange = () => { + fullscreenElementRef.value = document.fullscreenElement; + }; + + vue.onMounted(() => { + on("fullscreenchange", document, handleFullscreenChange); + }); + vue.onBeforeUnmount(() => { + off("fullscreenchange", document, handleFullscreenChange); + }); + } + + return useMemo(() => { + const { + to + } = props; + + if (to !== void 0) { + if (to === false) return teleportDisabled; + if (to === true) return fullscreenElementRef.value || "body"; + return to; + } + + if (modal !== null && modal !== void 0 && modal.value) { + return modal.value.$el ?? modal.value; + } + + if (drawer !== null && drawer !== void 0 && drawer.value) return drawer.value; + if (popover !== null && popover !== void 0 && popover.value) return popover.value; + if (selectMenu !== null && selectMenu !== void 0 && selectMenu.value) return selectMenu.value; + return to ?? (fullscreenElementRef.value || "body"); + }); + } + + useAdjustedTo.tdkey = teleportDisabled; + useAdjustedTo.propTo = { + type: [String, Object, Boolean], + default: void 0 + }; + + let houdiniRegistered = false; + function useHoudini() { + if (!isBrowser$2) return; + if (!window.CSS) return; + + if (!houdiniRegistered) { + var _window; + + houdiniRegistered = true; + + if ("registerProperty" in ((_window = window) === null || _window === void 0 ? void 0 : _window.CSS)) { + try { + ; + CSS.registerProperty({ + name: "--n-color-start", + syntax: "", + inherits: false, + initialValue: "#0000" + }); + CSS.registerProperty({ + name: "--n-color-end", + syntax: "", + inherits: false, + initialValue: "#0000" + }); + } catch (e) {} + } + } + } + + function getSlot(scope, slots) { + let slotName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'default'; + const slot = slots[slotName]; + + if (slot === undefined) { + throw new Error(`[vueuc/${scope}]: slot[${slotName}] is empty.`); + } + + return slot(); + } // o(n) flatten + + function flatten$2(vNodes) { + let filterCommentNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + let result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + vNodes.forEach(vNode => { + if (vNode === null) return; + + if (typeof vNode !== 'object') { + if (typeof vNode === 'string' || typeof vNode === 'number') { + result.push(vue.createTextVNode(String(vNode))); + } + + return; + } + + if (Array.isArray(vNode)) { + flatten$2(vNode, filterCommentNode, result); + return; + } + + if (vNode.type === vue.Fragment) { + if (vNode.children === null) return; + + if (Array.isArray(vNode.children)) { + flatten$2(vNode.children, filterCommentNode, result); + } // rawSlot + + } else if (vNode.type !== vue.Comment) { + result.push(vNode); + } + }); + return result; + } + function getFirstVNode(scope, slots) { + let slotName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'default'; + const slot = slots[slotName]; + + if (slot === undefined) { + throw new Error(`[vueuc/${scope}]: slot[${slotName}] is empty.`); + } + + const content = flatten$2(slot()); // vue will normalize the slot, so slot must be an array + + if (content.length === 1) { + return content[0]; + } else { + throw new Error(`[vueuc/${scope}]: slot[${slotName}] should have exactly one child.`); + } + } + + let viewMeasurer = null; + function ensureViewBoundingRect() { + if (viewMeasurer === null) { + viewMeasurer = document.getElementById('v-binder-view-measurer'); + + if (viewMeasurer === null) { + viewMeasurer = document.createElement('div'); + viewMeasurer.id = 'v-binder-view-measurer'; + const { + style + } = viewMeasurer; + style.position = 'fixed'; + style.left = '0'; + style.right = '0'; + style.top = '0'; + style.bottom = '0'; + style.pointerEvents = 'none'; + style.visibility = 'hidden'; + document.body.appendChild(viewMeasurer); + } + } + + return viewMeasurer.getBoundingClientRect(); + } + function getPointRect(x, y) { + const viewRect = ensureViewBoundingRect(); + return { + top: y, + left: x, + height: 0, + width: 0, + right: viewRect.width - x, + bottom: viewRect.height - y + }; + } + function getRect$1(el) { + const elRect = el.getBoundingClientRect(); + const viewRect = ensureViewBoundingRect(); + return { + left: elRect.left - viewRect.left, + top: elRect.top - viewRect.top, + bottom: viewRect.height + viewRect.top - elRect.bottom, + right: viewRect.width + viewRect.left - elRect.right, + width: elRect.width, + height: elRect.height + }; + } + function getParentNode(node) { + // document type + if (node.nodeType === 9) { + return null; + } + + return node.parentNode; + } + function getScrollParent(node) { + if (node === null) return null; + const parentNode = getParentNode(node); + + if (parentNode === null) { + return null; + } // Document + + + if (parentNode.nodeType === 9) { + return document; + } // Element + + + if (parentNode.nodeType === 1) { + // Firefox want us to check `-x` and `-y` variations as well + const { + overflow, + overflowX, + overflowY + } = getComputedStyle(parentNode); + + if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { + return parentNode; + } + } + + return getScrollParent(parentNode); + } + + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + const Binder = vue.defineComponent({ + name: 'Binder', + props: { + syncTargetWithParent: Boolean, + syncTarget: { + type: Boolean, + default: true + } + }, + + setup(props) { + var _a; + + vue.provide('VBinder', (_a = vue.getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy); + const VBinder = vue.inject('VBinder', null); + const targetRef = vue.ref(null); + /** + * If there's no nested vbinder, we can simply set the target ref. + * + * However, when it comes to: + * <- syncTarget = false + * + * Should hold target DOM ref, but can't get it directly from + * its VTarget. So if there are nested VBinder, we should: + * 1. Stop setting target DOM from level-1 VTarget + * 2. Set target DOM from level-2 VTarget + * For (1), we need `syncTarget` to `false` + * For (2), we need to set `syncTargetWithParent` to `true` on + * level-2 VBinder + * + * <- syncTargetWithParent = true + * target + * + * + * content1 + * + * + * + * content2 + * + * + */ + + const setTargetRef = el => { + targetRef.value = el; // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + + if (VBinder && props.syncTargetWithParent) { + VBinder.setTargetRef(el); + } + }; // scroll related + + + let scrollableNodes = []; + + const ensureScrollListener = () => { + let cursor = targetRef.value; + + while (true) { + cursor = getScrollParent(cursor); + if (cursor === null) break; + scrollableNodes.push(cursor); + } + + for (const el of scrollableNodes) { + on('scroll', el, onScroll, true); + } + }; + + const removeScrollListeners = () => { + for (const el of scrollableNodes) { + off('scroll', el, onScroll, true); + } + + scrollableNodes = []; + }; + + const followerScrollListeners = new Set(); + + const addScrollListener = listener => { + if (followerScrollListeners.size === 0) { + ensureScrollListener(); + } + + if (!followerScrollListeners.has(listener)) { + followerScrollListeners.add(listener); + } + }; + + const removeScrollListener = listener => { + if (followerScrollListeners.has(listener)) { + followerScrollListeners.delete(listener); + } + + if (followerScrollListeners.size === 0) { + removeScrollListeners(); + } + }; + + const onScroll = () => { + beforeNextFrameOnce(onScrollRaf); + }; + + const onScrollRaf = () => { + followerScrollListeners.forEach(listener => listener()); + }; // resize related + + + const followerResizeListeners = new Set(); + + const addResizeListener = listener => { + if (followerResizeListeners.size === 0) { + on('resize', window, onResize); + } + + if (!followerResizeListeners.has(listener)) { + followerResizeListeners.add(listener); + } + }; + + const removeResizeListener = listener => { + if (followerResizeListeners.has(listener)) { + followerResizeListeners.delete(listener); + } + + if (followerResizeListeners.size === 0) { + off('resize', window, onResize); + } + }; + + const onResize = () => { + followerResizeListeners.forEach(listener => listener()); + }; + + vue.onBeforeUnmount(() => { + off('resize', window, onResize); + removeScrollListeners(); + }); + return { + targetRef, + setTargetRef, + addScrollListener, + removeScrollListener, + addResizeListener, + removeResizeListener + }; + }, + + render() { + return getSlot('binder', this.$slots); + } + + }); + var VBinder = Binder; + + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + var VTarget = vue.defineComponent({ + name: 'Target', + + setup() { + const { + setTargetRef, + syncTarget + } = vue.inject('VBinder'); + const setTargetDirective = { + mounted: setTargetRef, + updated: setTargetRef + }; + return { + syncTarget, + setTargetDirective + }; + }, + + render() { + const { + syncTarget, + setTargetDirective + } = this; + /** + * If you are using VBinder as a child of VBinder, the children wouldn't be + * a valid DOM or component that can be attached to by directive. + * So we won't sync target on those kind of situation and control the + * target sync logic manually. + */ + + if (syncTarget) { + return vue.withDirectives(getFirstVNode('follower', this.$slots), [[setTargetDirective]]); + } + + return getFirstVNode('follower', this.$slots); + } + + }); + + const ctxKey$1 = '@@mmoContext'; + const mousemoveoutside = { + mounted(el, _ref) { + let { + value + } = _ref; + el[ctxKey$1] = { + handler: undefined + }; + + if (typeof value === 'function') { + el[ctxKey$1].handler = value; + on('mousemoveoutside', el, value); + } + }, + + updated(el, _ref2) { + let { + value + } = _ref2; + const ctx = el[ctxKey$1]; + + if (typeof value === 'function') { + if (ctx.handler) { + if (ctx.handler !== value) { + off('mousemoveoutside', el, ctx.handler); + ctx.handler = value; + on('mousemoveoutside', el, value); + } + } else { + el[ctxKey$1].handler = value; + on('mousemoveoutside', el, value); + } + } else { + if (ctx.handler) { + off('mousemoveoutside', el, ctx.handler); + ctx.handler = undefined; + } + } + }, + + unmounted(el) { + const { + handler + } = el[ctxKey$1]; + + if (handler) { + off('mousemoveoutside', el, handler); + } + + el[ctxKey$1].handler = undefined; + } + + }; + var mousemoveoutside$1 = mousemoveoutside; + + const ctxKey = '@@coContext'; + const clickoutside = { + mounted(el, _ref) { + let { + value, + modifiers + } = _ref; + el[ctxKey] = { + handler: undefined + }; + + if (typeof value === 'function') { + el[ctxKey].handler = value; + on('clickoutside', el, value, { + capture: modifiers.capture + }); + } + }, + + updated(el, _ref2) { + let { + value, + modifiers + } = _ref2; + const ctx = el[ctxKey]; + + if (typeof value === 'function') { + if (ctx.handler) { + if (ctx.handler !== value) { + off('clickoutside', el, ctx.handler, { + capture: modifiers.capture + }); + ctx.handler = value; + on('clickoutside', el, value, { + capture: modifiers.capture + }); + } + } else { + el[ctxKey].handler = value; + on('clickoutside', el, value, { + capture: modifiers.capture + }); + } + } else { + if (ctx.handler) { + off('clickoutside', el, ctx.handler, { + capture: modifiers.capture + }); + ctx.handler = undefined; + } + } + }, + + unmounted(el, _ref3) { + let { + modifiers + } = _ref3; + const { + handler + } = el[ctxKey]; + + if (handler) { + off('clickoutside', el, handler, { + capture: modifiers.capture + }); + } + + el[ctxKey].handler = undefined; + } + + }; + var clickoutside$1 = clickoutside; + + function warn$1(location, message) { + console.error(`[vdirs/${location}]: ${message}`); + } + + class ZIndexManager { + constructor() { + this.elementZIndex = new Map(); + this.nextZIndex = 2000; + } + + get elementCount() { + return this.elementZIndex.size; + } + + ensureZIndex(el, zIndex) { + const { + elementZIndex + } = this; + + if (zIndex !== undefined) { + el.style.zIndex = `${zIndex}`; + elementZIndex.delete(el); + return; + } + + const { + nextZIndex + } = this; + + if (elementZIndex.has(el)) { + const currentZIndex = elementZIndex.get(el); + if (currentZIndex + 1 === this.nextZIndex) return; + } + + el.style.zIndex = `${nextZIndex}`; + elementZIndex.set(el, nextZIndex); + this.nextZIndex = nextZIndex + 1; + this.squashState(); + } + + unregister(el, zIndex) { + const { + elementZIndex + } = this; + + if (elementZIndex.has(el)) { + elementZIndex.delete(el); + } else if (zIndex === undefined) { + warn$1('z-index-manager/unregister-element', 'Element not found when unregistering.'); + } + + this.squashState(); + } + + squashState() { + const { + elementCount + } = this; + + if (!elementCount) { + this.nextZIndex = 2000; + } + + if (this.nextZIndex - elementCount > 2500) this.rearrange(); + } + + rearrange() { + const elementZIndexPair = Array.from(this.elementZIndex.entries()); + elementZIndexPair.sort((pair1, pair2) => { + return pair1[1] - pair2[1]; + }); + this.nextZIndex = 2000; + elementZIndexPair.forEach(pair => { + const el = pair[0]; + const zIndex = this.nextZIndex++; + if (`${zIndex}` !== el.style.zIndex) el.style.zIndex = `${zIndex}`; + }); + } + + } + + var zIndexManager = new ZIndexManager(); + + const ctx = '@@ziContext'; // We don't expect manually bound zindex should be changed + + const zindexable = { + mounted(el, bindings) { + const { + value = {} + } = bindings; + const { + zIndex, + enabled + } = value; + el[ctx] = { + enabled: !!enabled, + initialized: false + }; + + if (enabled) { + zIndexManager.ensureZIndex(el, zIndex); + el[ctx].initialized = true; + } + }, + + updated(el, bindings) { + const { + value = {} + } = bindings; + const { + zIndex, + enabled + } = value; + const cachedEnabled = el[ctx].enabled; + + if (enabled && !cachedEnabled) { + zIndexManager.ensureZIndex(el, zIndex); + el[ctx].initialized = true; + } + + el[ctx].enabled = !!enabled; + }, + + unmounted(el, bindings) { + if (!el[ctx].initialized) return; + const { + value = {} + } = bindings; + const { + zIndex + } = value; + zIndexManager.unregister(el, zIndex); + } + + }; + var zindexable$1 = zindexable; + + const ssrContextKey = Symbol('@css-render/vue3-ssr'); + + function createStyleString(id, style) { + return ``; + } + + function ssrAdapter(id, style) { + const ssrContext = vue.inject(ssrContextKey, null); + + if (ssrContext === null) { + console.error('[css-render/vue3-ssr]: no ssr context found.'); + return; + } + + const { + styles, + ids + } = ssrContext; // we need to impl other options to make it behaves the same as the client side + + if (ids.has(id)) return; + + if (styles !== null) { + ids.add(id); + styles.push(createStyleString(id, style)); + } + } + + const isBrowser = typeof document !== 'undefined'; + function useSsrAdapter() { + if (isBrowser) return undefined; + const context = vue.inject(ssrContextKey, null); + if (context === null) return undefined; + return { + adapter: ssrAdapter, + context + }; + } + + function warn(location, message) { + console.error(`[vueuc/${location}]: ${message}`); + } + + const { + c + } = CssRender(); + const cssrAnchorMetaName$1 = 'vueuc-style'; + + function lowBit(n) { + return n & -n; + } + + class FinweckTree { + /** + * @param l length of the array + * @param min min value of the array + */ + constructor(l, min) { + this.l = l; + this.min = min; + const ft = new Array(l + 1); + + for (let i = 0; i < l + 1; ++i) { + ft[i] = 0; + } + + this.ft = ft; + } + /** + * Add arr[i] by n, start from 0 + * @param i the index of the element to be added + * @param n the value to be added + */ + + + add(i, n) { + if (n === 0) return; + const { + l, + ft + } = this; + i += 1; + + while (i <= l) { + ft[i] += n; + i += lowBit(i); + } + } + /** + * Get the value of index i + * @param i index + * @returns value of the index + */ + + + get(i) { + return this.sum(i + 1) - this.sum(i); + } + /** + * Get the sum of first i elements + * @param i count of head elements to be added + * @returns the sum of first i elements + */ + + + sum(i) { + if (i === undefined) i = this.l; + if (i <= 0) return 0; + const { + ft, + min, + l + } = this; + if (i > l) throw new Error('[FinweckTree.sum]: `i` is larger than length.'); + let ret = i * min; + + while (i > 0) { + ret += ft[i]; + i -= lowBit(i); + } + + return ret; + } + /** + * Get the largest count of head elements whose sum are <= threshold + * @param threshold + * @returns the largest count of head elements whose sum are <= threshold + */ + + + getBound(threshold) { + let l = 0; + let r = this.l; + + while (r > l) { + const m = Math.floor((l + r) / 2); + const sumM = this.sum(m); + + if (sumM > threshold) { + r = m; + continue; + } else if (sumM < threshold) { + if (l === m) { + if (this.sum(l + 1) <= threshold) return l + 1; + return m; + } + + l = m; + } else { + return m; + } + } + + return l; + } + + } + + function resolveTo(selector) { + if (typeof selector === 'string') { + return document.querySelector(selector); + } + + return selector(); + } + + var LazyTeleport = vue.defineComponent({ + name: 'LazyTeleport', + props: { + to: { + type: [String, Object], + default: undefined + }, + disabled: Boolean, + show: { + type: Boolean, + required: true + } + }, + + setup(props) { + return { + showTeleport: useFalseUntilTruthy(vue.toRef(props, 'show')), + mergedTo: vue.computed(() => { + const { + to + } = props; + return to !== null && to !== void 0 ? to : 'body'; + }) + }; + }, + + render() { + return this.showTeleport ? this.disabled ? getSlot('lazy-teleport', this.$slots) : vue.h(vue.Teleport, { + disabled: this.disabled, + to: this.mergedTo + }, getSlot('lazy-teleport', this.$slots)) : null; + } + + }); + + const oppositionPositions = { + top: 'bottom', + bottom: 'top', + left: 'right', + right: 'left' + }; + const oppositeAligns = { + start: 'end', + center: 'center', + end: 'start' + }; + const propToCompare = { + top: 'height', + bottom: 'height', + left: 'width', + right: 'width' + }; + const transformOrigins = { + 'bottom-start': 'top left', + bottom: 'top center', + 'bottom-end': 'top right', + 'top-start': 'bottom left', + top: 'bottom center', + 'top-end': 'bottom right', + 'right-start': 'top left', + right: 'center left', + 'right-end': 'bottom left', + 'left-start': 'top right', + left: 'center right', + 'left-end': 'bottom right' + }; + const overlapTransformOrigin = { + 'bottom-start': 'bottom left', + bottom: 'bottom center', + 'bottom-end': 'bottom right', + 'top-start': 'top left', + top: 'top center', + 'top-end': 'top right', + 'right-start': 'top right', + right: 'center right', + 'right-end': 'bottom right', + 'left-start': 'top left', + left: 'center left', + 'left-end': 'bottom left' + }; + const oppositeAlignCssPositionProps = { + 'bottom-start': 'right', + 'bottom-end': 'left', + 'top-start': 'right', + 'top-end': 'left', + 'right-start': 'bottom', + 'right-end': 'top', + 'left-start': 'bottom', + 'left-end': 'top' + }; + const keepOffsetDirection = { + top: true, + bottom: false, + left: true, + right: false // left-- + + }; + const cssPositionToOppositeAlign = { + top: 'end', + bottom: 'start', + left: 'end', + right: 'start' + }; + function getPlacementAndOffsetOfFollower(placement, targetRect, followerRect, shift, flip, overlap) { + if (!flip || overlap) { + return { + placement: placement, + top: 0, + left: 0 + }; + } + + const [position, align] = placement.split('-'); + let properAlign = align !== null && align !== void 0 ? align : 'center'; + let properOffset = { + top: 0, + left: 0 + }; + + const deriveOffset = (oppositeAlignCssSizeProp, alignCssPositionProp, offsetVertically) => { + let left = 0; + let top = 0; + const diff = followerRect[oppositeAlignCssSizeProp] - targetRect[alignCssPositionProp] - targetRect[oppositeAlignCssSizeProp]; + + if (diff > 0 && shift) { + if (offsetVertically) { + // screen border + // |-----------------------------------------| + // | | f | | + // | | o | | + // | | l | | + // | | l |---- | + // | | o |tar | | + // | | w |get | | + // | | e | | | + // | | r |---- | + // | ---- | + // |-----------------------------------------| + top = keepOffsetDirection[alignCssPositionProp] ? diff : -diff; + } else { + // screen border + // |----------------------------------------| + // | | + // | ---------- | + // | | target | | + // | ---------------------------------- + // | | follower | + // | ---------------------------------- + // | | + // |----------------------------------------| + left = keepOffsetDirection[alignCssPositionProp] ? diff : -diff; + } + } + + return { + left, + top + }; + }; + + const offsetVertically = position === 'left' || position === 'right'; // choose proper placement for non-center align + + if (properAlign !== 'center') { + const oppositeAlignCssPositionProp = oppositeAlignCssPositionProps[placement]; + const currentAlignCssPositionProp = oppositionPositions[oppositeAlignCssPositionProp]; + const oppositeAlignCssSizeProp = propToCompare[oppositeAlignCssPositionProp]; // if follower rect is larger than target rect in align direction + // ----------[ target ]---------| + // ----------[ follower ] + + if (followerRect[oppositeAlignCssSizeProp] > targetRect[oppositeAlignCssSizeProp]) { + if ( // current space is not enough + // ----------[ target ]---------| + // -------[ follower ] + targetRect[oppositeAlignCssPositionProp] + targetRect[oppositeAlignCssSizeProp] < followerRect[oppositeAlignCssSizeProp]) { + const followerOverTargetSize = (followerRect[oppositeAlignCssSizeProp] - targetRect[oppositeAlignCssSizeProp]) / 2; + + if (targetRect[oppositeAlignCssPositionProp] < followerOverTargetSize || targetRect[currentAlignCssPositionProp] < followerOverTargetSize) { + // opposite align has larger space + // -------[ target ]-----------| + // -------[ follower ]-| + if (targetRect[oppositeAlignCssPositionProp] < targetRect[currentAlignCssPositionProp]) { + properAlign = oppositeAligns[align]; + properOffset = deriveOffset(oppositeAlignCssSizeProp, currentAlignCssPositionProp, offsetVertically); + } else { + // ----------------[ target ]----| + // --------[ follower ]----| + properOffset = deriveOffset(oppositeAlignCssSizeProp, oppositeAlignCssPositionProp, offsetVertically); + } + } else { + // 'center' align is better + // ------------[ target ]--------| + // -------[ follower ]--| + properAlign = 'center'; + } + } + } else if (followerRect[oppositeAlignCssSizeProp] < targetRect[oppositeAlignCssSizeProp]) { + // TODO: maybe center is better + if (targetRect[currentAlignCssPositionProp] < 0 && // opposite align has larger space + // ------------[ target ] + // ----------------[follower] + targetRect[oppositeAlignCssPositionProp] > targetRect[currentAlignCssPositionProp]) { + properAlign = oppositeAligns[align]; + } + } + } else { + const possibleAlternativeAlignCssPositionProp1 = position === 'bottom' || position === 'top' ? 'left' : 'top'; + const possibleAlternativeAlignCssPositionProp2 = oppositionPositions[possibleAlternativeAlignCssPositionProp1]; + const alternativeAlignCssSizeProp = propToCompare[possibleAlternativeAlignCssPositionProp1]; + const followerOverTargetSize = (followerRect[alternativeAlignCssSizeProp] - targetRect[alternativeAlignCssSizeProp]) / 2; + + if ( // center is not enough + // ----------- [ target ]--| + // -------[ follower ] + targetRect[possibleAlternativeAlignCssPositionProp1] < followerOverTargetSize || targetRect[possibleAlternativeAlignCssPositionProp2] < followerOverTargetSize) { + // alternative 2 position's space is larger + if (targetRect[possibleAlternativeAlignCssPositionProp1] > targetRect[possibleAlternativeAlignCssPositionProp2]) { + properAlign = cssPositionToOppositeAlign[possibleAlternativeAlignCssPositionProp1]; + properOffset = deriveOffset(alternativeAlignCssSizeProp, possibleAlternativeAlignCssPositionProp1, offsetVertically); + } else { + // alternative 1 position's space is larger + properAlign = cssPositionToOppositeAlign[possibleAlternativeAlignCssPositionProp2]; + properOffset = deriveOffset(alternativeAlignCssSizeProp, possibleAlternativeAlignCssPositionProp2, offsetVertically); + } + } + } + + let properPosition = position; + + if ( // space is not enough + targetRect[position] < followerRect[propToCompare[position]] && // opposite position's space is larger + targetRect[position] < targetRect[oppositionPositions[position]]) { + properPosition = oppositionPositions[position]; + } + + return { + placement: properAlign !== 'center' ? `${properPosition}-${properAlign}` : properPosition, + left: properOffset.left, + top: properOffset.top + }; + } + function getProperTransformOrigin(placement, overlap) { + if (overlap) return overlapTransformOrigin[placement]; + return transformOrigins[placement]; + } // ------------ + // | offset | + // | | + // | [target] | + // | | + // ------------ + // TODO: refactor it to remove dup logic + + function getOffset$1(placement, offsetRect, targetRect, offsetTopToStandardPlacement, offsetLeftToStandardPlacement, overlap) { + if (overlap) { + switch (placement) { + case 'bottom-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`, + left: `${Math.round(targetRect.left - offsetRect.left)}px`, + transform: 'translateY(-100%)' + }; + + case 'bottom-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`, + transform: 'translateX(-100%) translateY(-100%)' + }; + + case 'top-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top)}px`, + left: `${Math.round(targetRect.left - offsetRect.left)}px`, + transform: '' + }; + + case 'top-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`, + transform: 'translateX(-100%)' + }; + + case 'right-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`, + transform: 'translateX(-100%)' + }; + + case 'right-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`, + transform: 'translateX(-100%) translateY(-100%)' + }; + + case 'left-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top)}px`, + left: `${Math.round(targetRect.left - offsetRect.left)}px`, + transform: '' + }; + + case 'left-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`, + left: `${Math.round(targetRect.left - offsetRect.left)}px`, + transform: 'translateY(-100%)' + }; + + case 'top': + return { + top: `${Math.round(targetRect.top - offsetRect.top)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2)}px`, + transform: 'translateX(-50%)' + }; + + case 'right': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`, + transform: 'translateX(-100%) translateY(-50%)' + }; + + case 'left': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2)}px`, + left: `${Math.round(targetRect.left - offsetRect.left)}px`, + transform: 'translateY(-50%)' + }; + + case 'bottom': + default: + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2)}px`, + transform: 'translateX(-50%) translateY(-100%)' + }; + } + } + + switch (placement) { + case 'bottom-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`, + transform: '' + }; + + case 'bottom-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width + offsetLeftToStandardPlacement)}px`, + transform: 'translateX(-100%)' + }; + + case 'top-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`, + transform: 'translateY(-100%)' + }; + + case 'top-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width + offsetLeftToStandardPlacement)}px`, + transform: 'translateX(-100%) translateY(-100%)' + }; + + case 'right-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width + offsetLeftToStandardPlacement)}px`, + transform: '' + }; + + case 'right-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width + offsetLeftToStandardPlacement)}px`, + transform: 'translateY(-100%)' + }; + + case 'left-start': + return { + top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`, + transform: 'translateX(-100%)' + }; + + case 'left-end': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`, + transform: 'translateX(-100%) translateY(-100%)' + }; + + case 'top': + return { + top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2 + offsetLeftToStandardPlacement)}px`, + transform: 'translateY(-100%) translateX(-50%)' + }; + + case 'right': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2 + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width + offsetLeftToStandardPlacement)}px`, + transform: 'translateY(-50%)' + }; + + case 'left': + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2 + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`, + transform: 'translateY(-50%) translateX(-100%)' + }; + + case 'bottom': + default: + return { + top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height + offsetTopToStandardPlacement)}px`, + left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2 + offsetLeftToStandardPlacement)}px`, + transform: 'translateX(-50%)' + }; + } + } + + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + const style$1B = c([c('.v-binder-follower-container', { + position: 'absolute', + left: '0', + right: '0', + top: '0', + height: '0', + pointerEvents: 'none', + zIndex: 'auto' + }), c('.v-binder-follower-content', { + position: 'absolute', + zIndex: 'auto' + }, [c('> *', { + pointerEvents: 'all' + })])]); + var VFollower = vue.defineComponent({ + name: 'Follower', + inheritAttrs: false, + props: { + show: Boolean, + enabled: { + type: Boolean, + default: undefined + }, + placement: { + type: String, + default: 'bottom' + }, + syncTrigger: { + type: Array, + default: ['resize', 'scroll'] + }, + to: [String, Object], + flip: { + type: Boolean, + default: true + }, + internalShift: Boolean, + x: Number, + y: Number, + width: String, + minWidth: String, + containerClass: String, + teleportDisabled: Boolean, + zindexable: { + type: Boolean, + default: true + }, + zIndex: Number, + overlap: Boolean + }, + + setup(props) { + const VBinder = vue.inject('VBinder'); + const mergedEnabledRef = useMemo(() => { + return props.enabled !== undefined ? props.enabled : props.show; + }); + const followerRef = vue.ref(null); + const offsetContainerRef = vue.ref(null); + + const ensureListeners = () => { + const { + syncTrigger + } = props; + + if (syncTrigger.includes('scroll')) { + VBinder.addScrollListener(syncPosition); + } + + if (syncTrigger.includes('resize')) { + VBinder.addResizeListener(syncPosition); + } + }; + + const removeListeners = () => { + VBinder.removeScrollListener(syncPosition); + VBinder.removeResizeListener(syncPosition); + }; + + vue.onMounted(() => { + if (mergedEnabledRef.value) { + syncPosition(); + ensureListeners(); + } + }); + const ssrAdapter = useSsrAdapter(); + style$1B.mount({ + id: 'vueuc/binder', + head: true, + anchorMetaName: cssrAnchorMetaName$1, + ssr: ssrAdapter + }); + vue.onBeforeUnmount(() => { + removeListeners(); + }); + onFontsReady(() => { + if (mergedEnabledRef.value) { + syncPosition(); + } + }); + + const syncPosition = () => { + if (!mergedEnabledRef.value) { + return; + } + + const follower = followerRef.value; // sometimes watched props change before its dom is ready + // for example: show=false, x=undefined, y=undefined + // show=true, x=0, y=0 + // will cause error + // I may optimize the watch start point later + + if (follower === null) return; + const target = VBinder.targetRef; + const { + x, + y, + overlap + } = props; + const targetRect = x !== undefined && y !== undefined ? getPointRect(x, y) : getRect$1(target); + follower.style.setProperty('--v-target-width', `${Math.round(targetRect.width)}px`); + follower.style.setProperty('--v-target-height', `${Math.round(targetRect.height)}px`); + const { + width, + minWidth, + placement, + internalShift, + flip + } = props; + follower.setAttribute('v-placement', placement); + + if (overlap) { + follower.setAttribute('v-overlap', ''); + } else { + follower.removeAttribute('v-overlap'); + } + + const { + style + } = follower; + + if (width === 'target') { + style.width = `${targetRect.width}px`; + } else if (width !== undefined) { + style.width = width; + } else { + style.width = ''; + } + + if (minWidth === 'target') { + style.minWidth = `${targetRect.width}px`; + } else if (minWidth !== undefined) { + style.minWidth = minWidth; + } else { + style.minWidth = ''; + } + + const followerRect = getRect$1(follower); + const offsetContainerRect = getRect$1(offsetContainerRef.value); + const { + left: offsetLeftToStandardPlacement, + top: offsetTopToStandardPlacement, + placement: properPlacement + } = getPlacementAndOffsetOfFollower(placement, targetRect, followerRect, internalShift, flip, overlap); + const properTransformOrigin = getProperTransformOrigin(properPlacement, overlap); + const { + left, + top, + transform + } = getOffset$1(properPlacement, offsetContainerRect, targetRect, offsetTopToStandardPlacement, offsetLeftToStandardPlacement, overlap); // we assume that the content size doesn't change after flip, + // nor we need to make sync logic more complex + + follower.setAttribute('v-placement', properPlacement); + follower.style.setProperty('--v-offset-left', `${Math.round(offsetLeftToStandardPlacement)}px`); + follower.style.setProperty('--v-offset-top', `${Math.round(offsetTopToStandardPlacement)}px`); + follower.style.transform = `translateX(${left}) translateY(${top}) ${transform}`; + follower.style.setProperty('--v-transform-origin', properTransformOrigin); + follower.style.transformOrigin = properTransformOrigin; + }; + + vue.watch(mergedEnabledRef, value => { + if (value) { + ensureListeners(); + syncOnNextTick(); + } else { + removeListeners(); + } + }); + + const syncOnNextTick = () => { + vue.nextTick().then(syncPosition).catch(e => console.error(e)); + }; + + ['placement', 'x', 'y', 'internalShift', 'flip', 'width', 'overlap', 'minWidth'].forEach(prop => { + vue.watch(vue.toRef(props, prop), syncPosition); + }); + ['teleportDisabled'].forEach(prop => { + vue.watch(vue.toRef(props, prop), syncOnNextTick); + }); + vue.watch(vue.toRef(props, 'syncTrigger'), value => { + if (!value.includes('resize')) { + VBinder.removeResizeListener(syncPosition); + } else { + VBinder.addResizeListener(syncPosition); + } + + if (!value.includes('scroll')) { + VBinder.removeScrollListener(syncPosition); + } else { + VBinder.addScrollListener(syncPosition); + } + }); + const isMountedRef = isMounted(); + const mergedToRef = useMemo(() => { + const { + to + } = props; + if (to !== undefined) return to; + + if (isMountedRef.value) { + // TODO: find proper container + return undefined; + } + + return undefined; + }); + return { + VBinder, + mergedEnabled: mergedEnabledRef, + offsetContainerRef, + followerRef, + mergedTo: mergedToRef, + syncPosition + }; + }, + + render() { + return vue.h(LazyTeleport, { + show: this.show, + to: this.mergedTo, + disabled: this.teleportDisabled + }, { + default: () => { + var _a, _b; + + const vNode = vue.h('div', { + class: ['v-binder-follower-container', this.containerClass], + ref: 'offsetContainerRef' + }, [vue.h('div', { + class: 'v-binder-follower-content', + ref: 'followerRef' + }, (_b = (_a = this.$slots).default) === null || _b === void 0 ? void 0 : _b.call(_a))]); + + if (this.zindexable) { + return vue.withDirectives(vNode, [[zindexable$1, { + enabled: this.mergedEnabled, + zIndex: this.zIndex + }]]); + } + + return vNode; + } + }); + } + + }); + + var resizeObservers = []; + + var hasActiveObservations = function () { + return resizeObservers.some(function (ro) { + return ro.activeTargets.length > 0; + }); + }; + + var hasSkippedObservations = function () { + return resizeObservers.some(function (ro) { + return ro.skippedTargets.length > 0; + }); + }; + + var msg = 'ResizeObserver loop completed with undelivered notifications.'; + + var deliverResizeLoopError = function () { + var event; + + if (typeof ErrorEvent === 'function') { + event = new ErrorEvent('error', { + message: msg + }); + } else { + event = document.createEvent('Event'); + event.initEvent('error', false, false); + event.message = msg; + } + + window.dispatchEvent(event); + }; + + var ResizeObserverBoxOptions; + + (function (ResizeObserverBoxOptions) { + ResizeObserverBoxOptions["BORDER_BOX"] = "border-box"; + ResizeObserverBoxOptions["CONTENT_BOX"] = "content-box"; + ResizeObserverBoxOptions["DEVICE_PIXEL_CONTENT_BOX"] = "device-pixel-content-box"; + })(ResizeObserverBoxOptions || (ResizeObserverBoxOptions = {})); + + var freeze = function (obj) { + return Object.freeze(obj); + }; + + var ResizeObserverSize = function () { + function ResizeObserverSize(inlineSize, blockSize) { + this.inlineSize = inlineSize; + this.blockSize = blockSize; + freeze(this); + } + + return ResizeObserverSize; + }(); + + var DOMRectReadOnly = function () { + function DOMRectReadOnly(x, y, width, height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + this.top = this.y; + this.left = this.x; + this.bottom = this.top + this.height; + this.right = this.left + this.width; + return freeze(this); + } + + DOMRectReadOnly.prototype.toJSON = function () { + var _a = this, + x = _a.x, + y = _a.y, + top = _a.top, + right = _a.right, + bottom = _a.bottom, + left = _a.left, + width = _a.width, + height = _a.height; + + return { + x: x, + y: y, + top: top, + right: right, + bottom: bottom, + left: left, + width: width, + height: height + }; + }; + + DOMRectReadOnly.fromRect = function (rectangle) { + return new DOMRectReadOnly(rectangle.x, rectangle.y, rectangle.width, rectangle.height); + }; + + return DOMRectReadOnly; + }(); + + var isSVG = function (target) { + return target instanceof SVGElement && 'getBBox' in target; + }; + + var isHidden = function (target) { + if (isSVG(target)) { + var _a = target.getBBox(), + width = _a.width, + height = _a.height; + + return !width && !height; + } + + var _b = target, + offsetWidth = _b.offsetWidth, + offsetHeight = _b.offsetHeight; + return !(offsetWidth || offsetHeight || target.getClientRects().length); + }; + + var isElement = function (obj) { + var _a, _b; + + if (obj instanceof Element) { + return true; + } + + var scope = (_b = (_a = obj) === null || _a === void 0 ? void 0 : _a.ownerDocument) === null || _b === void 0 ? void 0 : _b.defaultView; + return !!(scope && obj instanceof scope.Element); + }; + + var isReplacedElement = function (target) { + switch (target.tagName) { + case 'INPUT': + if (target.type !== 'image') { + break; + } + + case 'VIDEO': + case 'AUDIO': + case 'EMBED': + case 'OBJECT': + case 'CANVAS': + case 'IFRAME': + case 'IMG': + return true; + } + + return false; + }; + + var global$1 = typeof window !== 'undefined' ? window : {}; + + var cache = new WeakMap(); + var scrollRegexp = /auto|scroll/; + var verticalRegexp = /^tb|vertical/; + var IE = /msie|trident/i.test(global$1.navigator && global$1.navigator.userAgent); + + var parseDimension = function (pixel) { + return parseFloat(pixel || '0'); + }; + + var size = function (inlineSize, blockSize, switchSizes) { + if (inlineSize === void 0) { + inlineSize = 0; + } + + if (blockSize === void 0) { + blockSize = 0; + } + + if (switchSizes === void 0) { + switchSizes = false; + } + + return new ResizeObserverSize((switchSizes ? blockSize : inlineSize) || 0, (switchSizes ? inlineSize : blockSize) || 0); + }; + + var zeroBoxes = freeze({ + devicePixelContentBoxSize: size(), + borderBoxSize: size(), + contentBoxSize: size(), + contentRect: new DOMRectReadOnly(0, 0, 0, 0) + }); + + var calculateBoxSizes = function (target, forceRecalculation) { + if (forceRecalculation === void 0) { + forceRecalculation = false; + } + + if (cache.has(target) && !forceRecalculation) { + return cache.get(target); + } + + if (isHidden(target)) { + cache.set(target, zeroBoxes); + return zeroBoxes; + } + + var cs = getComputedStyle(target); + var svg = isSVG(target) && target.ownerSVGElement && target.getBBox(); + var removePadding = !IE && cs.boxSizing === 'border-box'; + var switchSizes = verticalRegexp.test(cs.writingMode || ''); + var canScrollVertically = !svg && scrollRegexp.test(cs.overflowY || ''); + var canScrollHorizontally = !svg && scrollRegexp.test(cs.overflowX || ''); + var paddingTop = svg ? 0 : parseDimension(cs.paddingTop); + var paddingRight = svg ? 0 : parseDimension(cs.paddingRight); + var paddingBottom = svg ? 0 : parseDimension(cs.paddingBottom); + var paddingLeft = svg ? 0 : parseDimension(cs.paddingLeft); + var borderTop = svg ? 0 : parseDimension(cs.borderTopWidth); + var borderRight = svg ? 0 : parseDimension(cs.borderRightWidth); + var borderBottom = svg ? 0 : parseDimension(cs.borderBottomWidth); + var borderLeft = svg ? 0 : parseDimension(cs.borderLeftWidth); + var horizontalPadding = paddingLeft + paddingRight; + var verticalPadding = paddingTop + paddingBottom; + var horizontalBorderArea = borderLeft + borderRight; + var verticalBorderArea = borderTop + borderBottom; + var horizontalScrollbarThickness = !canScrollHorizontally ? 0 : target.offsetHeight - verticalBorderArea - target.clientHeight; + var verticalScrollbarThickness = !canScrollVertically ? 0 : target.offsetWidth - horizontalBorderArea - target.clientWidth; + var widthReduction = removePadding ? horizontalPadding + horizontalBorderArea : 0; + var heightReduction = removePadding ? verticalPadding + verticalBorderArea : 0; + var contentWidth = svg ? svg.width : parseDimension(cs.width) - widthReduction - verticalScrollbarThickness; + var contentHeight = svg ? svg.height : parseDimension(cs.height) - heightReduction - horizontalScrollbarThickness; + var borderBoxWidth = contentWidth + horizontalPadding + verticalScrollbarThickness + horizontalBorderArea; + var borderBoxHeight = contentHeight + verticalPadding + horizontalScrollbarThickness + verticalBorderArea; + var boxes = freeze({ + devicePixelContentBoxSize: size(Math.round(contentWidth * devicePixelRatio), Math.round(contentHeight * devicePixelRatio), switchSizes), + borderBoxSize: size(borderBoxWidth, borderBoxHeight, switchSizes), + contentBoxSize: size(contentWidth, contentHeight, switchSizes), + contentRect: new DOMRectReadOnly(paddingLeft, paddingTop, contentWidth, contentHeight) + }); + cache.set(target, boxes); + return boxes; + }; + + var calculateBoxSize = function (target, observedBox, forceRecalculation) { + var _a = calculateBoxSizes(target, forceRecalculation), + borderBoxSize = _a.borderBoxSize, + contentBoxSize = _a.contentBoxSize, + devicePixelContentBoxSize = _a.devicePixelContentBoxSize; + + switch (observedBox) { + case ResizeObserverBoxOptions.DEVICE_PIXEL_CONTENT_BOX: + return devicePixelContentBoxSize; + + case ResizeObserverBoxOptions.BORDER_BOX: + return borderBoxSize; + + default: + return contentBoxSize; + } + }; + + var ResizeObserverEntry = function () { + function ResizeObserverEntry(target) { + var boxes = calculateBoxSizes(target); + this.target = target; + this.contentRect = boxes.contentRect; + this.borderBoxSize = freeze([boxes.borderBoxSize]); + this.contentBoxSize = freeze([boxes.contentBoxSize]); + this.devicePixelContentBoxSize = freeze([boxes.devicePixelContentBoxSize]); + } + + return ResizeObserverEntry; + }(); + + var calculateDepthForNode = function (node) { + if (isHidden(node)) { + return Infinity; + } + + var depth = 0; + var parent = node.parentNode; + + while (parent) { + depth += 1; + parent = parent.parentNode; + } + + return depth; + }; + + var broadcastActiveObservations = function () { + var shallowestDepth = Infinity; + var callbacks = []; + resizeObservers.forEach(function processObserver(ro) { + if (ro.activeTargets.length === 0) { + return; + } + + var entries = []; + ro.activeTargets.forEach(function processTarget(ot) { + var entry = new ResizeObserverEntry(ot.target); + var targetDepth = calculateDepthForNode(ot.target); + entries.push(entry); + ot.lastReportedSize = calculateBoxSize(ot.target, ot.observedBox); + + if (targetDepth < shallowestDepth) { + shallowestDepth = targetDepth; + } + }); + callbacks.push(function resizeObserverCallback() { + ro.callback.call(ro.observer, entries, ro.observer); + }); + ro.activeTargets.splice(0, ro.activeTargets.length); + }); + + for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) { + var callback = callbacks_1[_i]; + callback(); + } + + return shallowestDepth; + }; + + var gatherActiveObservationsAtDepth = function (depth) { + resizeObservers.forEach(function processObserver(ro) { + ro.activeTargets.splice(0, ro.activeTargets.length); + ro.skippedTargets.splice(0, ro.skippedTargets.length); + ro.observationTargets.forEach(function processTarget(ot) { + if (ot.isActive()) { + if (calculateDepthForNode(ot.target) > depth) { + ro.activeTargets.push(ot); + } else { + ro.skippedTargets.push(ot); + } + } + }); + }); + }; + + var process$1 = function () { + var depth = 0; + gatherActiveObservationsAtDepth(depth); + + while (hasActiveObservations()) { + depth = broadcastActiveObservations(); + gatherActiveObservationsAtDepth(depth); + } + + if (hasSkippedObservations()) { + deliverResizeLoopError(); + } + + return depth > 0; + }; + + var trigger; + var callbacks = []; + + var notify = function () { + return callbacks.splice(0).forEach(function (cb) { + return cb(); + }); + }; + + var queueMicroTask = function (callback) { + if (!trigger) { + var toggle_1 = 0; + var el_1 = document.createTextNode(''); + var config = { + characterData: true + }; + new MutationObserver(function () { + return notify(); + }).observe(el_1, config); + + trigger = function () { + el_1.textContent = "" + (toggle_1 ? toggle_1-- : toggle_1++); + }; + } + + callbacks.push(callback); + trigger(); + }; + + var queueResizeObserver = function (cb) { + queueMicroTask(function ResizeObserver() { + requestAnimationFrame(cb); + }); + }; + + var watching = 0; + + var isWatching = function () { + return !!watching; + }; + + var CATCH_PERIOD = 250; + var observerConfig = { + attributes: true, + characterData: true, + childList: true, + subtree: true + }; + var events = ['resize', 'load', 'transitionend', 'animationend', 'animationstart', 'animationiteration', 'keyup', 'keydown', 'mouseup', 'mousedown', 'mouseover', 'mouseout', 'blur', 'focus']; + + var time$1 = function (timeout) { + if (timeout === void 0) { + timeout = 0; + } + + return Date.now() + timeout; + }; + + var scheduled = false; + + var Scheduler = function () { + function Scheduler() { + var _this = this; + + this.stopped = true; + + this.listener = function () { + return _this.schedule(); + }; + } + + Scheduler.prototype.run = function (timeout) { + var _this = this; + + if (timeout === void 0) { + timeout = CATCH_PERIOD; + } + + if (scheduled) { + return; + } + + scheduled = true; + var until = time$1(timeout); + queueResizeObserver(function () { + var elementsHaveResized = false; + + try { + elementsHaveResized = process$1(); + } finally { + scheduled = false; + timeout = until - time$1(); + + if (!isWatching()) { + return; + } + + if (elementsHaveResized) { + _this.run(1000); + } else if (timeout > 0) { + _this.run(timeout); + } else { + _this.start(); + } + } + }); + }; + + Scheduler.prototype.schedule = function () { + this.stop(); + this.run(); + }; + + Scheduler.prototype.observe = function () { + var _this = this; + + var cb = function () { + return _this.observer && _this.observer.observe(document.body, observerConfig); + }; + + document.body ? cb() : global$1.addEventListener('DOMContentLoaded', cb); + }; + + Scheduler.prototype.start = function () { + var _this = this; + + if (this.stopped) { + this.stopped = false; + this.observer = new MutationObserver(this.listener); + this.observe(); + events.forEach(function (name) { + return global$1.addEventListener(name, _this.listener, true); + }); + } + }; + + Scheduler.prototype.stop = function () { + var _this = this; + + if (!this.stopped) { + this.observer && this.observer.disconnect(); + events.forEach(function (name) { + return global$1.removeEventListener(name, _this.listener, true); + }); + this.stopped = true; + } + }; + + return Scheduler; + }(); + + var scheduler = new Scheduler(); + + var updateCount = function (n) { + !watching && n > 0 && scheduler.start(); + watching += n; + !watching && scheduler.stop(); + }; + + var skipNotifyOnElement = function (target) { + return !isSVG(target) && !isReplacedElement(target) && getComputedStyle(target).display === 'inline'; + }; + + var ResizeObservation = function () { + function ResizeObservation(target, observedBox) { + this.target = target; + this.observedBox = observedBox || ResizeObserverBoxOptions.CONTENT_BOX; + this.lastReportedSize = { + inlineSize: 0, + blockSize: 0 + }; + } + + ResizeObservation.prototype.isActive = function () { + var size = calculateBoxSize(this.target, this.observedBox, true); + + if (skipNotifyOnElement(this.target)) { + this.lastReportedSize = size; + } + + if (this.lastReportedSize.inlineSize !== size.inlineSize || this.lastReportedSize.blockSize !== size.blockSize) { + return true; + } + + return false; + }; + + return ResizeObservation; + }(); + + var ResizeObserverDetail = function () { + function ResizeObserverDetail(resizeObserver, callback) { + this.activeTargets = []; + this.skippedTargets = []; + this.observationTargets = []; + this.observer = resizeObserver; + this.callback = callback; + } + + return ResizeObserverDetail; + }(); + + var observerMap = new WeakMap(); + + var getObservationIndex = function (observationTargets, target) { + for (var i = 0; i < observationTargets.length; i += 1) { + if (observationTargets[i].target === target) { + return i; + } + } + + return -1; + }; + + var ResizeObserverController = function () { + function ResizeObserverController() {} + + ResizeObserverController.connect = function (resizeObserver, callback) { + var detail = new ResizeObserverDetail(resizeObserver, callback); + observerMap.set(resizeObserver, detail); + }; + + ResizeObserverController.observe = function (resizeObserver, target, options) { + var detail = observerMap.get(resizeObserver); + var firstObservation = detail.observationTargets.length === 0; + + if (getObservationIndex(detail.observationTargets, target) < 0) { + firstObservation && resizeObservers.push(detail); + detail.observationTargets.push(new ResizeObservation(target, options && options.box)); + updateCount(1); + scheduler.schedule(); + } + }; + + ResizeObserverController.unobserve = function (resizeObserver, target) { + var detail = observerMap.get(resizeObserver); + var index = getObservationIndex(detail.observationTargets, target); + var lastObservation = detail.observationTargets.length === 1; + + if (index >= 0) { + lastObservation && resizeObservers.splice(resizeObservers.indexOf(detail), 1); + detail.observationTargets.splice(index, 1); + updateCount(-1); + } + }; + + ResizeObserverController.disconnect = function (resizeObserver) { + var _this = this; + + var detail = observerMap.get(resizeObserver); + detail.observationTargets.slice().forEach(function (ot) { + return _this.unobserve(resizeObserver, ot.target); + }); + detail.activeTargets.splice(0, detail.activeTargets.length); + }; + + return ResizeObserverController; + }(); + + var ResizeObserver = function () { + function ResizeObserver(callback) { + if (arguments.length === 0) { + throw new TypeError("Failed to construct 'ResizeObserver': 1 argument required, but only 0 present."); + } + + if (typeof callback !== 'function') { + throw new TypeError("Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function."); + } + + ResizeObserverController.connect(this, callback); + } + + ResizeObserver.prototype.observe = function (target, options) { + if (arguments.length === 0) { + throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present."); + } + + if (!isElement(target)) { + throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element"); + } + + ResizeObserverController.observe(this, target, options); + }; + + ResizeObserver.prototype.unobserve = function (target) { + if (arguments.length === 0) { + throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present."); + } + + if (!isElement(target)) { + throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element"); + } + + ResizeObserverController.unobserve(this, target); + }; + + ResizeObserver.prototype.disconnect = function () { + ResizeObserverController.disconnect(this); + }; + + ResizeObserver.toString = function () { + return 'function ResizeObserver () { [polyfill code] }'; + }; + + return ResizeObserver; + }(); + + class ResizeObserverDelegate { + constructor() { + this.handleResize = this.handleResize.bind(this); + this.observer = new ResizeObserver(this.handleResize); + this.elHandlersMap = new Map(); + } + + handleResize(entries) { + for (const entry of entries) { + const handler = this.elHandlersMap.get(entry.target); + + if (handler !== undefined) { + handler(entry); + } + } + } + + registerHandler(el, handler) { + this.elHandlersMap.set(el, handler); + this.observer.observe(el); + } + + unregisterHandler(el) { + if (!this.elHandlersMap.has(el)) { + return; + } + + this.elHandlersMap.delete(el); + this.observer.unobserve(el); + } + + } + + var resizeObserverManager = new ResizeObserverDelegate(); + + var VResizeObserver = vue.defineComponent({ + name: 'ResizeObserver', + props: { + onResize: Function + }, + + setup(props) { + let registered = false; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + + const proxy = vue.getCurrentInstance().proxy; + + function handleResize(entry) { + const { + onResize + } = props; + if (onResize !== undefined) onResize(entry); + } + + vue.onMounted(() => { + const el = proxy.$el; + + if (el === undefined) { + warn('resize-observer', '$el does not exist.'); + return; + } + + if (el.nextElementSibling !== el.nextSibling) { + if (el.nodeType === 3 && el.nodeValue !== '') { + warn('resize-observer', '$el can not be observed (it may be a text node).'); + return; + } + } + + if (el.nextElementSibling !== null) { + resizeObserverManager.registerHandler(el.nextElementSibling, handleResize); + registered = true; + } + }); + vue.onBeforeUnmount(() => { + if (registered) { + resizeObserverManager.unregisterHandler(proxy.$el.nextElementSibling); + } + }); + }, + + render() { + return vue.renderSlot(this.$slots, 'default'); + } + + }); + + let maybeTouch; + function ensureMaybeTouch() { + if (maybeTouch === undefined) { + if ('matchMedia' in window) { + maybeTouch = window.matchMedia('(pointer:coarse)').matches; + } else { + maybeTouch = false; + } + } + + return maybeTouch; + } + let wheelScale; + function ensureWheelScale() { + if (wheelScale === undefined) { + wheelScale = 'chrome' in window ? window.devicePixelRatio : 1; + } + + return wheelScale; + } + + /* eslint-disable no-void */ + const styles$1 = c('.v-vl', { + maxHeight: 'inherit', + height: '100%', + overflow: 'auto', + minWidth: '1px' // a zero width container won't be scrollable + + }, [c('&:not(.v-vl--show-scrollbar)', { + scrollbarWidth: 'none' + }, [c('&::-webkit-scrollbar, &::-webkit-scrollbar-track-piece, &::-webkit-scrollbar-thumb', { + width: 0, + height: 0, + display: 'none' + })])]); + var VVirtualList = vue.defineComponent({ + name: 'VirtualList', + inheritAttrs: false, + props: { + showScrollbar: { + type: Boolean, + default: true + }, + items: { + type: Array, + default: () => [] + }, + // it is suppose to be the min height + itemSize: { + type: Number, + required: true + }, + itemResizable: Boolean, + itemsStyle: [String, Object], + visibleItemsTag: { + type: [String, Object], + default: 'div' + }, + visibleItemsProps: Object, + ignoreItemResize: Boolean, + onScroll: Function, + onWheel: Function, + onResize: Function, + defaultScrollKey: [Number, String], + defaultScrollIndex: Number, + keyField: { + type: String, + default: 'key' + }, + // Whether it is a good API? + // ResizeObserver + footer & header is not enough. + // Too complex for simple case + paddingTop: { + type: [Number, String], + default: 0 + }, + paddingBottom: { + type: [Number, String], + default: 0 + } + }, + + setup(props) { + const ssrAdapter = useSsrAdapter(); + styles$1.mount({ + id: 'vueuc/virtual-list', + head: true, + anchorMetaName: cssrAnchorMetaName$1, + ssr: ssrAdapter + }); + vue.onMounted(() => { + const { + defaultScrollIndex, + defaultScrollKey + } = props; + + if (defaultScrollIndex !== undefined && defaultScrollIndex !== null) { + scrollTo({ + index: defaultScrollIndex + }); + } else if (defaultScrollKey !== undefined && defaultScrollKey !== null) { + scrollTo({ + key: defaultScrollKey + }); + } + }); + let isDeactivated = false; + let activateStateInitialized = false; + vue.onActivated(() => { + isDeactivated = false; + + if (!activateStateInitialized) { + activateStateInitialized = true; + return; + } // remount + + + scrollTo({ + top: scrollTopRef.value, + left: scrollLeft + }); + }); + vue.onDeactivated(() => { + isDeactivated = true; + + if (!activateStateInitialized) { + activateStateInitialized = true; + } + }); + const keyIndexMapRef = vue.computed(() => { + const map = new Map(); + const { + keyField + } = props; + props.items.forEach((item, index) => { + map.set(item[keyField], index); + }); + return map; + }); + const listElRef = vue.ref(null); + const listHeightRef = vue.ref(undefined); + const keyToHeightOffset = new Map(); + const finweckTreeRef = vue.computed(() => { + const { + items, + itemSize, + keyField + } = props; + const ft = new FinweckTree(items.length, itemSize); + items.forEach((item, index) => { + const key = item[keyField]; + const heightOffset = keyToHeightOffset.get(key); + + if (heightOffset !== undefined) { + ft.add(index, heightOffset); + } + }); + return ft; + }); + const finweckTreeUpdateTrigger = vue.ref(0); + let scrollLeft = 0; + const scrollTopRef = vue.ref(0); + const startIndexRef = useMemo(() => { + return Math.max(finweckTreeRef.value.getBound(scrollTopRef.value - depx(props.paddingTop)) - 1, 0); + }); + const viewportItemsRef = vue.computed(() => { + const { + value: listHeight + } = listHeightRef; + if (listHeight === undefined) return []; + const { + items, + itemSize + } = props; + const startIndex = startIndexRef.value; + const endIndex = Math.min(startIndex + Math.ceil(listHeight / itemSize + 1), items.length - 1); + const viewportItems = []; + + for (let i = startIndex; i <= endIndex; ++i) { + viewportItems.push(items[i]); + } + + return viewportItems; + }); + + const scrollTo = (options, y) => { + if (typeof options === 'number') { + scrollToPosition(options, y, 'auto'); + return; + } + + const { + left, + top, + index, + key, + position, + behavior, + debounce = true + } = options; + + if (left !== undefined || top !== undefined) { + scrollToPosition(left, top, behavior); + } else if (index !== undefined) { + scrollToIndex(index, behavior, debounce); + } else if (key !== undefined) { + const toIndex = keyIndexMapRef.value.get(key); + if (toIndex !== undefined) scrollToIndex(toIndex, behavior, debounce); + } else if (position === 'bottom') { + scrollToPosition(0, Number.MAX_SAFE_INTEGER, behavior); + } else if (position === 'top') { + scrollToPosition(0, 0, behavior); + } + }; + + let anchorIndex; + let anchorTimerId = null; + + function scrollToIndex(index, behavior, debounce) { + const { + value: ft + } = finweckTreeRef; + const targetTop = ft.sum(index) + depx(props.paddingTop); + + if (!debounce) { + listElRef.value.scrollTo({ + left: 0, + top: targetTop, + behavior + }); + } else { + anchorIndex = index; + + if (anchorTimerId !== null) { + window.clearTimeout(anchorTimerId); + } + + anchorTimerId = window.setTimeout(() => { + anchorIndex = undefined; + anchorTimerId = null; + }, 16); // use 0 ms may be ealier than resize callback... + + const { + scrollTop, + offsetHeight + } = listElRef.value; + + if (targetTop > scrollTop) { + const itemSize = ft.get(index); + + if (targetTop + itemSize <= scrollTop + offsetHeight) ; else { + listElRef.value.scrollTo({ + left: 0, + top: targetTop + itemSize - offsetHeight, + behavior + }); + } + } else { + listElRef.value.scrollTo({ + left: 0, + top: targetTop, + behavior + }); + } + } + } + + function scrollToPosition(left, top, behavior) { + listElRef.value.scrollTo({ + left, + top, + behavior + }); + } + + function handleItemResize(key, entry) { + var _a, _b, _c; + + if (isDeactivated) return; + if (props.ignoreItemResize) return; + if (isHideByVShow(entry.target)) return; + const { + value: ft + } = finweckTreeRef; + const index = keyIndexMapRef.value.get(key); + const previousHeight = ft.get(index); + const height = (_c = (_b = (_a = entry.borderBoxSize) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.blockSize) !== null && _c !== void 0 ? _c : entry.contentRect.height; + if (height === previousHeight) return; // height offset based on itemSize + // used when rebuild the finweck tree + + const offset = height - props.itemSize; + + if (offset === 0) { + keyToHeightOffset.delete(key); + } else { + keyToHeightOffset.set(key, height - props.itemSize); + } // delta height based on finweck tree data + + + const delta = height - previousHeight; + if (delta === 0) return; + ft.add(index, delta); + const listEl = listElRef.value; + + if (listEl != null) { + if (anchorIndex === undefined) { + const previousHeightSum = ft.sum(index); + + if (listEl.scrollTop > previousHeightSum) { + listEl.scrollBy(0, delta); + } + } else { + if (index < anchorIndex) { + listEl.scrollBy(0, delta); + } else if (index === anchorIndex) { + const previousHeightSum = ft.sum(index); + + if (height + previousHeightSum > // Note, listEl shouldn't have border, nor offsetHeight won't be + // correct + listEl.scrollTop + listEl.offsetHeight) { + listEl.scrollBy(0, delta); + } + } + } + + syncViewport(); + } + + finweckTreeUpdateTrigger.value++; + } + + const mayUseWheel = !ensureMaybeTouch(); + let wheelCatched = false; + + function handleListScroll(e) { + var _a; + + (_a = props.onScroll) === null || _a === void 0 ? void 0 : _a.call(props, e); + + if (!mayUseWheel || !wheelCatched) { + syncViewport(); + } + } + + function handleListWheel(e) { + var _a; + + (_a = props.onWheel) === null || _a === void 0 ? void 0 : _a.call(props, e); + + if (mayUseWheel) { + const listEl = listElRef.value; + + if (listEl != null) { + if (e.deltaX === 0) { + if (listEl.scrollTop === 0 && e.deltaY <= 0) { + return; + } + + if (listEl.scrollTop + listEl.offsetHeight >= listEl.scrollHeight && e.deltaY >= 0) { + return; + } + } + + e.preventDefault(); + listEl.scrollTop += e.deltaY / ensureWheelScale(); + listEl.scrollLeft += e.deltaX / ensureWheelScale(); + syncViewport(); + wheelCatched = true; + beforeNextFrameOnce(() => { + wheelCatched = false; + }); + } + } + } + + function handleListResize(entry) { + if (isDeactivated) return; // List is HTMLElement + + if (isHideByVShow(entry.target)) return; // If height is same, return + + if (entry.contentRect.height === listHeightRef.value) return; + listHeightRef.value = entry.contentRect.height; + const { + onResize + } = props; + if (onResize !== undefined) onResize(entry); + } + + function syncViewport() { + const { + value: listEl + } = listElRef; // sometime ref el can be null + // https://github.com/TuSimple/naive-ui/issues/811 + + if (listEl == null) return; + scrollTopRef.value = listEl.scrollTop; + scrollLeft = listEl.scrollLeft; + } + + function isHideByVShow(el) { + let cursor = el; + + while (cursor !== null) { + if (cursor.style.display === 'none') return true; + cursor = cursor.parentElement; + } + + return false; + } + + return { + listHeight: listHeightRef, + listStyle: { + overflow: 'auto' + }, + keyToIndex: keyIndexMapRef, + itemsStyle: vue.computed(() => { + const { + itemResizable + } = props; + const height = pxfy(finweckTreeRef.value.sum()); // eslint-disable-next-line @typescript-eslint/no-unused-expressions + + finweckTreeUpdateTrigger.value; + return [props.itemsStyle, { + boxSizing: 'content-box', + height: itemResizable ? '' : height, + minHeight: itemResizable ? height : '', + paddingTop: pxfy(props.paddingTop), + paddingBottom: pxfy(props.paddingBottom) + }]; + }), + visibleItemsStyle: vue.computed(() => { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + finweckTreeUpdateTrigger.value; + return { + transform: `translateY(${pxfy(finweckTreeRef.value.sum(startIndexRef.value))})` + }; + }), + viewportItems: viewportItemsRef, + listElRef, + itemsElRef: vue.ref(null), + scrollTo, + handleListResize, + handleListScroll, + handleListWheel, + handleItemResize + }; + }, + + render() { + const { + itemResizable, + keyField, + keyToIndex, + visibleItemsTag + } = this; + return vue.h(VResizeObserver, { + onResize: this.handleListResize + }, { + default: () => { + var _a, _b; + + return vue.h('div', vue.mergeProps(this.$attrs, { + class: ['v-vl', this.showScrollbar && 'v-vl--show-scrollbar'], + onScroll: this.handleListScroll, + onWheel: this.handleListWheel, + ref: 'listElRef' + }), [this.items.length !== 0 ? vue.h('div', { + ref: 'itemsElRef', + class: 'v-vl-items', + style: this.itemsStyle + }, [vue.h(visibleItemsTag, Object.assign({ + class: 'v-vl-visible-items', + style: this.visibleItemsStyle + }, this.visibleItemsProps), { + default: () => this.viewportItems.map(item => { + const key = item[keyField]; + const index = keyToIndex.get(key); + const itemVNode = this.$slots.default({ + item, + index + })[0]; + + if (itemResizable) { + return vue.h(VResizeObserver, { + key, + onResize: entry => this.handleItemResize(key, entry) + }, { + default: () => itemVNode + }); + } + + itemVNode.key = key; + return itemVNode; + }) + })]) : (_b = (_a = this.$slots).empty) === null || _b === void 0 ? void 0 : _b.call(_a)]); + } + }); + } + + }); + + const styles = c('.v-x-scroll', { + overflow: 'auto', + scrollbarWidth: 'none' + }, [c('&::-webkit-scrollbar', { + width: 0, + height: 0 + })]); + var VXScroll = vue.defineComponent({ + name: 'XScroll', + props: { + disabled: Boolean, + onScroll: Function + }, + + setup() { + const selfRef = vue.ref(null); + + function handleWheel(e) { + const preventYWheel = e.currentTarget.offsetWidth < e.currentTarget.scrollWidth; + if (!preventYWheel || e.deltaY === 0) return; + e.currentTarget.scrollLeft += e.deltaY + e.deltaX; + e.preventDefault(); + } + + const ssrAdapter = useSsrAdapter(); + styles.mount({ + id: 'vueuc/x-scroll', + head: true, + anchorMetaName: cssrAnchorMetaName$1, + ssr: ssrAdapter + }); + const exposedMethods = { + scrollTo() { + var _a; + + (_a = selfRef.value) === null || _a === void 0 ? void 0 : _a.scrollTo(...arguments); + } + + }; + return Object.assign({ + selfRef, + handleWheel + }, exposedMethods); + }, + + render() { + return vue.h('div', { + ref: 'selfRef', + onScroll: this.onScroll, + onWheel: this.disabled ? undefined : this.handleWheel, + class: 'v-x-scroll' + }, this.$slots); + } + + }); + + /* eslint-disable @typescript-eslint/strict-boolean-expressions */ + const hiddenAttr = 'v-hidden'; + const style$1A = c('[v-hidden]', { + display: 'none!important' + }); + var VOverflow = vue.defineComponent({ + name: 'Overflow', + props: { + getCounter: Function, + getTail: Function, + updateCounter: Function, + onUpdateOverflow: Function + }, + + setup(props, _ref) { + let { + slots + } = _ref; + const selfRef = vue.ref(null); + const counterRef = vue.ref(null); + + function deriveCounter() { + const { + value: self + } = selfRef; + const { + getCounter, + getTail + } = props; + let counter; + if (getCounter !== undefined) counter = getCounter();else { + counter = counterRef.value; + } + if (!self || !counter) return; + + if (counter.hasAttribute(hiddenAttr)) { + counter.removeAttribute(hiddenAttr); + } + + const { + children + } = self; + const containerWidth = self.offsetWidth; + const childWidths = []; + const tail = slots.tail ? getTail === null || getTail === void 0 ? void 0 : getTail() : null; + let childWidthSum = tail ? tail.offsetWidth : 0; + let overflow = false; + const len = self.children.length - (slots.tail ? 1 : 0); + + for (let i = 0; i < len - 1; ++i) { + if (i < 0) continue; + const child = children[i]; + + if (overflow) { + if (!child.hasAttribute(hiddenAttr)) { + child.setAttribute(hiddenAttr, ''); + } + + continue; + } else if (child.hasAttribute(hiddenAttr)) { + child.removeAttribute(hiddenAttr); + } + + const childWidth = child.offsetWidth; + childWidthSum += childWidth; + childWidths[i] = childWidth; + + if (childWidthSum > containerWidth) { + const { + updateCounter + } = props; + + for (let j = i; j >= 0; --j) { + const restCount = len - 1 - j; + + if (updateCounter !== undefined) { + updateCounter(restCount); + } else { + counter.textContent = `${restCount}`; + } + + const counterWidth = counter.offsetWidth; + childWidthSum -= childWidths[j]; + + if (childWidthSum + counterWidth <= containerWidth || j === 0) { + overflow = true; + i = j - 1; + + if (tail) { + // tail too long or 1st element too long + // we only consider tail now + if (i === -1) { + tail.style.maxWidth = `${containerWidth - counterWidth}px`; + tail.style.boxSizing = 'border-box'; + } else { + tail.style.maxWidth = ''; + } + } + + break; + } + } + } + } + + const { + onUpdateOverflow + } = props; + + if (!overflow) { + if (onUpdateOverflow !== undefined) { + onUpdateOverflow(false); + } + + counter.setAttribute(hiddenAttr, ''); + } else { + if (onUpdateOverflow !== undefined) { + onUpdateOverflow(true); + } + } + } + + const ssrAdapter = useSsrAdapter(); + style$1A.mount({ + id: 'vueuc/overflow', + head: true, + anchorMetaName: cssrAnchorMetaName$1, + ssr: ssrAdapter + }); + vue.onMounted(deriveCounter); // besides onMounted, other case should be manually triggered, or we shoud watch items + + return { + selfRef, + counterRef, + sync: deriveCounter + }; + }, + + render() { + const { + $slots + } = this; // eslint-disable-next-line @typescript-eslint/no-floating-promises + + vue.nextTick(this.sync); // It shouldn't have border + + return vue.h('div', { + class: 'v-overflow', + ref: 'selfRef' + }, [vue.renderSlot($slots, 'default'), // $slots.counter should only has 1 element + $slots.counter ? $slots.counter() : vue.h('span', { + style: { + display: 'inline-block' + }, + ref: 'counterRef' + }), // $slots.tail should only has 1 element + $slots.tail ? $slots.tail() : null]); + } + + }); + + /* eslint-disable @typescript-eslint/strict-boolean-expressions */ + // ref https://www.w3.org/TR/wai-aria-practices-1.1/examples/dialog-modal/js/dialog.js + function isHTMLElement(node) { + return node instanceof HTMLElement; + } + + function focusFirstDescendant(node) { + for (let i = 0; i < node.childNodes.length; i++) { + const child = node.childNodes[i]; + + if (isHTMLElement(child)) { + if (attemptFocus(child) || focusFirstDescendant(child)) { + return true; + } + } + } + + return false; + } + function focusLastDescendant(element) { + for (let i = element.childNodes.length - 1; i >= 0; i--) { + const child = element.childNodes[i]; + + if (isHTMLElement(child)) { + if (attemptFocus(child) || focusLastDescendant(child)) { + return true; + } + } + } + + return false; + } + + function attemptFocus(element) { + if (!isFocusable(element)) { + return false; + } + + try { + element.focus({ + preventScroll: true + }); + } catch (e) {} + + return document.activeElement === element; + } + + function isFocusable(element) { + if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute('tabIndex') !== null) { + return true; + } + + if (element.getAttribute('disabled')) { + return false; + } + + switch (element.nodeName) { + case 'A': + return !!element.href && element.rel !== 'ignore'; + + case 'INPUT': + return element.type !== 'hidden' && element.type !== 'file'; + + case 'BUTTON': + case 'SELECT': + case 'TEXTAREA': + return true; + + default: + return false; + } + } + + let stack = []; + const FocusTrap = vue.defineComponent({ + name: 'FocusTrap', + props: { + disabled: Boolean, + active: Boolean, + autoFocus: { + type: Boolean, + default: true + }, + onEsc: Function, + initialFocusTo: String, + finalFocusTo: String, + returnFocusOnDeactivated: { + type: Boolean, + default: true + } + }, + + setup(props) { + const id = createId(); + const focusableStartRef = vue.ref(null); + const focusableEndRef = vue.ref(null); + let activated = false; + let ignoreInternalFocusChange = false; + const lastFocusedElement = document.activeElement; + + function isCurrentActive() { + const currentActiveId = stack[stack.length - 1]; + return currentActiveId === id; + } + + function handleDocumentKeydown(e) { + var _a; + + if (e.code === 'Escape') { + if (isCurrentActive()) { + (_a = props.onEsc) === null || _a === void 0 ? void 0 : _a.call(props, e); + } + } + } + + vue.onMounted(() => { + vue.watch(() => props.active, value => { + if (value) { + activate(); + on('keydown', document, handleDocumentKeydown); + } else { + off('keydown', document, handleDocumentKeydown); + + if (activated) { + deactivate(); + } + } + }, { + immediate: true + }); + }); + vue.onBeforeUnmount(() => { + off('keydown', document, handleDocumentKeydown); + if (activated) deactivate(); + }); + + function handleDocumentFocus(e) { + if (ignoreInternalFocusChange) return; + + if (isCurrentActive()) { + const mainEl = getMainEl(); + if (mainEl === null) return; + if (mainEl.contains(getPreciseEventTarget(e))) return; // I don't handle shift + tab status since it's too tricky to handle + // Not impossible but I need to sleep + + resetFocusTo('first'); + } + } + + function getMainEl() { + const focusableStartEl = focusableStartRef.value; + if (focusableStartEl === null) return null; + let mainEl = focusableStartEl; + + while (true) { + mainEl = mainEl.nextSibling; + if (mainEl === null) break; + + if (mainEl instanceof Element && mainEl.tagName === 'DIV') { + break; + } + } + + return mainEl; + } + + function activate() { + var _a; + + if (props.disabled) return; + stack.push(id); + + if (props.autoFocus) { + const { + initialFocusTo + } = props; + + if (initialFocusTo === undefined) { + resetFocusTo('first'); + } else { + (_a = resolveTo(initialFocusTo)) === null || _a === void 0 ? void 0 : _a.focus({ + preventScroll: true + }); + } + } + + activated = true; + document.addEventListener('focus', handleDocumentFocus, true); + } + + function deactivate() { + var _a; + + if (props.disabled) return; + document.removeEventListener('focus', handleDocumentFocus, true); + stack = stack.filter(idInStack => idInStack !== id); + if (isCurrentActive()) return; + const { + finalFocusTo + } = props; + + if (finalFocusTo !== undefined) { + (_a = resolveTo(finalFocusTo)) === null || _a === void 0 ? void 0 : _a.focus({ + preventScroll: true + }); + } else if (props.returnFocusOnDeactivated) { + if (lastFocusedElement instanceof HTMLElement) { + ignoreInternalFocusChange = true; + lastFocusedElement.focus({ + preventScroll: true + }); + ignoreInternalFocusChange = false; + } + } + } + + function resetFocusTo(target) { + if (!isCurrentActive()) return; + + if (props.active) { + const focusableStartEl = focusableStartRef.value; + const focusableEndEl = focusableEndRef.value; + + if (focusableStartEl !== null && focusableEndEl !== null) { + const mainEl = getMainEl(); + + if (mainEl == null || mainEl === focusableEndEl) { + ignoreInternalFocusChange = true; + focusableStartEl.focus({ + preventScroll: true + }); + ignoreInternalFocusChange = false; + return; + } + + ignoreInternalFocusChange = true; + const focused = target === 'first' ? focusFirstDescendant(mainEl) : focusLastDescendant(mainEl); + ignoreInternalFocusChange = false; + + if (!focused) { + ignoreInternalFocusChange = true; + focusableStartEl.focus({ + preventScroll: true + }); + ignoreInternalFocusChange = false; + } + } + } + } + + function handleStartFocus(e) { + if (ignoreInternalFocusChange) return; + const mainEl = getMainEl(); + if (mainEl === null) return; + + if (e.relatedTarget !== null && mainEl.contains(e.relatedTarget)) { + // if it comes from inner, focus last + resetFocusTo('last'); + } else { + // otherwise focus first + resetFocusTo('first'); + } + } + + function handleEndFocus(e) { + if (ignoreInternalFocusChange) return; + + if (e.relatedTarget !== null && e.relatedTarget === focusableStartRef.value) { + // if it comes from first, focus last + resetFocusTo('last'); + } else { + // otherwise focus first + resetFocusTo('first'); + } + } + + return { + focusableStartRef, + focusableEndRef, + focusableStyle: 'position: absolute; height: 0; width: 0;', + handleStartFocus, + handleEndFocus + }; + }, + + render() { + const { + default: defaultSlot + } = this.$slots; + if (defaultSlot === undefined) return null; + if (this.disabled) return defaultSlot(); + const { + active, + focusableStyle + } = this; + return vue.h(vue.Fragment, null, [vue.h('div', { + 'aria-hidden': 'true', + tabindex: active ? '0' : '-1', + ref: 'focusableStartRef', + style: focusableStyle, + onFocus: this.handleStartFocus + }), defaultSlot(), vue.h('div', { + 'aria-hidden': 'true', + style: focusableStyle, + ref: 'focusableEndRef', + tabindex: active ? '0' : '-1', + onFocus: this.handleEndFocus + })]); + } + + }); + + function useOnResize(elRef, onResize) { + if (onResize) { + vue.onMounted(() => { + const { + value: el + } = elRef; + + if (el) { + resizeObserverManager.registerHandler(el, onResize); + } + }); + vue.onBeforeUnmount(() => { + const { + value: el + } = elRef; + + if (el) { + resizeObserverManager.unregisterHandler(el); + } + }); + } + } + + let lockCount = 0; + let originalMarginRight = ""; + let originalOverflow = ""; + let originalOverflowX = ""; + let originalOverflowY = ""; + const lockHtmlScrollRightCompensationRef = vue.ref("0px"); + function useLockHtmlScroll(lockRef) { + if (typeof document === "undefined") return; + const el = document.documentElement; + let watchStopHandle; + let activated = false; + + const unlock = () => { + el.style.marginRight = originalMarginRight; + el.style.overflow = originalOverflow; + el.style.overflowX = originalOverflowX; + el.style.overflowY = originalOverflowY; + lockHtmlScrollRightCompensationRef.value = "0px"; + }; + + vue.onMounted(() => { + watchStopHandle = vue.watch(lockRef, value => { + if (value) { + if (!lockCount) { + const scrollbarWidth = window.innerWidth - el.offsetWidth; + + if (scrollbarWidth > 0) { + originalMarginRight = el.style.marginRight; + el.style.marginRight = `${scrollbarWidth}px`; + lockHtmlScrollRightCompensationRef.value = `${scrollbarWidth}px`; + } + + originalOverflow = el.style.overflow; + originalOverflowX = el.style.overflowX; + originalOverflowY = el.style.overflowY; + el.style.overflow = "hidden"; + el.style.overflowX = "hidden"; + el.style.overflowY = "hidden"; + } + + activated = true; + lockCount++; + } else { + lockCount--; + + if (!lockCount) { + unlock(); + } + + activated = false; + } + }, { + immediate: true + }); + }); + vue.onBeforeUnmount(() => { + var _watchStopHandle; + + (_watchStopHandle = watchStopHandle) === null || _watchStopHandle === void 0 ? void 0 : _watchStopHandle(); + + if (activated) { + lockCount--; + + if (!lockCount) { + unlock(); + } + + activated = false; + } + }); + } + + const isComposingRef = vue.ref(false); + + const compositionStartHandler = () => { + isComposingRef.value = true; + }; + + const compositionEndHandler = () => { + isComposingRef.value = false; + }; + + let mountedCount = 0; + const useIsComposing = () => { + if (isBrowser$2) { + vue.onBeforeMount(() => { + if (!mountedCount) { + window.addEventListener("compositionstart", compositionStartHandler); + window.addEventListener("compositionend", compositionEndHandler); + } + + mountedCount++; + }); + vue.onBeforeUnmount(() => { + if (mountedCount <= 1) { + window.removeEventListener("compositionstart", compositionStartHandler); + window.removeEventListener("compositionend", compositionEndHandler); + mountedCount = 0; + } else { + mountedCount--; + } + }); + } + + return isComposingRef; + }; + + function useReactivated(callback) { + const isDeactivatedRef = { + isDeactivated: false + }; + let activateStateInitialized = false; + vue.onActivated(() => { + isDeactivatedRef.isDeactivated = false; + + if (!activateStateInitialized) { + activateStateInitialized = true; + return; + } + + callback(); + }); + vue.onDeactivated(() => { + isDeactivatedRef.isDeactivated = true; + + if (!activateStateInitialized) { + activateStateInitialized = true; + } + }); + return isDeactivatedRef; + } + + function isDocument(node) { + return node.nodeName === "#document"; + } + + const formItemInjectionKey = createInjectionKey("n-form-item"); + function useFormItem(props) { + let { + defaultSize = "medium", + mergedSize, + mergedDisabled + } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + const NFormItem = vue.inject(formItemInjectionKey, null); + vue.provide(formItemInjectionKey, null); + const mergedSizeRef = vue.computed(mergedSize ? () => mergedSize(NFormItem) : () => { + const { + size + } = props; + if (size) return size; + + if (NFormItem) { + const { + mergedSize: mergedSize2 + } = NFormItem; + + if (mergedSize2.value !== void 0) { + return mergedSize2.value; + } + } + + return defaultSize; + }); + const mergedDisabledRef = vue.computed(mergedDisabled ? () => mergedDisabled(NFormItem) : () => { + const { + disabled + } = props; + + if (disabled !== void 0) { + return disabled; + } + + if (NFormItem) { + return NFormItem.disabled.value; + } + + return false; + }); + const mergedStatusRef = vue.computed(() => { + const { + status + } = props; + if (status) return status; + return NFormItem === null || NFormItem === void 0 ? void 0 : NFormItem.mergedValidationStatus.value; + }); + vue.onBeforeUnmount(() => { + if (NFormItem) { + NFormItem.restoreValidation(); + } + }); + return { + mergedSizeRef, + mergedDisabledRef, + mergedStatusRef, + + nTriggerFormBlur() { + if (NFormItem) { + NFormItem.handleContentBlur(); + } + }, + + nTriggerFormChange() { + if (NFormItem) { + NFormItem.handleContentChange(); + } + }, + + nTriggerFormFocus() { + if (NFormItem) { + NFormItem.handleContentFocus(); + } + }, + + nTriggerFormInput() { + if (NFormItem) { + NFormItem.handleContentInput(); + } + } + + }; + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; + } + + var lodash = {exports: {}}; + + /** + * @license + * Lodash + * Copyright OpenJS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + (function (module, exports) { + (function(){/** Used as a safe reference for `undefined` in pre-ES5 environments. */var undefined$1;/** Used as the semantic version number. */var VERSION='4.17.21';/** Used as the size to enable large array optimizations. */var LARGE_ARRAY_SIZE=200;/** Error message constants. */var CORE_ERROR_TEXT='Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',FUNC_ERROR_TEXT='Expected a function',INVALID_TEMPL_VAR_ERROR_TEXT='Invalid `variable` option passed into `_.template`';/** Used to stand-in for `undefined` hash values. */var HASH_UNDEFINED='__lodash_hash_undefined__';/** Used as the maximum memoize cache size. */var MAX_MEMOIZE_SIZE=500;/** Used as the internal argument placeholder. */var PLACEHOLDER='__lodash_placeholder__';/** Used to compose bitmasks for cloning. */var CLONE_DEEP_FLAG=1,CLONE_FLAT_FLAG=2,CLONE_SYMBOLS_FLAG=4;/** Used to compose bitmasks for value comparisons. */var COMPARE_PARTIAL_FLAG=1,COMPARE_UNORDERED_FLAG=2;/** Used to compose bitmasks for function metadata. */var WRAP_BIND_FLAG=1,WRAP_BIND_KEY_FLAG=2,WRAP_CURRY_BOUND_FLAG=4,WRAP_CURRY_FLAG=8,WRAP_CURRY_RIGHT_FLAG=16,WRAP_PARTIAL_FLAG=32,WRAP_PARTIAL_RIGHT_FLAG=64,WRAP_ARY_FLAG=128,WRAP_REARG_FLAG=256,WRAP_FLIP_FLAG=512;/** Used as default options for `_.truncate`. */var DEFAULT_TRUNC_LENGTH=30,DEFAULT_TRUNC_OMISSION='...';/** Used to detect hot functions by number of calls within a span of milliseconds. */var HOT_COUNT=800,HOT_SPAN=16;/** Used to indicate the type of lazy iteratees. */var LAZY_FILTER_FLAG=1,LAZY_MAP_FLAG=2,LAZY_WHILE_FLAG=3;/** Used as references for various `Number` constants. */var INFINITY=1/0,MAX_SAFE_INTEGER=9007199254740991,MAX_INTEGER=1.7976931348623157e+308,NAN=0/0;/** Used as references for the maximum length and index of an array. */var MAX_ARRAY_LENGTH=4294967295,MAX_ARRAY_INDEX=MAX_ARRAY_LENGTH-1,HALF_MAX_ARRAY_LENGTH=MAX_ARRAY_LENGTH>>>1;/** Used to associate wrap methods with their bit flags. */var wrapFlags=[['ary',WRAP_ARY_FLAG],['bind',WRAP_BIND_FLAG],['bindKey',WRAP_BIND_KEY_FLAG],['curry',WRAP_CURRY_FLAG],['curryRight',WRAP_CURRY_RIGHT_FLAG],['flip',WRAP_FLIP_FLAG],['partial',WRAP_PARTIAL_FLAG],['partialRight',WRAP_PARTIAL_RIGHT_FLAG],['rearg',WRAP_REARG_FLAG]];/** `Object#toString` result references. */var argsTag='[object Arguments]',arrayTag='[object Array]',asyncTag='[object AsyncFunction]',boolTag='[object Boolean]',dateTag='[object Date]',domExcTag='[object DOMException]',errorTag='[object Error]',funcTag='[object Function]',genTag='[object GeneratorFunction]',mapTag='[object Map]',numberTag='[object Number]',nullTag='[object Null]',objectTag='[object Object]',promiseTag='[object Promise]',proxyTag='[object Proxy]',regexpTag='[object RegExp]',setTag='[object Set]',stringTag='[object String]',symbolTag='[object Symbol]',undefinedTag='[object Undefined]',weakMapTag='[object WeakMap]',weakSetTag='[object WeakSet]';var arrayBufferTag='[object ArrayBuffer]',dataViewTag='[object DataView]',float32Tag='[object Float32Array]',float64Tag='[object Float64Array]',int8Tag='[object Int8Array]',int16Tag='[object Int16Array]',int32Tag='[object Int32Array]',uint8Tag='[object Uint8Array]',uint8ClampedTag='[object Uint8ClampedArray]',uint16Tag='[object Uint16Array]',uint32Tag='[object Uint32Array]';/** Used to match empty string literals in compiled template source. */var reEmptyStringLeading=/\b__p \+= '';/g,reEmptyStringMiddle=/\b(__p \+=) '' \+/g,reEmptyStringTrailing=/(__e\(.*?\)|\b__t\)) \+\n'';/g;/** Used to match HTML entities and HTML characters. */var reEscapedHtml=/&(?:amp|lt|gt|quot|#39);/g,reUnescapedHtml=/[&<>"']/g,reHasEscapedHtml=RegExp(reEscapedHtml.source),reHasUnescapedHtml=RegExp(reUnescapedHtml.source);/** Used to match template delimiters. */var reEscape=/<%-([\s\S]+?)%>/g,reEvaluate=/<%([\s\S]+?)%>/g,reInterpolate=/<%=([\s\S]+?)%>/g;/** Used to match property names within property paths. */var reIsDeepProp=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,reIsPlainProp=/^\w*$/,rePropName=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */var reRegExpChar=/[\\^$.*+?()[\]{}|]/g,reHasRegExpChar=RegExp(reRegExpChar.source);/** Used to match leading whitespace. */var reTrimStart=/^\s+/;/** Used to match a single whitespace character. */var reWhitespace=/\s/;/** Used to match wrap detail comments. */var reWrapComment=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,reWrapDetails=/\{\n\/\* \[wrapped with (.+)\] \*/,reSplitDetails=/,? & /;/** Used to match words composed of alphanumeric characters. */var reAsciiWord=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;/** + * Used to validate the `validate` option in `_.template` variable. + * + * Forbids characters which could potentially change the meaning of the function argument definition: + * - "()," (modification of function parameters) + * - "=" (default value) + * - "[]{}" (destructuring of function parameters) + * - "/" (beginning of a comment) + * - whitespace + */var reForbiddenIdentifierChars=/[()=,{}\[\]\/\s]/;/** Used to match backslashes in property paths. */var reEscapeChar=/\\(\\)?/g;/** + * Used to match + * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). + */var reEsTemplate=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;/** Used to match `RegExp` flags from their coerced string values. */var reFlags=/\w*$/;/** Used to detect bad signed hexadecimal string values. */var reIsBadHex=/^[-+]0x[0-9a-f]+$/i;/** Used to detect binary string values. */var reIsBinary=/^0b[01]+$/i;/** Used to detect host constructors (Safari). */var reIsHostCtor=/^\[object .+?Constructor\]$/;/** Used to detect octal string values. */var reIsOctal=/^0o[0-7]+$/i;/** Used to detect unsigned integer values. */var reIsUint=/^(?:0|[1-9]\d*)$/;/** Used to match Latin Unicode letters (excluding mathematical operators). */var reLatin=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;/** Used to ensure capturing order of template delimiters. */var reNoMatch=/($^)/;/** Used to match unescaped characters in compiled string literals. */var reUnescapedString=/['\n\r\u2028\u2029\\]/g;/** Used to compose unicode character classes. */var rsAstralRange='\\ud800-\\udfff',rsComboMarksRange='\\u0300-\\u036f',reComboHalfMarksRange='\\ufe20-\\ufe2f',rsComboSymbolsRange='\\u20d0-\\u20ff',rsComboRange=rsComboMarksRange+reComboHalfMarksRange+rsComboSymbolsRange,rsDingbatRange='\\u2700-\\u27bf',rsLowerRange='a-z\\xdf-\\xf6\\xf8-\\xff',rsMathOpRange='\\xac\\xb1\\xd7\\xf7',rsNonCharRange='\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',rsPunctuationRange='\\u2000-\\u206f',rsSpaceRange=' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',rsUpperRange='A-Z\\xc0-\\xd6\\xd8-\\xde',rsVarRange='\\ufe0e\\ufe0f',rsBreakRange=rsMathOpRange+rsNonCharRange+rsPunctuationRange+rsSpaceRange;/** Used to compose unicode capture groups. */var rsApos="['\u2019]",rsAstral='['+rsAstralRange+']',rsBreak='['+rsBreakRange+']',rsCombo='['+rsComboRange+']',rsDigits='\\d+',rsDingbat='['+rsDingbatRange+']',rsLower='['+rsLowerRange+']',rsMisc='[^'+rsAstralRange+rsBreakRange+rsDigits+rsDingbatRange+rsLowerRange+rsUpperRange+']',rsFitz='\\ud83c[\\udffb-\\udfff]',rsModifier='(?:'+rsCombo+'|'+rsFitz+')',rsNonAstral='[^'+rsAstralRange+']',rsRegional='(?:\\ud83c[\\udde6-\\uddff]){2}',rsSurrPair='[\\ud800-\\udbff][\\udc00-\\udfff]',rsUpper='['+rsUpperRange+']',rsZWJ='\\u200d';/** Used to compose unicode regexes. */var rsMiscLower='(?:'+rsLower+'|'+rsMisc+')',rsMiscUpper='(?:'+rsUpper+'|'+rsMisc+')',rsOptContrLower='(?:'+rsApos+'(?:d|ll|m|re|s|t|ve))?',rsOptContrUpper='(?:'+rsApos+'(?:D|LL|M|RE|S|T|VE))?',reOptMod=rsModifier+'?',rsOptVar='['+rsVarRange+']?',rsOptJoin='(?:'+rsZWJ+'(?:'+[rsNonAstral,rsRegional,rsSurrPair].join('|')+')'+rsOptVar+reOptMod+')*',rsOrdLower='\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',rsOrdUpper='\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',rsSeq=rsOptVar+reOptMod+rsOptJoin,rsEmoji='(?:'+[rsDingbat,rsRegional,rsSurrPair].join('|')+')'+rsSeq,rsSymbol='(?:'+[rsNonAstral+rsCombo+'?',rsCombo,rsRegional,rsSurrPair,rsAstral].join('|')+')';/** Used to match apostrophes. */var reApos=RegExp(rsApos,'g');/** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */var reComboMark=RegExp(rsCombo,'g');/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */var reUnicode=RegExp(rsFitz+'(?='+rsFitz+')|'+rsSymbol+rsSeq,'g');/** Used to match complex or compound words. */var reUnicodeWord=RegExp([rsUpper+'?'+rsLower+'+'+rsOptContrLower+'(?='+[rsBreak,rsUpper,'$'].join('|')+')',rsMiscUpper+'+'+rsOptContrUpper+'(?='+[rsBreak,rsUpper+rsMiscLower,'$'].join('|')+')',rsUpper+'?'+rsMiscLower+'+'+rsOptContrLower,rsUpper+'+'+rsOptContrUpper,rsOrdUpper,rsOrdLower,rsDigits,rsEmoji].join('|'),'g');/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */var reHasUnicode=RegExp('['+rsZWJ+rsAstralRange+rsComboRange+rsVarRange+']');/** Used to detect strings that need a more robust regexp to match words. */var reHasUnicodeWord=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;/** Used to assign default `context` object properties. */var contextProps=['Array','Buffer','DataView','Date','Error','Float32Array','Float64Array','Function','Int8Array','Int16Array','Int32Array','Map','Math','Object','Promise','RegExp','Set','String','Symbol','TypeError','Uint8Array','Uint8ClampedArray','Uint16Array','Uint32Array','WeakMap','_','clearTimeout','isFinite','parseInt','setTimeout'];/** Used to make template sourceURLs easier to identify. */var templateCounter=-1;/** Used to identify `toStringTag` values of typed arrays. */var typedArrayTags={};typedArrayTags[float32Tag]=typedArrayTags[float64Tag]=typedArrayTags[int8Tag]=typedArrayTags[int16Tag]=typedArrayTags[int32Tag]=typedArrayTags[uint8Tag]=typedArrayTags[uint8ClampedTag]=typedArrayTags[uint16Tag]=typedArrayTags[uint32Tag]=true;typedArrayTags[argsTag]=typedArrayTags[arrayTag]=typedArrayTags[arrayBufferTag]=typedArrayTags[boolTag]=typedArrayTags[dataViewTag]=typedArrayTags[dateTag]=typedArrayTags[errorTag]=typedArrayTags[funcTag]=typedArrayTags[mapTag]=typedArrayTags[numberTag]=typedArrayTags[objectTag]=typedArrayTags[regexpTag]=typedArrayTags[setTag]=typedArrayTags[stringTag]=typedArrayTags[weakMapTag]=false;/** Used to identify `toStringTag` values supported by `_.clone`. */var cloneableTags={};cloneableTags[argsTag]=cloneableTags[arrayTag]=cloneableTags[arrayBufferTag]=cloneableTags[dataViewTag]=cloneableTags[boolTag]=cloneableTags[dateTag]=cloneableTags[float32Tag]=cloneableTags[float64Tag]=cloneableTags[int8Tag]=cloneableTags[int16Tag]=cloneableTags[int32Tag]=cloneableTags[mapTag]=cloneableTags[numberTag]=cloneableTags[objectTag]=cloneableTags[regexpTag]=cloneableTags[setTag]=cloneableTags[stringTag]=cloneableTags[symbolTag]=cloneableTags[uint8Tag]=cloneableTags[uint8ClampedTag]=cloneableTags[uint16Tag]=cloneableTags[uint32Tag]=true;cloneableTags[errorTag]=cloneableTags[funcTag]=cloneableTags[weakMapTag]=false;/** Used to map Latin Unicode letters to basic Latin letters. */var deburredLetters={// Latin-1 Supplement block. + '\xc0':'A','\xc1':'A','\xc2':'A','\xc3':'A','\xc4':'A','\xc5':'A','\xe0':'a','\xe1':'a','\xe2':'a','\xe3':'a','\xe4':'a','\xe5':'a','\xc7':'C','\xe7':'c','\xd0':'D','\xf0':'d','\xc8':'E','\xc9':'E','\xca':'E','\xcb':'E','\xe8':'e','\xe9':'e','\xea':'e','\xeb':'e','\xcc':'I','\xcd':'I','\xce':'I','\xcf':'I','\xec':'i','\xed':'i','\xee':'i','\xef':'i','\xd1':'N','\xf1':'n','\xd2':'O','\xd3':'O','\xd4':'O','\xd5':'O','\xd6':'O','\xd8':'O','\xf2':'o','\xf3':'o','\xf4':'o','\xf5':'o','\xf6':'o','\xf8':'o','\xd9':'U','\xda':'U','\xdb':'U','\xdc':'U','\xf9':'u','\xfa':'u','\xfb':'u','\xfc':'u','\xdd':'Y','\xfd':'y','\xff':'y','\xc6':'Ae','\xe6':'ae','\xde':'Th','\xfe':'th','\xdf':'ss',// Latin Extended-A block. + '\u0100':'A','\u0102':'A','\u0104':'A','\u0101':'a','\u0103':'a','\u0105':'a','\u0106':'C','\u0108':'C','\u010a':'C','\u010c':'C','\u0107':'c','\u0109':'c','\u010b':'c','\u010d':'c','\u010e':'D','\u0110':'D','\u010f':'d','\u0111':'d','\u0112':'E','\u0114':'E','\u0116':'E','\u0118':'E','\u011a':'E','\u0113':'e','\u0115':'e','\u0117':'e','\u0119':'e','\u011b':'e','\u011c':'G','\u011e':'G','\u0120':'G','\u0122':'G','\u011d':'g','\u011f':'g','\u0121':'g','\u0123':'g','\u0124':'H','\u0126':'H','\u0125':'h','\u0127':'h','\u0128':'I','\u012a':'I','\u012c':'I','\u012e':'I','\u0130':'I','\u0129':'i','\u012b':'i','\u012d':'i','\u012f':'i','\u0131':'i','\u0134':'J','\u0135':'j','\u0136':'K','\u0137':'k','\u0138':'k','\u0139':'L','\u013b':'L','\u013d':'L','\u013f':'L','\u0141':'L','\u013a':'l','\u013c':'l','\u013e':'l','\u0140':'l','\u0142':'l','\u0143':'N','\u0145':'N','\u0147':'N','\u014a':'N','\u0144':'n','\u0146':'n','\u0148':'n','\u014b':'n','\u014c':'O','\u014e':'O','\u0150':'O','\u014d':'o','\u014f':'o','\u0151':'o','\u0154':'R','\u0156':'R','\u0158':'R','\u0155':'r','\u0157':'r','\u0159':'r','\u015a':'S','\u015c':'S','\u015e':'S','\u0160':'S','\u015b':'s','\u015d':'s','\u015f':'s','\u0161':'s','\u0162':'T','\u0164':'T','\u0166':'T','\u0163':'t','\u0165':'t','\u0167':'t','\u0168':'U','\u016a':'U','\u016c':'U','\u016e':'U','\u0170':'U','\u0172':'U','\u0169':'u','\u016b':'u','\u016d':'u','\u016f':'u','\u0171':'u','\u0173':'u','\u0174':'W','\u0175':'w','\u0176':'Y','\u0177':'y','\u0178':'Y','\u0179':'Z','\u017b':'Z','\u017d':'Z','\u017a':'z','\u017c':'z','\u017e':'z','\u0132':'IJ','\u0133':'ij','\u0152':'Oe','\u0153':'oe','\u0149':"'n",'\u017f':'s'};/** Used to map characters to HTML entities. */var htmlEscapes={'&':'&','<':'<','>':'>','"':'"',"'":'''};/** Used to map HTML entities to characters. */var htmlUnescapes={'&':'&','<':'<','>':'>','"':'"',''':"'"};/** Used to escape characters for inclusion in compiled string literals. */var stringEscapes={'\\':'\\',"'":"'",'\n':'n','\r':'r','\u2028':'u2028','\u2029':'u2029'};/** Built-in method references without a dependency on `root`. */var freeParseFloat=parseFloat,freeParseInt=parseInt;/** Detect free variable `global` from Node.js. */var freeGlobal=typeof commonjsGlobal=='object'&&commonjsGlobal&&commonjsGlobal.Object===Object&&commonjsGlobal;/** Detect free variable `self`. */var freeSelf=typeof self=='object'&&self&&self.Object===Object&&self;/** Used as a reference to the global object. */var root=freeGlobal||freeSelf||Function('return this')();/** Detect free variable `exports`. */var freeExports=exports&&!exports.nodeType&&exports;/** Detect free variable `module`. */var freeModule=freeExports&&'object'=='object'&&module&&!module.nodeType&&module;/** Detect the popular CommonJS extension `module.exports`. */var moduleExports=freeModule&&freeModule.exports===freeExports;/** Detect free variable `process` from Node.js. */var freeProcess=moduleExports&&freeGlobal.process;/** Used to access faster Node.js helpers. */var nodeUtil=function(){try{// Use `util.types` for Node.js 10+. + var types=freeModule&&freeModule.require&&freeModule.require('util').types;if(types){return types;}// Legacy `process.binding('util')` for Node.js < 10. + return freeProcess&&freeProcess.binding&&freeProcess.binding('util');}catch(e){}}();/* Node.js helper references. */var nodeIsArrayBuffer=nodeUtil&&nodeUtil.isArrayBuffer,nodeIsDate=nodeUtil&&nodeUtil.isDate,nodeIsMap=nodeUtil&&nodeUtil.isMap,nodeIsRegExp=nodeUtil&&nodeUtil.isRegExp,nodeIsSet=nodeUtil&&nodeUtil.isSet,nodeIsTypedArray=nodeUtil&&nodeUtil.isTypedArray;/*--------------------------------------------------------------------------*/ /** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */function apply(func,thisArg,args){switch(args.length){case 0:return func.call(thisArg);case 1:return func.call(thisArg,args[0]);case 2:return func.call(thisArg,args[0],args[1]);case 3:return func.call(thisArg,args[0],args[1],args[2]);}return func.apply(thisArg,args);}/** + * A specialized version of `baseAggregator` for arrays. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */function arrayAggregator(array,setter,iteratee,accumulator){var index=-1,length=array==null?0:array.length;while(++index-1;}/** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */function arrayIncludesWith(array,value,comparator){var index=-1,length=array==null?0:array.length;while(++index-1){}return index;}/** + * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the last unmatched string symbol. + */function charsEndIndex(strSymbols,chrSymbols){var index=strSymbols.length;while(index--&&baseIndexOf(chrSymbols,strSymbols[index],0)>-1){}return index;}/** + * Gets the number of `placeholder` occurrences in `array`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} placeholder The placeholder to search for. + * @returns {number} Returns the placeholder count. + */function countHolders(array,placeholder){var length=array.length,result=0;while(length--){if(array[length]===placeholder){++result;}}return result;}/** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */var deburrLetter=basePropertyOf(deburredLetters);/** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */var escapeHtmlChar=basePropertyOf(htmlEscapes);/** + * Used by `_.template` to escape characters for inclusion in compiled string literals. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */function escapeStringChar(chr){return '\\'+stringEscapes[chr];}/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */function getValue(object,key){return object==null?undefined$1:object[key];}/** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */function hasUnicode(string){return reHasUnicode.test(string);}/** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a word is found, else `false`. + */function hasUnicodeWord(string){return reHasUnicodeWord.test(string);}/** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */function iteratorToArray(iterator){var data,result=[];while(!(data=iterator.next()).done){result.push(data.value);}return result;}/** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */function mapToArray(map){var index=-1,result=Array(map.size);map.forEach(function(value,key){result[++index]=[key,value];});return result;}/** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */function overArg(func,transform){return function(arg){return func(transform(arg));};}/** + * Replaces all `placeholder` elements in `array` with an internal placeholder + * and returns an array of their indexes. + * + * @private + * @param {Array} array The array to modify. + * @param {*} placeholder The placeholder to replace. + * @returns {Array} Returns the new array of placeholder indexes. + */function replaceHolders(array,placeholder){var index=-1,length=array.length,resIndex=0,result=[];while(++index true + * _.isFunction(_.bar); + * // => false + * + * lodash.isFunction(lodash.foo); + * // => false + * lodash.isFunction(lodash.bar); + * // => true + * + * // Create a suped-up `defer` in Node.js. + * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; + */var runInContext=function runInContext(context){context=context==null?root:_.defaults(root.Object(),context,_.pick(root,contextProps));/** Built-in constructor references. */var Array=context.Array,Date=context.Date,Error=context.Error,Function=context.Function,Math=context.Math,Object=context.Object,RegExp=context.RegExp,String=context.String,TypeError=context.TypeError;/** Used for built-in method references. */var arrayProto=Array.prototype,funcProto=Function.prototype,objectProto=Object.prototype;/** Used to detect overreaching core-js shims. */var coreJsData=context['__core-js_shared__'];/** Used to resolve the decompiled source of functions. */var funcToString=funcProto.toString;/** Used to check objects for own properties. */var hasOwnProperty=objectProto.hasOwnProperty;/** Used to generate unique IDs. */var idCounter=0;/** Used to detect methods masquerading as native. */var maskSrcKey=function(){var uid=/[^.]+$/.exec(coreJsData&&coreJsData.keys&&coreJsData.keys.IE_PROTO||'');return uid?'Symbol(src)_1.'+uid:'';}();/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */var nativeObjectToString=objectProto.toString;/** Used to infer the `Object` constructor. */var objectCtorString=funcToString.call(Object);/** Used to restore the original `_` reference in `_.noConflict`. */var oldDash=root._;/** Used to detect if a method is native. */var reIsNative=RegExp('^'+funcToString.call(hasOwnProperty).replace(reRegExpChar,'\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,'$1.*?')+'$');/** Built-in value references. */var Buffer=moduleExports?context.Buffer:undefined$1,Symbol=context.Symbol,Uint8Array=context.Uint8Array,allocUnsafe=Buffer?Buffer.allocUnsafe:undefined$1,getPrototype=overArg(Object.getPrototypeOf,Object),objectCreate=Object.create,propertyIsEnumerable=objectProto.propertyIsEnumerable,splice=arrayProto.splice,spreadableSymbol=Symbol?Symbol.isConcatSpreadable:undefined$1,symIterator=Symbol?Symbol.iterator:undefined$1,symToStringTag=Symbol?Symbol.toStringTag:undefined$1;var defineProperty=function(){try{var func=getNative(Object,'defineProperty');func({},'',{});return func;}catch(e){}}();/** Mocked built-ins. */var ctxClearTimeout=context.clearTimeout!==root.clearTimeout&&context.clearTimeout,ctxNow=Date&&Date.now!==root.Date.now&&Date.now,ctxSetTimeout=context.setTimeout!==root.setTimeout&&context.setTimeout;/* Built-in method references for those with the same name as other `lodash` methods. */var nativeCeil=Math.ceil,nativeFloor=Math.floor,nativeGetSymbols=Object.getOwnPropertySymbols,nativeIsBuffer=Buffer?Buffer.isBuffer:undefined$1,nativeIsFinite=context.isFinite,nativeJoin=arrayProto.join,nativeKeys=overArg(Object.keys,Object),nativeMax=Math.max,nativeMin=Math.min,nativeNow=Date.now,nativeParseInt=context.parseInt,nativeRandom=Math.random,nativeReverse=arrayProto.reverse;/* Built-in method references that are verified to be native. */var DataView=getNative(context,'DataView'),Map=getNative(context,'Map'),Promise=getNative(context,'Promise'),Set=getNative(context,'Set'),WeakMap=getNative(context,'WeakMap'),nativeCreate=getNative(Object,'create');/** Used to store function metadata. */var metaMap=WeakMap&&new WeakMap();/** Used to lookup unminified function names. */var realNames={};/** Used to detect maps, sets, and weakmaps. */var dataViewCtorString=toSource(DataView),mapCtorString=toSource(Map),promiseCtorString=toSource(Promise),setCtorString=toSource(Set),weakMapCtorString=toSource(WeakMap);/** Used to convert symbols to primitives and strings. */var symbolProto=Symbol?Symbol.prototype:undefined$1,symbolValueOf=symbolProto?symbolProto.valueOf:undefined$1,symbolToString=symbolProto?symbolProto.toString:undefined$1;/*------------------------------------------------------------------------*/ /** + * Creates a `lodash` object which wraps `value` to enable implicit method + * chain sequences. Methods that operate on and return arrays, collections, + * and functions can be chained together. Methods that retrieve a single value + * or may return a primitive value will automatically end the chain sequence + * and return the unwrapped value. Otherwise, the value must be unwrapped + * with `_#value`. + * + * Explicit chain sequences, which must be unwrapped with `_#value`, may be + * enabled using `_.chain`. + * + * The execution of chained methods is lazy, that is, it's deferred until + * `_#value` is implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. + * Shortcut fusion is an optimization to merge iteratee calls; this avoids + * the creation of intermediate arrays and can greatly reduce the number of + * iteratee executions. Sections of a chain sequence qualify for shortcut + * fusion if the section is applied to an array and iteratees accept only + * one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the `_#value` method is + * directly or indirectly included in the build. + * + * In addition to lodash methods, wrappers have `Array` and `String` methods. + * + * The wrapper `Array` methods are: + * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` + * + * The wrapper `String` methods are: + * `replace` and `split` + * + * The wrapper methods that support shortcut fusion are: + * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, + * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, + * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` + * + * The chainable wrapper methods are: + * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, + * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, + * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, + * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, + * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, + * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, + * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, + * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, + * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, + * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, + * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, + * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, + * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, + * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, + * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, + * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, + * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, + * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, + * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, + * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, + * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, + * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, + * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, + * `zipObject`, `zipObjectDeep`, and `zipWith` + * + * The wrapper methods that are **not** chainable by default are: + * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, + * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, + * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, + * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, + * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, + * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, + * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, + * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, + * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, + * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, + * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, + * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, + * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, + * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, + * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, + * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, + * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, + * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, + * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, + * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, + * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, + * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, + * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, + * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, + * `upperFirst`, `value`, and `words` + * + * @name _ + * @constructor + * @category Seq + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2, 3]); + * + * // Returns an unwrapped value. + * wrapped.reduce(_.add); + * // => 6 + * + * // Returns a wrapped value. + * var squares = wrapped.map(square); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */function lodash(value){if(isObjectLike(value)&&!isArray(value)&&!(value instanceof LazyWrapper)){if(value instanceof LodashWrapper){return value;}if(hasOwnProperty.call(value,'__wrapped__')){return wrapperClone(value);}}return new LodashWrapper(value);}/** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */var baseCreate=function(){function object(){}return function(proto){if(!isObject(proto)){return {};}if(objectCreate){return objectCreate(proto);}object.prototype=proto;var result=new object();object.prototype=undefined$1;return result;};}();/** + * The function whose prototype chain sequence wrappers inherit from. + * + * @private + */function baseLodash(){// No operation performed. + }/** + * The base constructor for creating `lodash` wrapper objects. + * + * @private + * @param {*} value The value to wrap. + * @param {boolean} [chainAll] Enable explicit method chain sequences. + */function LodashWrapper(value,chainAll){this.__wrapped__=value;this.__actions__=[];this.__chain__=!!chainAll;this.__index__=0;this.__values__=undefined$1;}/** + * By default, the template delimiters used by lodash are like those in + * embedded Ruby (ERB) as well as ES2015 template strings. Change the + * following template settings to use alternative delimiters. + * + * @static + * @memberOf _ + * @type {Object} + */lodash.templateSettings={/** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */'escape':reEscape,/** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */'evaluate':reEvaluate,/** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */'interpolate':reInterpolate,/** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */'variable':'',/** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */'imports':{/** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */'_':lodash}};// Ensure wrappers are instances of `baseLodash`. + lodash.prototype=baseLodash.prototype;lodash.prototype.constructor=lodash;LodashWrapper.prototype=baseCreate(baseLodash.prototype);LodashWrapper.prototype.constructor=LodashWrapper;/*------------------------------------------------------------------------*/ /** + * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. + * + * @private + * @constructor + * @param {*} value The value to wrap. + */function LazyWrapper(value){this.__wrapped__=value;this.__actions__=[];this.__dir__=1;this.__filtered__=false;this.__iteratees__=[];this.__takeCount__=MAX_ARRAY_LENGTH;this.__views__=[];}/** + * Creates a clone of the lazy wrapper object. + * + * @private + * @name clone + * @memberOf LazyWrapper + * @returns {Object} Returns the cloned `LazyWrapper` object. + */function lazyClone(){var result=new LazyWrapper(this.__wrapped__);result.__actions__=copyArray(this.__actions__);result.__dir__=this.__dir__;result.__filtered__=this.__filtered__;result.__iteratees__=copyArray(this.__iteratees__);result.__takeCount__=this.__takeCount__;result.__views__=copyArray(this.__views__);return result;}/** + * Reverses the direction of lazy iteration. + * + * @private + * @name reverse + * @memberOf LazyWrapper + * @returns {Object} Returns the new reversed `LazyWrapper` object. + */function lazyReverse(){if(this.__filtered__){var result=new LazyWrapper(this);result.__dir__=-1;result.__filtered__=true;}else {result=this.clone();result.__dir__*=-1;}return result;}/** + * Extracts the unwrapped value from its lazy wrapper. + * + * @private + * @name value + * @memberOf LazyWrapper + * @returns {*} Returns the unwrapped value. + */function lazyValue(){var array=this.__wrapped__.value(),dir=this.__dir__,isArr=isArray(array),isRight=dir<0,arrLength=isArr?array.length:0,view=getView(0,arrLength,this.__views__),start=view.start,end=view.end,length=end-start,index=isRight?end:start-1,iteratees=this.__iteratees__,iterLength=iteratees.length,resIndex=0,takeCount=nativeMin(length,this.__takeCount__);if(!isArr||!isRight&&arrLength==length&&takeCount==length){return baseWrapperValue(array,this.__actions__);}var result=[];outer:while(length--&&resIndex-1;}/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */function listCacheSet(key,value){var data=this.__data__,index=assocIndexOf(data,key);if(index<0){++this.size;data.push([key,value]);}else {data[index][1]=value;}return this;}// Add methods to `ListCache`. + ListCache.prototype.clear=listCacheClear;ListCache.prototype['delete']=listCacheDelete;ListCache.prototype.get=listCacheGet;ListCache.prototype.has=listCacheHas;ListCache.prototype.set=listCacheSet;/*------------------------------------------------------------------------*/ /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */function MapCache(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index=lower?number:lower;}}return number;}/** + * The base implementation of `_.clone` and `_.cloneDeep` which tracks + * traversed objects. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} bitmask The bitmask flags. + * 1 - Deep clone + * 2 - Flatten inherited properties + * 4 - Clone symbols + * @param {Function} [customizer] The function to customize cloning. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The parent object of `value`. + * @param {Object} [stack] Tracks traversed objects and their clone counterparts. + * @returns {*} Returns the cloned value. + */function baseClone(value,bitmask,customizer,key,object,stack){var result,isDeep=bitmask&CLONE_DEEP_FLAG,isFlat=bitmask&CLONE_FLAT_FLAG,isFull=bitmask&CLONE_SYMBOLS_FLAG;if(customizer){result=object?customizer(value,key,object,stack):customizer(value);}if(result!==undefined$1){return result;}if(!isObject(value)){return value;}var isArr=isArray(value);if(isArr){result=initCloneArray(value);if(!isDeep){return copyArray(value,result);}}else {var tag=getTag(value),isFunc=tag==funcTag||tag==genTag;if(isBuffer(value)){return cloneBuffer(value,isDeep);}if(tag==objectTag||tag==argsTag||isFunc&&!object){result=isFlat||isFunc?{}:initCloneObject(value);if(!isDeep){return isFlat?copySymbolsIn(value,baseAssignIn(result,value)):copySymbols(value,baseAssign(result,value));}}else {if(!cloneableTags[tag]){return object?value:{};}result=initCloneByTag(value,tag,isDeep);}}// Check for circular references and return its corresponding clone. + stack||(stack=new Stack());var stacked=stack.get(value);if(stacked){return stacked;}stack.set(value,result);if(isSet(value)){value.forEach(function(subValue){result.add(baseClone(subValue,bitmask,customizer,subValue,value,stack));});}else if(isMap(value)){value.forEach(function(subValue,key){result.set(key,baseClone(subValue,bitmask,customizer,key,value,stack));});}var keysFunc=isFull?isFlat?getAllKeysIn:getAllKeys:isFlat?keysIn:keys;var props=isArr?undefined$1:keysFunc(value);arrayEach(props||value,function(subValue,key){if(props){key=subValue;subValue=value[key];}// Recursively populate clone (susceptible to call stack limits). + assignValue(result,key,baseClone(subValue,bitmask,customizer,key,value,stack));});return result;}/** + * The base implementation of `_.conforms` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property predicates to conform to. + * @returns {Function} Returns the new spec function. + */function baseConforms(source){var props=keys(source);return function(object){return baseConformsTo(object,source,props);};}/** + * The base implementation of `_.conformsTo` which accepts `props` to check. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + */function baseConformsTo(object,source,props){var length=props.length;if(object==null){return !length;}object=Object(object);while(length--){var key=props[length],predicate=source[key],value=object[key];if(value===undefined$1&&!(key in object)||!predicate(value)){return false;}}return true;}/** + * The base implementation of `_.delay` and `_.defer` which accepts `args` + * to provide to `func`. + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {Array} args The arguments to provide to `func`. + * @returns {number|Object} Returns the timer id or timeout object. + */function baseDelay(func,wait,args){if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}return setTimeout(function(){func.apply(undefined$1,args);},wait);}/** + * The base implementation of methods like `_.difference` without support + * for excluding multiple arrays or iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + */function baseDifference(array,values,iteratee,comparator){var index=-1,includes=arrayIncludes,isCommon=true,length=array.length,result=[],valuesLength=values.length;if(!length){return result;}if(iteratee){values=arrayMap(values,baseUnary(iteratee));}if(comparator){includes=arrayIncludesWith;isCommon=false;}else if(values.length>=LARGE_ARRAY_SIZE){includes=cacheHas;isCommon=false;values=new SetCache(values);}outer:while(++indexlength?0:length+start;}end=end===undefined$1||end>length?length:toInteger(end);if(end<0){end+=length;}end=start>end?0:toLength(end);while(start0&&predicate(value)){if(depth>1){// Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value,depth-1,predicate,isStrict,result);}else {arrayPush(result,value);}}else if(!isStrict){result[result.length]=value;}}return result;}/** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */var baseFor=createBaseFor();/** + * This function is like `baseFor` except that it iterates over properties + * in the opposite order. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */var baseForRight=createBaseFor(true);/** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */function baseForOwn(object,iteratee){return object&&baseFor(object,iteratee,keys);}/** + * The base implementation of `_.forOwnRight` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */function baseForOwnRight(object,iteratee){return object&&baseForRight(object,iteratee,keys);}/** + * The base implementation of `_.functions` which creates an array of + * `object` function property names filtered from `props`. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} props The property names to filter. + * @returns {Array} Returns the function names. + */function baseFunctions(object,props){return arrayFilter(props,function(key){return isFunction(object[key]);});}/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */function baseGet(object,path){path=castPath(path,object);var index=0,length=path.length;while(object!=null&&indexother;}/** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */function baseHas(object,key){return object!=null&&hasOwnProperty.call(object,key);}/** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */function baseHasIn(object,key){return object!=null&&key in Object(object);}/** + * The base implementation of `_.inRange` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to check. + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + */function baseInRange(number,start,end){return number>=nativeMin(start,end)&&number=120&&array.length>=120)?new SetCache(othIndex&&array):undefined$1;}array=arrays[0];var index=-1,seen=caches[0];outer:while(++index-1){if(seen!==array){splice.call(seen,fromIndex,1);}splice.call(array,fromIndex,1);}}return array;}/** + * The base implementation of `_.pullAt` without support for individual + * indexes or capturing the removed elements. + * + * @private + * @param {Array} array The array to modify. + * @param {number[]} indexes The indexes of elements to remove. + * @returns {Array} Returns `array`. + */function basePullAt(array,indexes){var length=array?indexes.length:0,lastIndex=length-1;while(length--){var index=indexes[length];if(length==lastIndex||index!==previous){var previous=index;if(isIndex(index)){splice.call(array,index,1);}else {baseUnset(array,index);}}}return array;}/** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {number} lower The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the random number. + */function baseRandom(lower,upper){return lower+nativeFloor(nativeRandom()*(upper-lower+1));}/** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @param {number} step The value to increment or decrement by. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */function baseRange(start,end,step,fromRight){var index=-1,length=nativeMax(nativeCeil((end-start)/(step||1)),0),result=Array(length);while(length--){result[fromRight?length:++index]=start;start+=step;}return result;}/** + * The base implementation of `_.repeat` which doesn't coerce arguments. + * + * @private + * @param {string} string The string to repeat. + * @param {number} n The number of times to repeat the string. + * @returns {string} Returns the repeated string. + */function baseRepeat(string,n){var result='';if(!string||n<1||n>MAX_SAFE_INTEGER){return result;}// Leverage the exponentiation by squaring algorithm for a faster repeat. + // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. + do{if(n%2){result+=string;}n=nativeFloor(n/2);if(n){string+=string;}}while(n);return result;}/** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */function baseRest(func,start){return setToString(overRest(func,start,identity),func+'');}/** + * The base implementation of `_.sample`. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + */function baseSample(collection){return arraySample(values(collection));}/** + * The base implementation of `_.sampleSize` without param guards. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */function baseSampleSize(collection,n){var array=values(collection);return shuffleSelf(array,baseClamp(n,0,array.length));}/** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */function baseSet(object,path,value,customizer){if(!isObject(object)){return object;}path=castPath(path,object);var index=-1,length=path.length,lastIndex=length-1,nested=object;while(nested!=null&&++indexlength?0:length+start;}end=end>length?length:end;if(end<0){end+=length;}length=start>end?0:end-start>>>0;start>>>=0;var result=Array(length);while(++index>>1,computed=array[mid];if(computed!==null&&!isSymbol(computed)&&(retHighest?computed<=value:computed=LARGE_ARRAY_SIZE){var set=iteratee?null:createSet(array);if(set){return setToArray(set);}isCommon=false;includes=cacheHas;seen=new SetCache();}else {seen=iteratee?[]:result;}outer:while(++index=length?array:baseSlice(array,start,end);}/** + * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). + * + * @private + * @param {number|Object} id The timer id or timeout object of the timer to clear. + */var clearTimeout=ctxClearTimeout||function(id){return root.clearTimeout(id);};/** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */function cloneBuffer(buffer,isDeep){if(isDeep){return buffer.slice();}var length=buffer.length,result=allocUnsafe?allocUnsafe(length):new buffer.constructor(length);buffer.copy(result);return result;}/** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */function cloneArrayBuffer(arrayBuffer){var result=new arrayBuffer.constructor(arrayBuffer.byteLength);new Uint8Array(result).set(new Uint8Array(arrayBuffer));return result;}/** + * Creates a clone of `dataView`. + * + * @private + * @param {Object} dataView The data view to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned data view. + */function cloneDataView(dataView,isDeep){var buffer=isDeep?cloneArrayBuffer(dataView.buffer):dataView.buffer;return new dataView.constructor(buffer,dataView.byteOffset,dataView.byteLength);}/** + * Creates a clone of `regexp`. + * + * @private + * @param {Object} regexp The regexp to clone. + * @returns {Object} Returns the cloned regexp. + */function cloneRegExp(regexp){var result=new regexp.constructor(regexp.source,reFlags.exec(regexp));result.lastIndex=regexp.lastIndex;return result;}/** + * Creates a clone of the `symbol` object. + * + * @private + * @param {Object} symbol The symbol object to clone. + * @returns {Object} Returns the cloned symbol object. + */function cloneSymbol(symbol){return symbolValueOf?Object(symbolValueOf.call(symbol)):{};}/** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */function cloneTypedArray(typedArray,isDeep){var buffer=isDeep?cloneArrayBuffer(typedArray.buffer):typedArray.buffer;return new typedArray.constructor(buffer,typedArray.byteOffset,typedArray.length);}/** + * Compares values to sort them in ascending order. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {number} Returns the sort order indicator for `value`. + */function compareAscending(value,other){if(value!==other){var valIsDefined=value!==undefined$1,valIsNull=value===null,valIsReflexive=value===value,valIsSymbol=isSymbol(value);var othIsDefined=other!==undefined$1,othIsNull=other===null,othIsReflexive=other===other,othIsSymbol=isSymbol(other);if(!othIsNull&&!othIsSymbol&&!valIsSymbol&&value>other||valIsSymbol&&othIsDefined&&othIsReflexive&&!othIsNull&&!othIsSymbol||valIsNull&&othIsDefined&&othIsReflexive||!valIsDefined&&othIsReflexive||!valIsReflexive){return 1;}if(!valIsNull&&!valIsSymbol&&!othIsSymbol&&value=ordersLength){return result;}var order=orders[index];return result*(order=='desc'?-1:1);}}// Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications + // that causes it, under certain circumstances, to provide the same value for + // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 + // for more details. + // + // This also ensures a stable sort in V8 and other engines. + // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. + return object.index-other.index;}/** + * Creates an array that is the composition of partially applied arguments, + * placeholders, and provided arguments into a single array of arguments. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to prepend to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */function composeArgs(args,partials,holders,isCurried){var argsIndex=-1,argsLength=args.length,holdersLength=holders.length,leftIndex=-1,leftLength=partials.length,rangeLength=nativeMax(argsLength-holdersLength,0),result=Array(leftLength+rangeLength),isUncurried=!isCurried;while(++leftIndex1?sources[length-1]:undefined$1,guard=length>2?sources[2]:undefined$1;customizer=assigner.length>3&&typeof customizer=='function'?(length--,customizer):undefined$1;if(guard&&isIterateeCall(sources[0],sources[1],guard)){customizer=length<3?undefined$1:customizer;length=1;}object=Object(object);while(++index-1?iterable[iteratee?collection[index]:index]:undefined$1;};}/** + * Creates a `_.flow` or `_.flowRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new flow function. + */function createFlow(fromRight){return flatRest(function(funcs){var length=funcs.length,index=length,prereq=LodashWrapper.prototype.thru;if(fromRight){funcs.reverse();}while(index--){var func=funcs[index];if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}if(prereq&&!wrapper&&getFuncName(func)=='wrapper'){var wrapper=new LodashWrapper([],true);}}index=wrapper?index:length;while(++index1){args.reverse();}if(isAry&&aryarrLength)){return false;}// Check that cyclic values are equal. + var arrStacked=stack.get(array);var othStacked=stack.get(other);if(arrStacked&&othStacked){return arrStacked==other&&othStacked==array;}var index=-1,result=true,seen=bitmask&COMPARE_UNORDERED_FLAG?new SetCache():undefined$1;stack.set(array,other);stack.set(other,array);// Ignore non-index properties. + while(++index1?'& ':'')+details[lastIndex];details=details.join(length>2?', ':' ');return source.replace(reWrapComment,'{\n/* [wrapped with '+details+'] */\n');}/** + * Checks if `value` is a flattenable `arguments` object or array. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + */function isFlattenable(value){return isArray(value)||isArguments(value)||!!(spreadableSymbol&&value&&value[spreadableSymbol]);}/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */function isIndex(value,length){var type=typeof value;length=length==null?MAX_SAFE_INTEGER:length;return !!length&&(type=='number'||type!='symbol'&&reIsUint.test(value))&&value>-1&&value%1==0&&value0){if(++count>=HOT_COUNT){return arguments[0];}}else {count=0;}return func.apply(undefined$1,arguments);};}/** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */function shuffleSelf(array,size){var index=-1,length=array.length,lastIndex=length-1;size=size===undefined$1?length:size;while(++index [['a', 'b'], ['c', 'd']] + * + * _.chunk(['a', 'b', 'c', 'd'], 3); + * // => [['a', 'b', 'c'], ['d']] + */function chunk(array,size,guard){if(guard?isIterateeCall(array,size,guard):size===undefined$1){size=1;}else {size=nativeMax(toInteger(size),0);}var length=array==null?0:array.length;if(!length||size<1){return [];}var index=0,resIndex=0,result=Array(nativeCeil(length/size));while(index [1, 2, 3] + */function compact(array){var index=-1,length=array==null?0:array.length,resIndex=0,result=[];while(++index [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */function concat(){var length=arguments.length;if(!length){return [];}var args=Array(length-1),array=arguments[0],index=length;while(index--){args[index-1]=arguments[index];}return arrayPush(isArray(array)?copyArray(array):[array],baseFlatten(args,1));}/** + * Creates an array of `array` values not included in the other given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * **Note:** Unlike `_.pullAll`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.without, _.xor + * @example + * + * _.difference([2, 1], [2, 3]); + * // => [1] + */var difference=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true)):[];});/** + * This method is like `_.difference` except that it accepts `iteratee` which + * is invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * **Note:** Unlike `_.pullAllBy`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2] + * + * // The `_.property` iteratee shorthand. + * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */var differenceBy=baseRest(function(array,values){var iteratee=last(values);if(isArrayLikeObject(iteratee)){iteratee=undefined$1;}return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),getIteratee(iteratee,2)):[];});/** + * This method is like `_.difference` except that it accepts `comparator` + * which is invoked to compare elements of `array` to `values`. The order and + * references of result values are determined by the first array. The comparator + * is invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.pullAllWith`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */var differenceWith=baseRest(function(array,values){var comparator=last(values);if(isArrayLikeObject(comparator)){comparator=undefined$1;}return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),undefined$1,comparator):[];});/** + * Creates a slice of `array` with `n` elements dropped from the beginning. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.drop([1, 2, 3]); + * // => [2, 3] + * + * _.drop([1, 2, 3], 2); + * // => [3] + * + * _.drop([1, 2, 3], 5); + * // => [] + * + * _.drop([1, 2, 3], 0); + * // => [1, 2, 3] + */function drop(array,n,guard){var length=array==null?0:array.length;if(!length){return [];}n=guard||n===undefined$1?1:toInteger(n);return baseSlice(array,n<0?0:n,length);}/** + * Creates a slice of `array` with `n` elements dropped from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.dropRight([1, 2, 3]); + * // => [1, 2] + * + * _.dropRight([1, 2, 3], 2); + * // => [1] + * + * _.dropRight([1, 2, 3], 5); + * // => [] + * + * _.dropRight([1, 2, 3], 0); + * // => [1, 2, 3] + */function dropRight(array,n,guard){var length=array==null?0:array.length;if(!length){return [];}n=guard||n===undefined$1?1:toInteger(n);n=length-n;return baseSlice(array,0,n<0?0:n);}/** + * Creates a slice of `array` excluding elements dropped from the end. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.dropRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney'] + * + * // The `_.matches` iteratee shorthand. + * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropRightWhile(users, ['active', false]); + * // => objects for ['barney'] + * + * // The `_.property` iteratee shorthand. + * _.dropRightWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */function dropRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),true,true):[];}/** + * Creates a slice of `array` excluding elements dropped from the beginning. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.dropWhile(users, function(o) { return !o.active; }); + * // => objects for ['pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.dropWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropWhile(users, ['active', false]); + * // => objects for ['pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.dropWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */function dropWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),true):[];}/** + * Fills elements of `array` with `value` from `start` up to, but not + * including, `end`. + * + * **Note:** This method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Array + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.fill(array, 'a'); + * console.log(array); + * // => ['a', 'a', 'a'] + * + * _.fill(Array(3), 2); + * // => [2, 2, 2] + * + * _.fill([4, 6, 8, 10], '*', 1, 3); + * // => [4, '*', '*', 10] + */function fill(array,value,start,end){var length=array==null?0:array.length;if(!length){return [];}if(start&&typeof start!='number'&&isIterateeCall(array,value,start)){start=0;end=length;}return baseFill(array,value,start,end);}/** + * This method is like `_.find` except that it returns the index of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.findIndex(users, function(o) { return o.user == 'barney'; }); + * // => 0 + * + * // The `_.matches` iteratee shorthand. + * _.findIndex(users, { 'user': 'fred', 'active': false }); + * // => 1 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findIndex(users, ['active', false]); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.findIndex(users, 'active'); + * // => 2 + */function findIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length){return -1;}var index=fromIndex==null?0:toInteger(fromIndex);if(index<0){index=nativeMax(length+index,0);}return baseFindIndex(array,getIteratee(predicate,3),index);}/** + * This method is like `_.findIndex` except that it iterates over elements + * of `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); + * // => 2 + * + * // The `_.matches` iteratee shorthand. + * _.findLastIndex(users, { 'user': 'barney', 'active': true }); + * // => 0 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastIndex(users, ['active', false]); + * // => 2 + * + * // The `_.property` iteratee shorthand. + * _.findLastIndex(users, 'active'); + * // => 0 + */function findLastIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length){return -1;}var index=length-1;if(fromIndex!==undefined$1){index=toInteger(fromIndex);index=fromIndex<0?nativeMax(length+index,0):nativeMin(index,length-1);}return baseFindIndex(array,getIteratee(predicate,3),index,true);}/** + * Flattens `array` a single level deep. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flatten([1, [2, [3, [4]], 5]]); + * // => [1, 2, [3, [4]], 5] + */function flatten(array){var length=array==null?0:array.length;return length?baseFlatten(array,1):[];}/** + * Recursively flattens `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */function flattenDeep(array){var length=array==null?0:array.length;return length?baseFlatten(array,INFINITY):[];}/** + * Recursively flatten `array` up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Array + * @param {Array} array The array to flatten. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * var array = [1, [2, [3, [4]], 5]]; + * + * _.flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * _.flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */function flattenDepth(array,depth){var length=array==null?0:array.length;if(!length){return [];}depth=depth===undefined$1?1:toInteger(depth);return baseFlatten(array,depth);}/** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['a', 1], ['b', 2]]); + * // => { 'a': 1, 'b': 2 } + */function fromPairs(pairs){var index=-1,length=pairs==null?0:pairs.length,result={};while(++index 1 + * + * _.head([]); + * // => undefined + */function head(array){return array&&array.length?array[0]:undefined$1;}/** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the + * offset from the end of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // Search from the `fromIndex`. + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */function indexOf(array,value,fromIndex){var length=array==null?0:array.length;if(!length){return -1;}var index=fromIndex==null?0:toInteger(fromIndex);if(index<0){index=nativeMax(length+index,0);}return baseIndexOf(array,value,index);}/** + * Gets all but the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.initial([1, 2, 3]); + * // => [1, 2] + */function initial(array){var length=array==null?0:array.length;return length?baseSlice(array,0,-1):[];}/** + * Creates an array of unique values that are included in all given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersection([2, 1], [2, 3]); + * // => [2] + */var intersection=baseRest(function(arrays){var mapped=arrayMap(arrays,castArrayLikeObject);return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped):[];});/** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + * + * // The `_.property` iteratee shorthand. + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */var intersectionBy=baseRest(function(arrays){var iteratee=last(arrays),mapped=arrayMap(arrays,castArrayLikeObject);if(iteratee===last(mapped)){iteratee=undefined$1;}else {mapped.pop();}return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,getIteratee(iteratee,2)):[];});/** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The order and references + * of result values are determined by the first array. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */var intersectionWith=baseRest(function(arrays){var comparator=last(arrays),mapped=arrayMap(arrays,castArrayLikeObject);comparator=typeof comparator=='function'?comparator:undefined$1;if(comparator){mapped.pop();}return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,undefined$1,comparator):[];});/** + * Converts all elements in `array` into a string separated by `separator`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to convert. + * @param {string} [separator=','] The element separator. + * @returns {string} Returns the joined string. + * @example + * + * _.join(['a', 'b', 'c'], '~'); + * // => 'a~b~c' + */function join(array,separator){return array==null?'':nativeJoin.call(array,separator);}/** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */function last(array){var length=array==null?0:array.length;return length?array[length-1]:undefined$1;}/** + * This method is like `_.indexOf` except that it iterates over elements of + * `array` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * // Search from the `fromIndex`. + * _.lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + */function lastIndexOf(array,value,fromIndex){var length=array==null?0:array.length;if(!length){return -1;}var index=length;if(fromIndex!==undefined$1){index=toInteger(fromIndex);index=index<0?nativeMax(length+index,0):nativeMin(index,length-1);}return value===value?strictLastIndexOf(array,value,index):baseFindIndex(array,baseIsNaN,index,true);}/** + * Gets the element at index `n` of `array`. If `n` is negative, the nth + * element from the end is returned. + * + * @static + * @memberOf _ + * @since 4.11.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=0] The index of the element to return. + * @returns {*} Returns the nth element of `array`. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * + * _.nth(array, 1); + * // => 'b' + * + * _.nth(array, -2); + * // => 'c'; + */function nth(array,n){return array&&array.length?baseNth(array,toInteger(n)):undefined$1;}/** + * Removes all given values from `array` using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` + * to remove elements from an array by predicate. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...*} [values] The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pull(array, 'a', 'c'); + * console.log(array); + * // => ['b', 'b'] + */var pull=baseRest(pullAll);/** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pullAll(array, ['a', 'c']); + * console.log(array); + * // => ['b', 'b'] + */function pullAll(array,values){return array&&array.length&&values&&values.length?basePullAll(array,values):array;}/** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */function pullAllBy(array,values,iteratee){return array&&array.length&&values&&values.length?basePullAll(array,values,getIteratee(iteratee,2)):array;}/** + * This method is like `_.pullAll` except that it accepts `comparator` which + * is invoked to compare elements of `array` to `values`. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */function pullAllWith(array,values,comparator){return array&&array.length&&values&&values.length?basePullAll(array,values,undefined$1,comparator):array;}/** + * Removes elements from `array` corresponding to `indexes` and returns an + * array of removed elements. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...(number|number[])} [indexes] The indexes of elements to remove. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * var pulled = _.pullAt(array, [1, 3]); + * + * console.log(array); + * // => ['a', 'c'] + * + * console.log(pulled); + * // => ['b', 'd'] + */var pullAt=flatRest(function(array,indexes){var length=array==null?0:array.length,result=baseAt(array,indexes);basePullAt(array,arrayMap(indexes,function(index){return isIndex(index,length)?+index:index;}).sort(compareAscending));return result;});/** + * Removes all elements from `array` that `predicate` returns truthy for + * and returns an array of the removed elements. The predicate is invoked + * with three arguments: (value, index, array). + * + * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` + * to pull elements from an array by value. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = [1, 2, 3, 4]; + * var evens = _.remove(array, function(n) { + * return n % 2 == 0; + * }); + * + * console.log(array); + * // => [1, 3] + * + * console.log(evens); + * // => [2, 4] + */function remove(array,predicate){var result=[];if(!(array&&array.length)){return result;}var index=-1,indexes=[],length=array.length;predicate=getIteratee(predicate,3);while(++index [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */function reverse(array){return array==null?array:nativeReverse.call(array);}/** + * Creates a slice of `array` from `start` up to, but not including, `end`. + * + * **Note:** This method is used instead of + * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are + * returned. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */function slice(array,start,end){var length=array==null?0:array.length;if(!length){return [];}if(end&&typeof end!='number'&&isIterateeCall(array,start,end)){start=0;end=length;}else {start=start==null?0:toInteger(start);end=end===undefined$1?length:toInteger(end);}return baseSlice(array,start,end);}/** + * Uses a binary search to determine the lowest index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + */function sortedIndex(array,value){return baseSortedIndex(array,value);}/** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); + * // => 0 + */function sortedIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2));}/** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([4, 5, 5, 5, 6], 5); + * // => 1 + */function sortedIndexOf(array,value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value);if(index 4 + */function sortedLastIndex(array,value){return baseSortedIndex(array,value,true);}/** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 1 + * + * // The `_.property` iteratee shorthand. + * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); + * // => 1 + */function sortedLastIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2),true);}/** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); + * // => 3 + */function sortedLastIndexOf(array,value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value,true)-1;if(eq(array[index],value)){return index;}}return -1;}/** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */function sortedUniq(array){return array&&array.length?baseSortedUniq(array):[];}/** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.3] + */function sortedUniqBy(array,iteratee){return array&&array.length?baseSortedUniq(array,getIteratee(iteratee,2)):[];}/** + * Gets all but the first element of `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.tail([1, 2, 3]); + * // => [2, 3] + */function tail(array){var length=array==null?0:array.length;return length?baseSlice(array,1,length):[];}/** + * Creates a slice of `array` with `n` elements taken from the beginning. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.take([1, 2, 3]); + * // => [1] + * + * _.take([1, 2, 3], 2); + * // => [1, 2] + * + * _.take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.take([1, 2, 3], 0); + * // => [] + */function take(array,n,guard){if(!(array&&array.length)){return [];}n=guard||n===undefined$1?1:toInteger(n);return baseSlice(array,0,n<0?0:n);}/** + * Creates a slice of `array` with `n` elements taken from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.takeRight([1, 2, 3]); + * // => [3] + * + * _.takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * _.takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.takeRight([1, 2, 3], 0); + * // => [] + */function takeRight(array,n,guard){var length=array==null?0:array.length;if(!length){return [];}n=guard||n===undefined$1?1:toInteger(n);n=length-n;return baseSlice(array,n<0?0:n,length);}/** + * Creates a slice of `array` with elements taken from the end. Elements are + * taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.takeRightWhile(users, 'active'); + * // => [] + */function takeRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),false,true):[];}/** + * Creates a slice of `array` with elements taken from the beginning. Elements + * are taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matches` iteratee shorthand. + * _.takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * // The `_.property` iteratee shorthand. + * _.takeWhile(users, 'active'); + * // => [] + */function takeWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3)):[];}/** + * Creates an array of unique values, in order, from all given arrays using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.union([2], [1, 2]); + * // => [2, 1] + */var union=baseRest(function(arrays){return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true));});/** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which uniqueness is computed. Result values are chosen from the first + * array in which the value occurs. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */var unionBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee)){iteratee=undefined$1;}return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),getIteratee(iteratee,2));});/** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. Result values are chosen from + * the first array in which the value occurs. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */var unionWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=='function'?comparator:undefined$1;return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),undefined$1,comparator);});/** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. The order of result values is determined by the order they occur + * in the array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */function uniq(array){return array&&array.length?baseUniq(array):[];}/** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The order of result values is determined by the + * order they occur in the array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */function uniqBy(array,iteratee){return array&&array.length?baseUniq(array,getIteratee(iteratee,2)):[];}/** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The order of result values is + * determined by the order they occur in the array.The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */function uniqWith(array,comparator){comparator=typeof comparator=='function'?comparator:undefined$1;return array&&array.length?baseUniq(array,undefined$1,comparator):[];}/** + * This method is like `_.zip` except that it accepts an array of grouped + * elements and creates an array regrouping the elements to their pre-zip + * configuration. + * + * @static + * @memberOf _ + * @since 1.2.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + * + * _.unzip(zipped); + * // => [['a', 'b'], [1, 2], [true, false]] + */function unzip(array){if(!(array&&array.length)){return [];}var length=0;array=arrayFilter(array,function(group){if(isArrayLikeObject(group)){length=nativeMax(group.length,length);return true;}});return baseTimes(length,function(index){return arrayMap(array,baseProperty(index));});}/** + * This method is like `_.unzip` except that it accepts `iteratee` to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @param {Function} [iteratee=_.identity] The function to combine + * regrouped values. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip([1, 2], [10, 20], [100, 200]); + * // => [[1, 10, 100], [2, 20, 200]] + * + * _.unzipWith(zipped, _.add); + * // => [3, 30, 300] + */function unzipWith(array,iteratee){if(!(array&&array.length)){return [];}var result=unzip(array);if(iteratee==null){return result;}return arrayMap(result,function(group){return apply(iteratee,undefined$1,group);});}/** + * Creates an array excluding all given values using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.pull`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...*} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.xor + * @example + * + * _.without([2, 1, 2, 3], 1, 2); + * // => [3] + */var without=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,values):[];});/** + * Creates an array of unique values that is the + * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) + * of the given arrays. The order of result values is determined by the order + * they occur in the arrays. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.without + * @example + * + * _.xor([2, 1], [2, 3]); + * // => [1, 3] + */var xor=baseRest(function(arrays){return baseXor(arrayFilter(arrays,isArrayLikeObject));});/** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which by which they're compared. The order of result values is determined + * by the order they occur in the arrays. The iteratee is invoked with one + * argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2, 3.4] + * + * // The `_.property` iteratee shorthand. + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */var xorBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee)){iteratee=undefined$1;}return baseXor(arrayFilter(arrays,isArrayLikeObject),getIteratee(iteratee,2));});/** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The order of result values is + * determined by the order they occur in the arrays. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */var xorWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=='function'?comparator:undefined$1;return baseXor(arrayFilter(arrays,isArrayLikeObject),undefined$1,comparator);});/** + * Creates an array of grouped elements, the first of which contains the + * first elements of the given arrays, the second of which contains the + * second elements of the given arrays, and so on. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + */var zip=baseRest(unzip);/** + * This method is like `_.fromPairs` except that it accepts two arrays, + * one of property identifiers and one of corresponding values. + * + * @static + * @memberOf _ + * @since 0.4.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObject(['a', 'b'], [1, 2]); + * // => { 'a': 1, 'b': 2 } + */function zipObject(props,values){return baseZipObject(props||[],values||[],assignValue);}/** + * This method is like `_.zipObject` except that it supports property paths. + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); + * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */function zipObjectDeep(props,values){return baseZipObject(props||[],values||[],baseSet);}/** + * This method is like `_.zip` except that it accepts `iteratee` to specify + * how grouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee=_.identity] The function to combine + * grouped values. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { + * return a + b + c; + * }); + * // => [111, 222] + */var zipWith=baseRest(function(arrays){var length=arrays.length,iteratee=length>1?arrays[length-1]:undefined$1;iteratee=typeof iteratee=='function'?(arrays.pop(),iteratee):undefined$1;return unzipWith(arrays,iteratee);});/*------------------------------------------------------------------------*/ /** + * Creates a `lodash` wrapper instance that wraps `value` with explicit method + * chain sequences enabled. The result of such sequences must be unwrapped + * with `_#value`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Seq + * @param {*} value The value to wrap. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'pebbles', 'age': 1 } + * ]; + * + * var youngest = _ + * .chain(users) + * .sortBy('age') + * .map(function(o) { + * return o.user + ' is ' + o.age; + * }) + * .head() + * .value(); + * // => 'pebbles is 1' + */function chain(value){var result=lodash(value);result.__chain__=true;return result;}/** + * This method invokes `interceptor` and returns `value`. The interceptor + * is invoked with one argument; (value). The purpose of this method is to + * "tap into" a method chain sequence in order to modify intermediate results. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns `value`. + * @example + * + * _([1, 2, 3]) + * .tap(function(array) { + * // Mutate input array. + * array.pop(); + * }) + * .reverse() + * .value(); + * // => [2, 1] + */function tap(value,interceptor){interceptor(value);return value;}/** + * This method is like `_.tap` except that it returns the result of `interceptor`. + * The purpose of this method is to "pass thru" values replacing intermediate + * results in a method chain sequence. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns the result of `interceptor`. + * @example + * + * _(' abc ') + * .chain() + * .trim() + * .thru(function(value) { + * return [value]; + * }) + * .value(); + * // => ['abc'] + */function thru(value,interceptor){return interceptor(value);}/** + * This method is the wrapper version of `_.at`. + * + * @name at + * @memberOf _ + * @since 1.0.0 + * @category Seq + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _(object).at(['a[0].b.c', 'a[1]']).value(); + * // => [3, 4] + */var wrapperAt=flatRest(function(paths){var length=paths.length,start=length?paths[0]:0,value=this.__wrapped__,interceptor=function(object){return baseAt(object,paths);};if(length>1||this.__actions__.length||!(value instanceof LazyWrapper)||!isIndex(start)){return this.thru(interceptor);}value=value.slice(start,+start+(length?1:0));value.__actions__.push({'func':thru,'args':[interceptor],'thisArg':undefined$1});return new LodashWrapper(value,this.__chain__).thru(function(array){if(length&&!array.length){array.push(undefined$1);}return array;});});/** + * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. + * + * @name chain + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // A sequence without explicit chaining. + * _(users).head(); + * // => { 'user': 'barney', 'age': 36 } + * + * // A sequence with explicit chaining. + * _(users) + * .chain() + * .head() + * .pick('user') + * .value(); + * // => { 'user': 'barney' } + */function wrapperChain(){return chain(this);}/** + * Executes the chain sequence and returns the wrapped result. + * + * @name commit + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2]; + * var wrapped = _(array).push(3); + * + * console.log(array); + * // => [1, 2] + * + * wrapped = wrapped.commit(); + * console.log(array); + * // => [1, 2, 3] + * + * wrapped.last(); + * // => 3 + * + * console.log(array); + * // => [1, 2, 3] + */function wrapperCommit(){return new LodashWrapper(this.value(),this.__chain__);}/** + * Gets the next value on a wrapped object following the + * [iterator protocol](https://mdn.io/iteration_protocols#iterator). + * + * @name next + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the next iterator value. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped.next(); + * // => { 'done': false, 'value': 1 } + * + * wrapped.next(); + * // => { 'done': false, 'value': 2 } + * + * wrapped.next(); + * // => { 'done': true, 'value': undefined } + */function wrapperNext(){if(this.__values__===undefined$1){this.__values__=toArray(this.value());}var done=this.__index__>=this.__values__.length,value=done?undefined$1:this.__values__[this.__index__++];return {'done':done,'value':value};}/** + * Enables the wrapper to be iterable. + * + * @name Symbol.iterator + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the wrapper object. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped[Symbol.iterator]() === wrapped; + * // => true + * + * Array.from(wrapped); + * // => [1, 2] + */function wrapperToIterator(){return this;}/** + * Creates a clone of the chain sequence planting `value` as the wrapped value. + * + * @name plant + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @param {*} value The value to plant. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2]).map(square); + * var other = wrapped.plant([3, 4]); + * + * other.value(); + * // => [9, 16] + * + * wrapped.value(); + * // => [1, 4] + */function wrapperPlant(value){var result,parent=this;while(parent instanceof baseLodash){var clone=wrapperClone(parent);clone.__index__=0;clone.__values__=undefined$1;if(result){previous.__wrapped__=clone;}else {result=clone;}var previous=clone;parent=parent.__wrapped__;}previous.__wrapped__=value;return result;}/** + * This method is the wrapper version of `_.reverse`. + * + * **Note:** This method mutates the wrapped array. + * + * @name reverse + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2, 3]; + * + * _(array).reverse().value() + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */function wrapperReverse(){var value=this.__wrapped__;if(value instanceof LazyWrapper){var wrapped=value;if(this.__actions__.length){wrapped=new LazyWrapper(this);}wrapped=wrapped.reverse();wrapped.__actions__.push({'func':thru,'args':[reverse],'thisArg':undefined$1});return new LodashWrapper(wrapped,this.__chain__);}return this.thru(reverse);}/** + * Executes the chain sequence to resolve the unwrapped value. + * + * @name value + * @memberOf _ + * @since 0.1.0 + * @alias toJSON, valueOf + * @category Seq + * @returns {*} Returns the resolved unwrapped value. + * @example + * + * _([1, 2, 3]).value(); + * // => [1, 2, 3] + */function wrapperValue(){return baseWrapperValue(this.__wrapped__,this.__actions__);}/*------------------------------------------------------------------------*/ /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the number of times the key was returned by `iteratee`. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.countBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': 1, '6': 2 } + * + * // The `_.property` iteratee shorthand. + * _.countBy(['one', 'two', 'three'], 'length'); + * // => { '3': 2, '5': 1 } + */var countBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key)){++result[key];}else {baseAssignValue(result,key,1);}});/** + * Checks if `predicate` returns truthy for **all** elements of `collection`. + * Iteration is stopped once `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * **Note:** This method returns `true` for + * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because + * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of + * elements of empty collections. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + * @example + * + * _.every([true, 1, null, 'yes'], Boolean); + * // => false + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.every(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.every(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.every(users, 'active'); + * // => false + */function every(collection,predicate,guard){var func=isArray(collection)?arrayEvery:baseEvery;if(guard&&isIterateeCall(collection,predicate,guard)){predicate=undefined$1;}return func(collection,getIteratee(predicate,3));}/** + * Iterates over elements of `collection`, returning an array of all elements + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * **Note:** Unlike `_.remove`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.reject + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * _.filter(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.filter(users, { 'age': 36, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.filter(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.filter(users, 'active'); + * // => objects for ['barney'] + * + * // Combining several predicates using `_.overEvery` or `_.overSome`. + * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]])); + * // => objects for ['fred', 'barney'] + */function filter(collection,predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,getIteratee(predicate,3));}/** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.find(users, function(o) { return o.age < 40; }); + * // => object for 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.find(users, { 'age': 1, 'active': true }); + * // => object for 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.find(users, ['active', false]); + * // => object for 'fred' + * + * // The `_.property` iteratee shorthand. + * _.find(users, 'active'); + * // => object for 'barney' + */var find=createFind(findIndex);/** + * This method is like `_.find` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=collection.length-1] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * _.findLast([1, 2, 3, 4], function(n) { + * return n % 2 == 1; + * }); + * // => 3 + */var findLast=createFind(findLastIndex);/** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */function flatMap(collection,iteratee){return baseFlatten(map(collection,iteratee),1);}/** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */function flatMapDeep(collection,iteratee){return baseFlatten(map(collection,iteratee),INFINITY);}/** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */function flatMapDepth(collection,iteratee,depth){depth=depth===undefined$1?1:toInteger(depth);return baseFlatten(map(collection,iteratee),depth);}/** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */function forEach(collection,iteratee){var func=isArray(collection)?arrayEach:baseEach;return func(collection,getIteratee(iteratee,3));}/** + * This method is like `_.forEach` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @alias eachRight + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEach + * @example + * + * _.forEachRight([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `2` then `1`. + */function forEachRight(collection,iteratee){var func=isArray(collection)?arrayEachRight:baseEachRight;return func(collection,getIteratee(iteratee,3));}/** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The order of grouped values + * is determined by the order they occur in `collection`. The corresponding + * value of each key is an array of elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.groupBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * // The `_.property` iteratee shorthand. + * _.groupBy(['one', 'two', 'three'], 'length'); + * // => { '3': ['one', 'two'], '5': ['three'] } + */var groupBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key)){result[key].push(value);}else {baseAssignValue(result,key,[value]);}});/** + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {boolean} Returns `true` if `value` is found, else `false`. + * @example + * + * _.includes([1, 2, 3], 1); + * // => true + * + * _.includes([1, 2, 3], 1, 2); + * // => false + * + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true + * + * _.includes('abcd', 'bc'); + * // => true + */function includes(collection,value,fromIndex,guard){collection=isArrayLike(collection)?collection:values(collection);fromIndex=fromIndex&&!guard?toInteger(fromIndex):0;var length=collection.length;if(fromIndex<0){fromIndex=nativeMax(length+fromIndex,0);}return isString(collection)?fromIndex<=length&&collection.indexOf(value,fromIndex)>-1:!!length&&baseIndexOf(collection,value,fromIndex)>-1;}/** + * Invokes the method at `path` of each element in `collection`, returning + * an array of the results of each invoked method. Any additional arguments + * are provided to each invoked method. If `path` is a function, it's invoked + * for, and `this` bound to, each element in `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array|Function|string} path The path of the method to invoke or + * the function invoked per iteration. + * @param {...*} [args] The arguments to invoke each method with. + * @returns {Array} Returns the array of results. + * @example + * + * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * _.invokeMap([123, 456], String.prototype.split, ''); + * // => [['1', '2', '3'], ['4', '5', '6']] + */var invokeMap=baseRest(function(collection,path,args){var index=-1,isFunc=typeof path=='function',result=isArrayLike(collection)?Array(collection.length):[];baseEach(collection,function(value){result[++index]=isFunc?apply(path,value,args):baseInvoke(value,path,args);});return result;});/** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the last element responsible for generating the key. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * var array = [ + * { 'dir': 'left', 'code': 97 }, + * { 'dir': 'right', 'code': 100 } + * ]; + * + * _.keyBy(array, function(o) { + * return String.fromCharCode(o.code); + * }); + * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * + * _.keyBy(array, 'dir'); + * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + */var keyBy=createAggregator(function(result,value,key){baseAssignValue(result,key,value);});/** + * Creates an array of values by running each element in `collection` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. + * + * The guarded methods are: + * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, + * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, + * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, + * `template`, `trim`, `trimEnd`, `trimStart`, and `words` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + * @example + * + * function square(n) { + * return n * n; + * } + * + * _.map([4, 8], square); + * // => [16, 64] + * + * _.map({ 'a': 4, 'b': 8 }, square); + * // => [16, 64] (iteration order is not guaranteed) + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * // The `_.property` iteratee shorthand. + * _.map(users, 'user'); + * // => ['barney', 'fred'] + */function map(collection,iteratee){var func=isArray(collection)?arrayMap:baseMap;return func(collection,getIteratee(iteratee,3));}/** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] + * The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // Sort by `user` in ascending order and by `age` in descending order. + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + */function orderBy(collection,iteratees,orders,guard){if(collection==null){return [];}if(!isArray(iteratees)){iteratees=iteratees==null?[]:[iteratees];}orders=guard?undefined$1:orders;if(!isArray(orders)){orders=orders==null?[]:[orders];}return baseOrderBy(collection,iteratees,orders);}/** + * Creates an array of elements split into two groups, the first of which + * contains elements `predicate` returns truthy for, the second of which + * contains elements `predicate` returns falsey for. The predicate is + * invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the array of grouped elements. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true }, + * { 'user': 'pebbles', 'age': 1, 'active': false } + * ]; + * + * _.partition(users, function(o) { return o.active; }); + * // => objects for [['fred'], ['barney', 'pebbles']] + * + * // The `_.matches` iteratee shorthand. + * _.partition(users, { 'age': 1, 'active': false }); + * // => objects for [['pebbles'], ['barney', 'fred']] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.partition(users, ['active', false]); + * // => objects for [['barney', 'pebbles'], ['fred']] + * + * // The `_.property` iteratee shorthand. + * _.partition(users, 'active'); + * // => objects for [['fred'], ['barney', 'pebbles']] + */var partition=createAggregator(function(result,value,key){result[key?0:1].push(value);},function(){return [[],[]];});/** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` thru `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not given, the first element of `collection` is used as the initial + * value. The iteratee is invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, + * and `sortBy` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduceRight + * @example + * + * _.reduce([1, 2], function(sum, n) { + * return sum + n; + * }, 0); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * return result; + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) + */function reduce(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduce:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEach);}/** + * This method is like `_.reduce` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduce + * @example + * + * var array = [[0, 1], [2, 3], [4, 5]]; + * + * _.reduceRight(array, function(flattened, other) { + * return flattened.concat(other); + * }, []); + * // => [4, 5, 2, 3, 0, 1] + */function reduceRight(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduceRight:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEachRight);}/** + * The opposite of `_.filter`; this method returns the elements of `collection` + * that `predicate` does **not** return truthy for. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.filter + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true } + * ]; + * + * _.reject(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.reject(users, { 'age': 40, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.reject(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.reject(users, 'active'); + * // => objects for ['barney'] + */function reject(collection,predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,negate(getIteratee(predicate,3)));}/** + * Gets a random element from `collection`. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + * @example + * + * _.sample([1, 2, 3, 4]); + * // => 2 + */function sample(collection){var func=isArray(collection)?arraySample:baseSample;return func(collection);}/** + * Gets `n` random elements at unique keys from `collection` up to the + * size of `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @param {number} [n=1] The number of elements to sample. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the random elements. + * @example + * + * _.sampleSize([1, 2, 3], 2); + * // => [3, 1] + * + * _.sampleSize([1, 2, 3], 4); + * // => [2, 3, 1] + */function sampleSize(collection,n,guard){if(guard?isIterateeCall(collection,n,guard):n===undefined$1){n=1;}else {n=toInteger(n);}var func=isArray(collection)?arraySampleSize:baseSampleSize;return func(collection,n);}/** + * Creates an array of shuffled values, using a version of the + * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + * @example + * + * _.shuffle([1, 2, 3, 4]); + * // => [4, 1, 3, 2] + */function shuffle(collection){var func=isArray(collection)?arrayShuffle:baseShuffle;return func(collection);}/** + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable string keyed properties for objects. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @returns {number} Returns the collection size. + * @example + * + * _.size([1, 2, 3]); + * // => 3 + * + * _.size({ 'a': 1, 'b': 2 }); + * // => 2 + * + * _.size('pebbles'); + * // => 7 + */function size(collection){if(collection==null){return 0;}if(isArrayLike(collection)){return isString(collection)?stringSize(collection):collection.length;}var tag=getTag(collection);if(tag==mapTag||tag==setTag){return collection.size;}return baseKeys(collection).length;}/** + * Checks if `predicate` returns truthy for **any** element of `collection`. + * Iteration is stopped once `predicate` returns truthy. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.some(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.some(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.some(users, 'active'); + * // => true + */function some(collection,predicate,guard){var func=isArray(collection)?arraySome:baseSome;if(guard&&isIterateeCall(collection,predicate,guard)){predicate=undefined$1;}return func(collection,getIteratee(predicate,3));}/** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection thru each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[])} [iteratees=[_.identity]] + * The iteratees to sort by. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 30 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]] + */var sortBy=baseRest(function(collection,iteratees){if(collection==null){return [];}var length=iteratees.length;if(length>1&&isIterateeCall(collection,iteratees[0],iteratees[1])){iteratees=[];}else if(length>2&&isIterateeCall(iteratees[0],iteratees[1],iteratees[2])){iteratees=[iteratees[0]];}return baseOrderBy(collection,baseFlatten(iteratees,1),[]);});/*------------------------------------------------------------------------*/ /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */var now=ctxNow||function(){return root.Date.now();};/*------------------------------------------------------------------------*/ /** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {number} n The number of calls before `func` is invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */function after(n,func){if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}n=toInteger(n);return function(){if(--n<1){return func.apply(this,arguments);}};}/** + * Creates a function that invokes `func`, with up to `n` arguments, + * ignoring any additional arguments. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @param {number} [n=func.length] The arity cap. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.ary(parseInt, 1)); + * // => [6, 8, 10] + */function ary(func,n,guard){n=guard?undefined$1:n;n=func&&n==null?func.length:n;return createWrap(func,WRAP_ARY_FLAG,undefined$1,undefined$1,undefined$1,undefined$1,n);}/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */function before(n,func){var result;if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}n=toInteger(n);return function(){if(--n>0){result=func.apply(this,arguments);}if(n<=1){func=undefined$1;}return result;};}/** + * Creates a function that invokes `func` with the `this` binding of `thisArg` + * and `partials` prepended to the arguments it receives. + * + * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for partially applied arguments. + * + * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" + * property of bound functions. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * + * var object = { 'user': 'fred' }; + * + * var bound = _.bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * // Bound with placeholders. + * var bound = _.bind(greet, object, _, '!'); + * bound('hi'); + * // => 'hi fred!' + */var bind=baseRest(function(func,thisArg,partials){var bitmask=WRAP_BIND_FLAG;if(partials.length){var holders=replaceHolders(partials,getHolder(bind));bitmask|=WRAP_PARTIAL_FLAG;}return createWrap(func,bitmask,thisArg,partials,holders);});/** + * Creates a function that invokes the method at `object[key]` with `partials` + * prepended to the arguments it receives. + * + * This method differs from `_.bind` by allowing bound functions to reference + * methods that may be redefined or don't yet exist. See + * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) + * for more details. + * + * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Function + * @param {Object} object The object to invoke the method on. + * @param {string} key The key of the method. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'user': 'fred', + * 'greet': function(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * }; + * + * var bound = _.bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function(greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * var bound = _.bindKey(object, 'greet', _, '!'); + * bound('hi'); + * // => 'hiya fred!' + */var bindKey=baseRest(function(object,key,partials){var bitmask=WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG;if(partials.length){var holders=replaceHolders(partials,getHolder(bindKey));bitmask|=WRAP_PARTIAL_FLAG;}return createWrap(key,bitmask,object,partials,holders);});/** + * Creates a function that accepts arguments of `func` and either invokes + * `func` returning its result, if at least `arity` number of arguments have + * been provided, or returns a function that accepts the remaining `func` + * arguments, and so on. The arity of `func` may be specified if `func.length` + * is not sufficient. + * + * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curry(abc); + * + * curried(1)(2)(3); + * // => [1, 2, 3] + * + * curried(1, 2)(3); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(1)(_, 3)(2); + * // => [1, 2, 3] + */function curry(func,arity,guard){arity=guard?undefined$1:arity;var result=createWrap(func,WRAP_CURRY_FLAG,undefined$1,undefined$1,undefined$1,undefined$1,undefined$1,arity);result.placeholder=curry.placeholder;return result;}/** + * This method is like `_.curry` except that arguments are applied to `func` + * in the manner of `_.partialRight` instead of `_.partial`. + * + * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curryRight(abc); + * + * curried(3)(2)(1); + * // => [1, 2, 3] + * + * curried(2, 3)(1); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(3)(1, _)(2); + * // => [1, 2, 3] + */function curryRight(func,arity,guard){arity=guard?undefined$1:arity;var result=createWrap(func,WRAP_CURRY_RIGHT_FLAG,undefined$1,undefined$1,undefined$1,undefined$1,undefined$1,arity);result.placeholder=curryRight.placeholder;return result;}/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */function debounce(func,wait,options){var lastArgs,lastThis,maxWait,result,timerId,lastCallTime,lastInvokeTime=0,leading=false,maxing=false,trailing=true;if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}wait=toNumber(wait)||0;if(isObject(options)){leading=!!options.leading;maxing='maxWait'in options;maxWait=maxing?nativeMax(toNumber(options.maxWait)||0,wait):maxWait;trailing='trailing'in options?!!options.trailing:trailing;}function invokeFunc(time){var args=lastArgs,thisArg=lastThis;lastArgs=lastThis=undefined$1;lastInvokeTime=time;result=func.apply(thisArg,args);return result;}function leadingEdge(time){// Reset any `maxWait` timer. + lastInvokeTime=time;// Start the timer for the trailing edge. + timerId=setTimeout(timerExpired,wait);// Invoke the leading edge. + return leading?invokeFunc(time):result;}function remainingWait(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime,timeWaiting=wait-timeSinceLastCall;return maxing?nativeMin(timeWaiting,maxWait-timeSinceLastInvoke):timeWaiting;}function shouldInvoke(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime;// Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return lastCallTime===undefined$1||timeSinceLastCall>=wait||timeSinceLastCall<0||maxing&&timeSinceLastInvoke>=maxWait;}function timerExpired(){var time=now();if(shouldInvoke(time)){return trailingEdge(time);}// Restart the timer. + timerId=setTimeout(timerExpired,remainingWait(time));}function trailingEdge(time){timerId=undefined$1;// Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if(trailing&&lastArgs){return invokeFunc(time);}lastArgs=lastThis=undefined$1;return result;}function cancel(){if(timerId!==undefined$1){clearTimeout(timerId);}lastInvokeTime=0;lastArgs=lastCallTime=lastThis=timerId=undefined$1;}function flush(){return timerId===undefined$1?result:trailingEdge(now());}function debounced(){var time=now(),isInvoking=shouldInvoke(time);lastArgs=arguments;lastThis=this;lastCallTime=time;if(isInvoking){if(timerId===undefined$1){return leadingEdge(lastCallTime);}if(maxing){// Handle invocations in a tight loop. + clearTimeout(timerId);timerId=setTimeout(timerExpired,wait);return invokeFunc(lastCallTime);}}if(timerId===undefined$1){timerId=setTimeout(timerExpired,wait);}return result;}debounced.cancel=cancel;debounced.flush=flush;return debounced;}/** + * Defers invoking the `func` until the current call stack has cleared. Any + * additional arguments are provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to defer. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { + * console.log(text); + * }, 'deferred'); + * // => Logs 'deferred' after one millisecond. + */var defer=baseRest(function(func,args){return baseDelay(func,1,args);});/** + * Invokes `func` after `wait` milliseconds. Any additional arguments are + * provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { + * console.log(text); + * }, 1000, 'later'); + * // => Logs 'later' after one second. + */var delay=baseRest(function(func,wait,args){return baseDelay(func,toNumber(wait)||0,args);});/** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new flipped function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */function flip(func){return createWrap(func,WRAP_FLIP_FLAG);}/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */function memoize(func,resolver){if(typeof func!='function'||resolver!=null&&typeof resolver!='function'){throw new TypeError(FUNC_ERROR_TEXT);}var memoized=function(){var args=arguments,key=resolver?resolver.apply(this,args):args[0],cache=memoized.cache;if(cache.has(key)){return cache.get(key);}var result=func.apply(this,args);memoized.cache=cache.set(key,result)||cache;return result;};memoized.cache=new(memoize.Cache||MapCache)();return memoized;}// Expose `MapCache`. + memoize.Cache=MapCache;/** + * Creates a function that negates the result of the predicate `func`. The + * `func` predicate is invoked with the `this` binding and arguments of the + * created function. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} predicate The predicate to negate. + * @returns {Function} Returns the new negated function. + * @example + * + * function isEven(n) { + * return n % 2 == 0; + * } + * + * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); + * // => [1, 3, 5] + */function negate(predicate){if(typeof predicate!='function'){throw new TypeError(FUNC_ERROR_TEXT);}return function(){var args=arguments;switch(args.length){case 0:return !predicate.call(this);case 1:return !predicate.call(this,args[0]);case 2:return !predicate.call(this,args[0],args[1]);case 3:return !predicate.call(this,args[0],args[1],args[2]);}return !predicate.apply(this,args);};}/** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */function once(func){return before(2,func);}/** + * Creates a function that invokes `func` with its arguments transformed. + * + * @static + * @since 4.0.0 + * @memberOf _ + * @category Function + * @param {Function} func The function to wrap. + * @param {...(Function|Function[])} [transforms=[_.identity]] + * The argument transforms. + * @returns {Function} Returns the new function. + * @example + * + * function doubled(n) { + * return n * 2; + * } + * + * function square(n) { + * return n * n; + * } + * + * var func = _.overArgs(function(x, y) { + * return [x, y]; + * }, [square, doubled]); + * + * func(9, 3); + * // => [81, 6] + * + * func(10, 5); + * // => [100, 10] + */var overArgs=castRest(function(func,transforms){transforms=transforms.length==1&&isArray(transforms[0])?arrayMap(transforms[0],baseUnary(getIteratee())):arrayMap(baseFlatten(transforms,1),baseUnary(getIteratee()));var funcsLength=transforms.length;return baseRest(function(args){var index=-1,length=nativeMin(args.length,funcsLength);while(++index 'hello fred' + * + * // Partially applied with placeholders. + * var greetFred = _.partial(greet, _, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + */var partial=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partial));return createWrap(func,WRAP_PARTIAL_FLAG,undefined$1,partials,holders);});/** + * This method is like `_.partial` except that partially applied arguments + * are appended to the arguments it receives. + * + * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var greetFred = _.partialRight(greet, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + * + * // Partially applied with placeholders. + * var sayHelloTo = _.partialRight(greet, 'hello', _); + * sayHelloTo('fred'); + * // => 'hello fred' + */var partialRight=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partialRight));return createWrap(func,WRAP_PARTIAL_RIGHT_FLAG,undefined$1,partials,holders);});/** + * Creates a function that invokes `func` with arguments arranged according + * to the specified `indexes` where the argument value at the first index is + * provided as the first argument, the argument value at the second index is + * provided as the second argument, and so on. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to rearrange arguments for. + * @param {...(number|number[])} indexes The arranged argument indexes. + * @returns {Function} Returns the new function. + * @example + * + * var rearged = _.rearg(function(a, b, c) { + * return [a, b, c]; + * }, [2, 0, 1]); + * + * rearged('b', 'c', 'a') + * // => ['a', 'b', 'c'] + */var rearg=flatRest(function(func,indexes){return createWrap(func,WRAP_REARG_FLAG,undefined$1,undefined$1,undefined$1,indexes);});/** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */function rest(func,start){if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}start=start===undefined$1?start:toInteger(start);return baseRest(func,start);}/** + * Creates a function that invokes `func` with the `this` binding of the + * create function and an array of arguments much like + * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). + * + * **Note:** This method is based on the + * [spread operator](https://mdn.io/spread_operator). + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Function + * @param {Function} func The function to spread arguments over. + * @param {number} [start=0] The start position of the spread. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.spread(function(who, what) { + * return who + ' says ' + what; + * }); + * + * say(['fred', 'hello']); + * // => 'fred says hello' + * + * var numbers = Promise.all([ + * Promise.resolve(40), + * Promise.resolve(36) + * ]); + * + * numbers.then(_.spread(function(x, y) { + * return x + y; + * })); + * // => a Promise of 76 + */function spread(func,start){if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}start=start==null?0:nativeMax(toInteger(start),0);return baseRest(function(args){var array=args[start],otherArgs=castSlice(args,0,start);if(array){arrayPush(otherArgs,array);}return apply(func,this,otherArgs);});}/** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */function throttle(func,wait,options){var leading=true,trailing=true;if(typeof func!='function'){throw new TypeError(FUNC_ERROR_TEXT);}if(isObject(options)){leading='leading'in options?!!options.leading:leading;trailing='trailing'in options?!!options.trailing:trailing;}return debounce(func,wait,{'leading':leading,'maxWait':wait,'trailing':trailing});}/** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */function unary(func){return ary(func,1);}/** + * Creates a function that provides `value` to `wrapper` as its first + * argument. Any additional arguments provided to the function are appended + * to those provided to the `wrapper`. The wrapper is invoked with the `this` + * binding of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {*} value The value to wrap. + * @param {Function} [wrapper=identity] The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '

' + func(text) + '

'; + * }); + * + * p('fred, barney, & pebbles'); + * // => '

fred, barney, & pebbles

' + */function wrap(value,wrapper){return partial(castFunction(wrapper),value);}/*------------------------------------------------------------------------*/ /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */function castArray(){if(!arguments.length){return [];}var value=arguments[0];return isArray(value)?value:[value];}/** + * Creates a shallow clone of `value`. + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) + * and supports cloning arrays, array buffers, booleans, date objects, maps, + * numbers, `Object` objects, regexes, sets, strings, symbols, and typed + * arrays. The own enumerable properties of `arguments` objects are cloned + * as plain objects. An empty object is returned for uncloneable values such + * as error objects, functions, DOM nodes, and WeakMaps. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to clone. + * @returns {*} Returns the cloned value. + * @see _.cloneDeep + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var shallow = _.clone(objects); + * console.log(shallow[0] === objects[0]); + * // => true + */function clone(value){return baseClone(value,CLONE_SYMBOLS_FLAG);}/** + * This method is like `_.clone` except that it accepts `customizer` which + * is invoked to produce the cloned value. If `customizer` returns `undefined`, + * cloning is handled by the method instead. The `customizer` is invoked with + * up to four arguments; (value [, index|key, object, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the cloned value. + * @see _.cloneDeepWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * } + * + * var el = _.cloneWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 0 + */function cloneWith(value,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;return baseClone(value,CLONE_SYMBOLS_FLAG,customizer);}/** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */function cloneDeep(value){return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG);}/** + * This method is like `_.cloneWith` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the deep cloned value. + * @see _.cloneWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(true); + * } + * } + * + * var el = _.cloneDeepWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 20 + */function cloneDeepWith(value,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG,customizer);}/** + * Checks if `object` conforms to `source` by invoking the predicate + * properties of `source` with the corresponding property values of `object`. + * + * **Note:** This method is equivalent to `_.conforms` when `source` is + * partially applied. + * + * @static + * @memberOf _ + * @since 4.14.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); + * // => true + * + * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); + * // => false + */function conformsTo(object,source){return source==null||baseConformsTo(object,source,keys(source));}/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */function eq(value,other){return value===other||value!==value&&other!==other;}/** + * Checks if `value` is greater than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false + */var gt=createRelationalOperation(baseGt);/** + * Checks if `value` is greater than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than or equal to + * `other`, else `false`. + * @see _.lte + * @example + * + * _.gte(3, 1); + * // => true + * + * _.gte(3, 3); + * // => true + * + * _.gte(1, 3); + * // => false + */var gte=createRelationalOperation(function(value,other){return value>=other;});/** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */var isArguments=baseIsArguments(function(){return arguments;}())?baseIsArguments:function(value){return isObjectLike(value)&&hasOwnProperty.call(value,'callee')&&!propertyIsEnumerable.call(value,'callee');};/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */var isArray=Array.isArray;/** + * Checks if `value` is classified as an `ArrayBuffer` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + * @example + * + * _.isArrayBuffer(new ArrayBuffer(2)); + * // => true + * + * _.isArrayBuffer(new Array(2)); + * // => false + */var isArrayBuffer=nodeIsArrayBuffer?baseUnary(nodeIsArrayBuffer):baseIsArrayBuffer;/** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */function isArrayLike(value){return value!=null&&isLength(value.length)&&!isFunction(value);}/** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */function isArrayLikeObject(value){return isObjectLike(value)&&isArrayLike(value);}/** + * Checks if `value` is classified as a boolean primitive or object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. + * @example + * + * _.isBoolean(false); + * // => true + * + * _.isBoolean(null); + * // => false + */function isBoolean(value){return value===true||value===false||isObjectLike(value)&&baseGetTag(value)==boolTag;}/** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */var isBuffer=nativeIsBuffer||stubFalse;/** + * Checks if `value` is classified as a `Date` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + * @example + * + * _.isDate(new Date); + * // => true + * + * _.isDate('Mon April 23 2012'); + * // => false + */var isDate=nodeIsDate?baseUnary(nodeIsDate):baseIsDate;/** + * Checks if `value` is likely a DOM element. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * @example + * + * _.isElement(document.body); + * // => true + * + * _.isElement(''); + * // => false + */function isElement(value){return isObjectLike(value)&&value.nodeType===1&&!isPlainObject(value);}/** + * Checks if `value` is an empty object, collection, map, or set. + * + * Objects are considered empty if they have no own enumerable string keyed + * properties. + * + * Array-like values such as `arguments` objects, arrays, buffers, strings, or + * jQuery-like collections are considered empty if they have a `length` of `0`. + * Similarly, maps and sets are considered empty if they have a `size` of `0`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is empty, else `false`. + * @example + * + * _.isEmpty(null); + * // => true + * + * _.isEmpty(true); + * // => true + * + * _.isEmpty(1); + * // => true + * + * _.isEmpty([1, 2, 3]); + * // => false + * + * _.isEmpty({ 'a': 1 }); + * // => false + */function isEmpty(value){if(value==null){return true;}if(isArrayLike(value)&&(isArray(value)||typeof value=='string'||typeof value.splice=='function'||isBuffer(value)||isTypedArray(value)||isArguments(value))){return !value.length;}var tag=getTag(value);if(tag==mapTag||tag==setTag){return !value.size;}if(isPrototype(value)){return !baseKeys(value).length;}for(var key in value){if(hasOwnProperty.call(value,key)){return false;}}return true;}/** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */function isEqual(value,other){return baseIsEqual(value,other);}/** + * This method is like `_.isEqual` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with up to + * six arguments: (objValue, othValue [, index|key, object, other, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */function isEqualWith(value,other,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;var result=customizer?customizer(value,other):undefined$1;return result===undefined$1?baseIsEqual(value,other,undefined$1,customizer):!!result;}/** + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an error object, else `false`. + * @example + * + * _.isError(new Error); + * // => true + * + * _.isError(Error); + * // => false + */function isError(value){if(!isObjectLike(value)){return false;}var tag=baseGetTag(value);return tag==errorTag||tag==domExcTag||typeof value.message=='string'&&typeof value.name=='string'&&!isPlainObject(value);}/** + * Checks if `value` is a finite primitive number. + * + * **Note:** This method is based on + * [`Number.isFinite`](https://mdn.io/Number/isFinite). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. + * @example + * + * _.isFinite(3); + * // => true + * + * _.isFinite(Number.MIN_VALUE); + * // => true + * + * _.isFinite(Infinity); + * // => false + * + * _.isFinite('3'); + * // => false + */function isFinite(value){return typeof value=='number'&&nativeIsFinite(value);}/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */function isFunction(value){if(!isObject(value)){return false;}// The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag=baseGetTag(value);return tag==funcTag||tag==genTag||tag==asyncTag||tag==proxyTag;}/** + * Checks if `value` is an integer. + * + * **Note:** This method is based on + * [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */function isInteger(value){return typeof value=='number'&&value==toInteger(value);}/** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */function isLength(value){return typeof value=='number'&&value>-1&&value%1==0&&value<=MAX_SAFE_INTEGER;}/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */function isObject(value){var type=typeof value;return value!=null&&(type=='object'||type=='function');}/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */function isObjectLike(value){return value!=null&&typeof value=='object';}/** + * Checks if `value` is classified as a `Map` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + * @example + * + * _.isMap(new Map); + * // => true + * + * _.isMap(new WeakMap); + * // => false + */var isMap=nodeIsMap?baseUnary(nodeIsMap):baseIsMap;/** + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. + * + * **Note:** This method is equivalent to `_.matches` when `source` is + * partially applied. + * + * Partial comparisons will match empty array and empty object `source` + * values against any array or object value, respectively. See `_.isEqual` + * for a list of supported value comparisons. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.isMatch(object, { 'b': 2 }); + * // => true + * + * _.isMatch(object, { 'b': 1 }); + * // => false + */function isMatch(object,source){return object===source||baseIsMatch(object,source,getMatchData(source));}/** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with five + * arguments: (objValue, srcValue, index|key, object, source). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */function isMatchWith(object,source,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;return baseIsMatch(object,source,getMatchData(source),customizer);}/** + * Checks if `value` is `NaN`. + * + * **Note:** This method is based on + * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as + * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for + * `undefined` and other non-number values. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + * @example + * + * _.isNaN(NaN); + * // => true + * + * _.isNaN(new Number(NaN)); + * // => true + * + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false + */function isNaN(value){// An `NaN` primitive is the only value that is not equal to itself. + // Perform the `toStringTag` check first to avoid errors with some + // ActiveX objects in IE. + return isNumber(value)&&value!=+value;}/** + * Checks if `value` is a pristine native function. + * + * **Note:** This method can't reliably detect native functions in the presence + * of the core-js package because core-js circumvents this kind of detection. + * Despite multiple requests, the core-js maintainer has made it clear: any + * attempt to fix the detection will be obstructed. As a result, we're left + * with little choice but to throw an error. Unfortunately, this also affects + * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), + * which rely on core-js. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */function isNative(value){if(isMaskable(value)){throw new Error(CORE_ERROR_TEXT);}return baseIsNative(value);}/** + * Checks if `value` is `null`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `null`, else `false`. + * @example + * + * _.isNull(null); + * // => true + * + * _.isNull(void 0); + * // => false + */function isNull(value){return value===null;}/** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */function isNil(value){return value==null;}/** + * Checks if `value` is classified as a `Number` primitive or object. + * + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a number, else `false`. + * @example + * + * _.isNumber(3); + * // => true + * + * _.isNumber(Number.MIN_VALUE); + * // => true + * + * _.isNumber(Infinity); + * // => true + * + * _.isNumber('3'); + * // => false + */function isNumber(value){return typeof value=='number'||isObjectLike(value)&&baseGetTag(value)==numberTag;}/** + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. + * + * @static + * @memberOf _ + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */function isPlainObject(value){if(!isObjectLike(value)||baseGetTag(value)!=objectTag){return false;}var proto=getPrototype(value);if(proto===null){return true;}var Ctor=hasOwnProperty.call(proto,'constructor')&&proto.constructor;return typeof Ctor=='function'&&Ctor instanceof Ctor&&funcToString.call(Ctor)==objectCtorString;}/** + * Checks if `value` is classified as a `RegExp` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + * @example + * + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false + */var isRegExp=nodeIsRegExp?baseUnary(nodeIsRegExp):baseIsRegExp;/** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */function isSafeInteger(value){return isInteger(value)&&value>=-MAX_SAFE_INTEGER&&value<=MAX_SAFE_INTEGER;}/** + * Checks if `value` is classified as a `Set` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + * @example + * + * _.isSet(new Set); + * // => true + * + * _.isSet(new WeakSet); + * // => false + */var isSet=nodeIsSet?baseUnary(nodeIsSet):baseIsSet;/** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */function isString(value){return typeof value=='string'||!isArray(value)&&isObjectLike(value)&&baseGetTag(value)==stringTag;}/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */function isSymbol(value){return typeof value=='symbol'||isObjectLike(value)&&baseGetTag(value)==symbolTag;}/** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */var isTypedArray=nodeIsTypedArray?baseUnary(nodeIsTypedArray):baseIsTypedArray;/** + * Checks if `value` is `undefined`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */function isUndefined(value){return value===undefined$1;}/** + * Checks if `value` is classified as a `WeakMap` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. + * @example + * + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false + */function isWeakMap(value){return isObjectLike(value)&&getTag(value)==weakMapTag;}/** + * Checks if `value` is classified as a `WeakSet` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. + * @example + * + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false + */function isWeakSet(value){return isObjectLike(value)&&baseGetTag(value)==weakSetTag;}/** + * Checks if `value` is less than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + * @see _.gt + * @example + * + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false + */var lt=createRelationalOperation(baseLt);/** + * Checks if `value` is less than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than or equal to + * `other`, else `false`. + * @see _.gte + * @example + * + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); + * // => true + * + * _.lte(3, 1); + * // => false + */var lte=createRelationalOperation(function(value,other){return value<=other;});/** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */function toArray(value){if(!value){return [];}if(isArrayLike(value)){return isString(value)?stringToArray(value):copyArray(value);}if(symIterator&&value[symIterator]){return iteratorToArray(value[symIterator]());}var tag=getTag(value),func=tag==mapTag?mapToArray:tag==setTag?setToArray:values;return func(value);}/** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */function toFinite(value){if(!value){return value===0?value:0;}value=toNumber(value);if(value===INFINITY||value===-INFINITY){var sign=value<0?-1:1;return sign*MAX_INTEGER;}return value===value?value:0;}/** + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */function toInteger(value){var result=toFinite(value),remainder=result%1;return result===result?remainder?result-remainder:result:0;}/** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 + */function toLength(value){return value?baseClamp(toInteger(value),0,MAX_ARRAY_LENGTH):0;}/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */function toNumber(value){if(typeof value=='number'){return value;}if(isSymbol(value)){return NAN;}if(isObject(value)){var other=typeof value.valueOf=='function'?value.valueOf():value;value=isObject(other)?other+'':other;}if(typeof value!='string'){return value===0?value:+value;}value=baseTrim(value);var isBinary=reIsBinary.test(value);return isBinary||reIsOctal.test(value)?freeParseInt(value.slice(2),isBinary?2:8):reIsBadHex.test(value)?NAN:+value;}/** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */function toPlainObject(value){return copyObject(value,keysIn(value));}/** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3.2); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3.2'); + * // => 3 + */function toSafeInteger(value){return value?baseClamp(toInteger(value),-MAX_SAFE_INTEGER,MAX_SAFE_INTEGER):value===0?value:0;}/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */function toString(value){return value==null?'':baseToString(value);}/*------------------------------------------------------------------------*/ /** + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */var assign=createAssigner(function(object,source){if(isPrototype(source)||isArrayLike(source)){copyObject(source,keys(source),object);return;}for(var key in source){if(hasOwnProperty.call(source,key)){assignValue(object,key,source[key]);}}});/** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assign + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } + */var assignIn=createAssigner(function(object,source){copyObject(source,keysIn(source),object);});/** + * This method is like `_.assignIn` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */var assignInWith=createAssigner(function(object,source,srcIndex,customizer){copyObject(source,keysIn(source),object,customizer);});/** + * This method is like `_.assign` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignInWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */var assignWith=createAssigner(function(object,source,srcIndex,customizer){copyObject(source,keys(source),object,customizer);});/** + * Creates an array of values corresponding to `paths` of `object`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Array} Returns the picked values. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _.at(object, ['a[0].b.c', 'a[1]']); + * // => [3, 4] + */var at=flatRest(baseAt);/** + * Creates an object that inherits from the `prototype` object. If a + * `properties` object is given, its own enumerable string keyed properties + * are assigned to the created object. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Object + * @param {Object} prototype The object to inherit from. + * @param {Object} [properties] The properties to assign to the object. + * @returns {Object} Returns the new object. + * @example + * + * function Shape() { + * this.x = 0; + * this.y = 0; + * } + * + * function Circle() { + * Shape.call(this); + * } + * + * Circle.prototype = _.create(Shape.prototype, { + * 'constructor': Circle + * }); + * + * var circle = new Circle; + * circle instanceof Circle; + * // => true + * + * circle instanceof Shape; + * // => true + */function create(prototype,properties){var result=baseCreate(prototype);return properties==null?result:baseAssign(result,properties);}/** + * Assigns own and inherited enumerable string keyed properties of source + * objects to the destination object for all destination properties that + * resolve to `undefined`. Source objects are applied from left to right. + * Once a property is set, additional values of the same property are ignored. + * + * **Note:** This method mutates `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep + * @example + * + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */var defaults=baseRest(function(object,sources){object=Object(object);var index=-1;var length=sources.length;var guard=length>2?sources[2]:undefined$1;if(guard&&isIterateeCall(sources[0],sources[1],guard)){length=1;}while(++index { 'a': { 'b': 2, 'c': 3 } } + */var defaultsDeep=baseRest(function(args){args.push(undefined$1,customDefaultsMerge);return apply(mergeWith,undefined$1,args);});/** + * This method is like `_.find` except that it returns the key of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findKey(users, function(o) { return o.age < 40; }); + * // => 'barney' (iteration order is not guaranteed) + * + * // The `_.matches` iteratee shorthand. + * _.findKey(users, { 'age': 1, 'active': true }); + * // => 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findKey(users, 'active'); + * // => 'barney' + */function findKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwn);}/** + * This method is like `_.findKey` except that it iterates over elements of + * a collection in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findLastKey(users, function(o) { return o.age < 40; }); + * // => returns 'pebbles' assuming `_.findKey` returns 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.findLastKey(users, { 'age': 36, 'active': true }); + * // => 'barney' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findLastKey(users, 'active'); + * // => 'pebbles' + */function findLastKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwnRight);}/** + * Iterates over own and inherited enumerable string keyed properties of an + * object and invokes `iteratee` for each property. The iteratee is invoked + * with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forInRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forIn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). + */function forIn(object,iteratee){return object==null?object:baseFor(object,getIteratee(iteratee,3),keysIn);}/** + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forIn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forInRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. + */function forInRight(object,iteratee){return object==null?object:baseForRight(object,getIteratee(iteratee,3),keysIn);}/** + * Iterates over own enumerable string keyed properties of an object and + * invokes `iteratee` for each property. The iteratee is invoked with three + * arguments: (value, key, object). Iteratee functions may exit iteration + * early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwnRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */function forOwn(object,iteratee){return object&&baseForOwn(object,getIteratee(iteratee,3));}/** + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. + */function forOwnRight(object,iteratee){return object&&baseForOwnRight(object,getIteratee(iteratee,3));}/** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */function functions(object){return object==null?[]:baseFunctions(object,keys(object));}/** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functions + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */function functionsIn(object){return object==null?[]:baseFunctions(object,keysIn(object));}/** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */function get(object,path,defaultValue){var result=object==null?undefined$1:baseGet(object,path);return result===undefined$1?defaultValue:result;}/** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */function has(object,path){return object!=null&&hasPath(object,path,baseHas);}/** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); + * // => true + * + * _.hasIn(object, ['a', 'b']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */function hasIn(object,path){return object!=null&&hasPath(object,path,baseHasIn);}/** + * Creates an object composed of the inverted keys and values of `object`. + * If `object` contains duplicate values, subsequent values overwrite + * property assignments of previous values. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Object + * @param {Object} object The object to invert. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invert(object); + * // => { '1': 'c', '2': 'b' } + */var invert=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!='function'){value=nativeObjectToString.call(value);}result[value]=key;},constant(identity));/** + * This method is like `_.invert` except that the inverted object is generated + * from the results of running each element of `object` thru `iteratee`. The + * corresponding inverted value of each inverted key is an array of keys + * responsible for generating the inverted value. The iteratee is invoked + * with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Object + * @param {Object} object The object to invert. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } + * + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */var invertBy=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!='function'){value=nativeObjectToString.call(value);}if(hasOwnProperty.call(result,value)){result[value].push(key);}else {result[value]=[key];}},getIteratee);/** + * Invokes the method at `path` of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {...*} [args] The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + * @example + * + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; + * + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] + */var invoke=baseRest(baseInvoke);/** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */function keys(object){return isArrayLike(object)?arrayLikeKeys(object):baseKeys(object);}/** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */function keysIn(object){return isArrayLike(object)?arrayLikeKeys(object,true):baseKeysIn(object);}/** + * The opposite of `_.mapValues`; this method creates an object with the + * same values as `object` and keys generated by running each own enumerable + * string keyed property of `object` thru `iteratee`. The iteratee is invoked + * with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapValues + * @example + * + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; + * }); + * // => { 'a1': 1, 'b2': 2 } + */function mapKeys(object,iteratee){var result={};iteratee=getIteratee(iteratee,3);baseForOwn(object,function(value,key,object){baseAssignValue(result,iteratee(value,key,object),value);});return result;}/** + * Creates an object with the same keys as `object` and values generated + * by running each own enumerable string keyed property of `object` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, key, object). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapKeys + * @example + * + * var users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * + * _.mapValues(users, function(o) { return o.age; }); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + * + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + */function mapValues(object,iteratee){var result={};iteratee=getIteratee(iteratee,3);baseForOwn(object,function(value,key,object){baseAssignValue(result,key,iteratee(value,key,object));});return result;}/** + * This method is like `_.assign` except that it recursively merges own and + * inherited enumerable string keyed properties of source objects into the + * destination object. Source properties that resolve to `undefined` are + * skipped if a destination value exists. Array and plain object properties + * are merged recursively. Other objects and value types are overridden by + * assignment. Source objects are applied from left to right. Subsequent + * sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * var object = { + * 'a': [{ 'b': 2 }, { 'd': 4 }] + * }; + * + * var other = { + * 'a': [{ 'c': 3 }, { 'e': 5 }] + * }; + * + * _.merge(object, other); + * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } + */var merge=createAssigner(function(object,source,srcIndex){baseMerge(object,source,srcIndex);});/** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */var mergeWith=createAssigner(function(object,source,srcIndex,customizer){baseMerge(object,source,srcIndex,customizer);});/** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable property paths of `object` that are not omitted. + * + * **Note:** This method is considerably slower than `_.pick`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to omit. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */var omit=flatRest(function(object,paths){var result={};if(object==null){return result;}var isDeep=false;paths=arrayMap(paths,function(path){path=castPath(path,object);isDeep||(isDeep=path.length>1);return path;});copyObject(object,getAllKeysIn(object),result);if(isDeep){result=baseClone(result,CLONE_DEEP_FLAG|CLONE_FLAT_FLAG|CLONE_SYMBOLS_FLAG,customOmitClone);}var length=paths.length;while(length--){baseUnset(result,paths[length]);}return result;});/** + * The opposite of `_.pickBy`; this method creates an object composed of + * the own and inherited enumerable string keyed properties of `object` that + * `predicate` doesn't return truthy for. The predicate is invoked with two + * arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */function omitBy(object,predicate){return pickBy(object,negate(getIteratee(predicate)));}/** + * Creates an object composed of the picked `object` properties. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */var pick=flatRest(function(object,paths){return object==null?{}:basePick(object,paths);});/** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */function pickBy(object,predicate){if(object==null){return {};}var props=arrayMap(getAllKeysIn(object),function(prop){return [prop];});predicate=getIteratee(predicate);return basePickBy(object,props,function(value,path){return predicate(value,path[0]);});}/** + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */function result(object,path,defaultValue){path=castPath(path,object);var index=-1,length=path.length;// Ensure the loop is entered when path is empty. + if(!length){length=1;object=undefined$1;}while(++index 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */function set(object,path,value){return object==null?object:baseSet(object,path,value);}/** + * This method is like `_.set` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.setWith(object, '[0][1]', 'a', Object); + * // => { '0': { '1': 'a' } } + */function setWith(object,path,value,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;return object==null?object:baseSet(object,path,value,customizer);}/** + * Creates an array of own enumerable string keyed-value pairs for `object` + * which can be consumed by `_.fromPairs`. If `object` is a map or set, its + * entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entries + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) + */var toPairs=createToPairs(keys);/** + * Creates an array of own and inherited enumerable string keyed-value pairs + * for `object` which can be consumed by `_.fromPairs`. If `object` is a map + * or set, its entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entriesIn + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) + */var toPairsIn=createToPairs(keysIn);/** + * An alternative to `_.reduce`; this method transforms `object` to a new + * `accumulator` object which is the result of running each of its own + * enumerable string keyed properties thru `iteratee`, with each invocation + * potentially mutating the `accumulator` object. If `accumulator` is not + * provided, a new object with the same `[[Prototype]]` will be used. The + * iteratee is invoked with four arguments: (accumulator, value, key, object). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The custom accumulator value. + * @returns {*} Returns the accumulated value. + * @example + * + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] + * + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */function transform(object,iteratee,accumulator){var isArr=isArray(object),isArrLike=isArr||isBuffer(object)||isTypedArray(object);iteratee=getIteratee(iteratee,4);if(accumulator==null){var Ctor=object&&object.constructor;if(isArrLike){accumulator=isArr?new Ctor():[];}else if(isObject(object)){accumulator=isFunction(Ctor)?baseCreate(getPrototype(object)):{};}else {accumulator={};}}(isArrLike?arrayEach:baseForOwn)(object,function(value,index,object){return iteratee(accumulator,value,index,object);});return accumulator;}/** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */function unset(object,path){return object==null?true:baseUnset(object,path);}/** + * This method is like `_.set` except that accepts `updater` to produce the + * value to set. Use `_.updateWith` to customize `path` creation. The `updater` + * is invoked with one argument: (value). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 + * + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 + */function update(object,path,updater){return object==null?object:baseUpdate(object,path,castFunction(updater));}/** + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */function updateWith(object,path,updater,customizer){customizer=typeof customizer=='function'?customizer:undefined$1;return object==null?object:baseUpdate(object,path,castFunction(updater),customizer);}/** + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] + */function values(object){return object==null?[]:baseValues(object,keys(object));}/** + * Creates an array of the own and inherited enumerable string keyed property + * values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) + */function valuesIn(object){return object==null?[]:baseValues(object,keysIn(object));}/*------------------------------------------------------------------------*/ /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Number + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + */function clamp(number,lower,upper){if(upper===undefined$1){upper=lower;lower=undefined$1;}if(upper!==undefined$1){upper=toNumber(upper);upper=upper===upper?upper:0;}if(lower!==undefined$1){lower=toNumber(lower);lower=lower===lower?lower:0;}return baseClamp(toNumber(number),lower,upper);}/** + * Checks if `n` is between `start` and up to, but not including, `end`. If + * `end` is not specified, it's set to `start` with `start` then set to `0`. + * If `start` is greater than `end` the params are swapped to support + * negative ranges. + * + * @static + * @memberOf _ + * @since 3.3.0 + * @category Number + * @param {number} number The number to check. + * @param {number} [start=0] The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + * @see _.range, _.rangeRight + * @example + * + * _.inRange(3, 2, 4); + * // => true + * + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false + * + * _.inRange(1.2, 2); + * // => true + * + * _.inRange(5.2, 4); + * // => false + * + * _.inRange(-3, -2, -6); + * // => true + */function inRange(number,start,end){start=toFinite(start);if(end===undefined$1){end=start;start=0;}else {end=toFinite(end);}number=toNumber(number);return baseInRange(number,start,end);}/** + * Produces a random number between the inclusive `lower` and `upper` bounds. + * If only one argument is provided a number between `0` and the given number + * is returned. If `floating` is `true`, or either `lower` or `upper` are + * floats, a floating-point number is returned instead of an integer. + * + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Number + * @param {number} [lower=0] The lower bound. + * @param {number} [upper=1] The upper bound. + * @param {boolean} [floating] Specify returning a floating-point number. + * @returns {number} Returns the random number. + * @example + * + * _.random(0, 5); + * // => an integer between 0 and 5 + * + * _.random(5); + * // => also an integer between 0 and 5 + * + * _.random(5, true); + * // => a floating-point number between 0 and 5 + * + * _.random(1.2, 5.2); + * // => a floating-point number between 1.2 and 5.2 + */function random(lower,upper,floating){if(floating&&typeof floating!='boolean'&&isIterateeCall(lower,upper,floating)){upper=floating=undefined$1;}if(floating===undefined$1){if(typeof upper=='boolean'){floating=upper;upper=undefined$1;}else if(typeof lower=='boolean'){floating=lower;lower=undefined$1;}}if(lower===undefined$1&&upper===undefined$1){lower=0;upper=1;}else {lower=toFinite(lower);if(upper===undefined$1){upper=lower;lower=0;}else {upper=toFinite(upper);}}if(lower>upper){var temp=lower;lower=upper;upper=temp;}if(floating||lower%1||upper%1){var rand=nativeRandom();return nativeMin(lower+rand*(upper-lower+freeParseFloat('1e-'+((rand+'').length-1))),upper);}return baseRandom(lower,upper);}/*------------------------------------------------------------------------*/ /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */var camelCase=createCompounder(function(result,word,index){word=word.toLowerCase();return result+(index?capitalize(word):word);});/** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */function capitalize(string){return upperFirst(toString(string).toLowerCase());}/** + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */function deburr(string){string=toString(string);return string&&string.replace(reLatin,deburrLetter).replace(reComboMark,'');}/** + * Checks if `string` ends with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=string.length] The position to search up to. + * @returns {boolean} Returns `true` if `string` ends with `target`, + * else `false`. + * @example + * + * _.endsWith('abc', 'c'); + * // => true + * + * _.endsWith('abc', 'b'); + * // => false + * + * _.endsWith('abc', 'b', 2); + * // => true + */function endsWith(string,target,position){string=toString(string);target=baseToString(target);var length=string.length;position=position===undefined$1?length:baseClamp(toInteger(position),0,length);var end=position;position-=target.length;return position>=0&&string.slice(position,end)==target;}/** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. + * + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */function escape(string){string=toString(string);return string&&reHasUnescapedHtml.test(string)?string.replace(reUnescapedHtml,escapeHtmlChar):string;}/** + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]\(https://lodash\.com/\)' + */function escapeRegExp(string){string=toString(string);return string&&reHasRegExpChar.test(string)?string.replace(reRegExpChar,'\\$&'):string;}/** + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. + * @example + * + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' + * + * _.kebabCase('fooBar'); + * // => 'foo-bar' + * + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' + */var kebabCase=createCompounder(function(result,word,index){return result+(index?'-':'')+word.toLowerCase();});/** + * Converts `string`, as space separated words, to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' + * + * _.lowerCase('fooBar'); + * // => 'foo bar' + * + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' + */var lowerCase=createCompounder(function(result,word,index){return result+(index?' ':'')+word.toLowerCase();});/** + * Converts the first character of `string` to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' + */var lowerFirst=createCaseFirst('toLowerCase');/** + * Pads `string` on the left and right sides if it's shorter than `length`. + * Padding characters are truncated if they can't be evenly divided by `length`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.pad('abc', 8); + * // => ' abc ' + * + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' + * + * _.pad('abc', 3); + * // => 'abc' + */function pad(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;if(!length||strLength>=length){return string;}var mid=(length-strLength)/2;return createPadding(nativeFloor(mid),chars)+string+createPadding(nativeCeil(mid),chars);}/** + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.padEnd('abc', 6); + * // => 'abc ' + * + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' + */function padEnd(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' + */function padStart(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength 8 + * + * _.map(['6', '08', '10'], _.parseInt); + * // => [6, 8, 10] + */function parseInt(string,radix,guard){if(guard||radix==null){radix=0;}else if(radix){radix=+radix;}return nativeParseInt(toString(string).replace(reTrimStart,''),radix||0);}/** + * Repeats the given string `n` times. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to repeat. + * @param {number} [n=1] The number of times to repeat the string. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {string} Returns the repeated string. + * @example + * + * _.repeat('*', 3); + * // => '***' + * + * _.repeat('abc', 2); + * // => 'abcabc' + * + * _.repeat('abc', 0); + * // => '' + */function repeat(string,n,guard){if(guard?isIterateeCall(string,n,guard):n===undefined$1){n=1;}else {n=toInteger(n);}return baseRepeat(toString(string),n);}/** + * Replaces matches for `pattern` in `string` with `replacement`. + * + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to modify. + * @param {RegExp|string} pattern The pattern to replace. + * @param {Function|string} replacement The match replacement. + * @returns {string} Returns the modified string. + * @example + * + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' + */function replace(){var args=arguments,string=toString(args[0]);return args.length<3?string:string.replace(args[1],args[2]);}/** + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. + * @example + * + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' + * + * _.snakeCase('fooBar'); + * // => 'foo_bar' + * + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */var snakeCase=createCompounder(function(result,word,index){return result+(index?'_':'')+word.toLowerCase();});/** + * Splits `string` by `separator`. + * + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to split. + * @param {RegExp|string} separator The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * @example + * + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] + */function split(string,separator,limit){if(limit&&typeof limit!='number'&&isIterateeCall(string,separator,limit)){separator=limit=undefined$1;}limit=limit===undefined$1?MAX_ARRAY_LENGTH:limit>>>0;if(!limit){return [];}string=toString(string);if(string&&(typeof separator=='string'||separator!=null&&!isRegExp(separator))){separator=baseToString(separator);if(!separator&&hasUnicode(string)){return castSlice(stringToArray(string),0,limit);}}return string.split(separator,limit);}/** + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). + * + * @static + * @memberOf _ + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. + * @example + * + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' + * + * _.startCase('fooBar'); + * // => 'Foo Bar' + * + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' + */var startCase=createCompounder(function(result,word,index){return result+(index?' ':'')+upperFirst(word);});/** + * Checks if `string` starts with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=0] The position to search from. + * @returns {boolean} Returns `true` if `string` starts with `target`, + * else `false`. + * @example + * + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => true + */function startsWith(string,target,position){string=toString(string);position=position==null?0:baseClamp(toInteger(position),0,string.length);target=baseToString(target);return string.slice(position,position+target.length)==target;}/** + * Creates a compiled template function that can interpolate data properties + * in "interpolate" delimiters, HTML-escape interpolated data properties in + * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data + * properties may be accessed as free variables in the template. If a setting + * object is given, it takes precedence over `_.templateSettings` values. + * + * **Note:** In the development build `_.template` utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * for easier debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The template string. + * @param {Object} [options={}] The options object. + * @param {RegExp} [options.escape=_.templateSettings.escape] + * The HTML "escape" delimiter. + * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] + * The "evaluate" delimiter. + * @param {Object} [options.imports=_.templateSettings.imports] + * An object to import into the template as free variables. + * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] + * The "interpolate" delimiter. + * @param {string} [options.sourceURL='lodash.templateSources[n]'] + * The sourceURL of the compiled template. + * @param {string} [options.variable='obj'] + * The data object variable name. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the compiled template function. + * @example + * + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' + * + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': '