/** * Flatland.js * -------------------------------------------------- * This sketch is constantly evolving as a sandbox for Flatland.js * -------------------------------------------------- * https://twitter.com/pixelmoar * https://instagram.com/pixel.moar * -------------------------------------------------- * Devlog: https://pixelmoar.com/ * -------------------------------------------------- * License: Apache 2.0 with additional clause that you cannot mint NFTs without explicit permission */ function preload () { /** * 👇👇👇👇👇👇👇👇👇👇👇 * 👇👇👇 SETTINGS 👇👇👇 * 👇👇👇👇👇👇👇👇👇👇👇 * -------------------------------------------------- * These can aslo be configured through ?queryString params */ params = Object.assign({ // Number of frames per eyeblink fps: 15, minColumns: 1, maxColumns: 10, margin: 0.2 }, getURLParams()) } /** * Sketch entry point */ function setup() { colorMode(HSL, 360, 100, 100, 1) params.fps && frameRate(params.fps) size = min(windowWidth, windowHeight) createCanvas(size, size) _renderer.position(windowWidth / 2 - width / 2, windowHeight / 2 - height / 2, 'fixed') noiseOverlay = createGraphics(size, size) // Center the mouse so that the eyes start out centered mouseX = width / 2 mouseY = height / 2 createFlatland() document.body.style.background = Flatland.lands[0].residents[0].pupilColor } /** * Main draw loop */ function draw () { // Just call the draw method, Flatland.js will handle animations based on parameters ✨ Flatland.lands.forEach((flatland, i) => { flatland.draw(canvas => { canvas.background(color(flatland.bgColors[flatland.bg])) canvas.image(noiseOverlay, 0, 0) switch (i) { // Title case 1: canvas.noStroke() canvas.fill('#fff') canvas.textAlign(CENTER, CENTER) canvas.textSize(height / 40) canvas.text('waking up in', flatland.x, flatland.height / 4) canvas.textSize(height / 20) canvas.text('FLATLAND', flatland.x, 2 * flatland.height / 3) canvas.image(noiseOverlay, 0, 0) canvas.image(noiseOverlay, 0, 0) canvas.image(noiseOverlay, 0, 0) break // Rainbow case 6: const resident = flatland.residents[0] flatland.config.stripes.forEach(stripe => { resident.drawWhites(1, 1, stripe) stripe.size += 20 }) // Recycle the stripes flatland.config.stripes.forEach(stripe => { if (stripe.size > resident.size + flatland.config.maxScale * flatland.config.rainbowSpacing) { stripe.size = resident.size flatland.config.stripes.push(flatland.config.stripes.shift()) } }) canvas.image(noiseOverlay, 0, 0) break } }) }) } /** * Create a random set of eyes */ function createFlatland () { // Reset and recreate Flatland.dispose() // 0: Top left new Flatland({ bg: 4, width: ceil(width / 4), height: ceil(height / 8), onCreate: land => { land.addResident(land.width / 2, land.height / 2, land.height - land.height / 5, { body: 'heart', eyelidTop: 0, eyelidBottom: 0, bg: { color: 0, fill: true } }) } }) // 1: title new Flatland({ bg: 6, width: ceil(width / 2), height: ceil(height / 8), x: ceil(width / 4), }) // 2: top right new Flatland({ bg: 5, width: ceil(width / 4), height: ceil(height / 8), x: ceil(width / 4 + width / 2), onCreate: land => { land.addResident(land.width / 2, land.height / 2, land.height - land.height / 2.5, { body: 'star', eyelidTop: 0, eyelidBottom: 0, bg: { color: 1, fill: true } }) } }) // 3: Second row new Flatland({ bg: 0, width, height: ceil(height / 4), y: ceil(height / 8), onCreate: land => { packFlatlanders(land, 12, .2) } }) // Third row // 4: Big area new Flatland({ bg: 5, width: ceil(width / 4 + width / 2), height: ceil(height / 2), y: ceil(height / 8 + height / 4), onCreate: land => { packFlatlanders(land, 2, .2, { color: 1, // Anxious eyes are open top, relaxed bottoms eyelidTop: 1, eyelidBottom: random(.25, .55), maxLookWait: 15, angle: .15, pupilSize: random(.1, .5) }) land.residents[1].cloned = land.residents[0] land.residents[0].pupilScale = random(.5, .8) land.residents[1].angle *= -1 land.residents[1].params.angle = land.residents[1].angle } }) // 5: Top right new Flatland({ bg: 2, width: ceil(width / 4), height: ceil(height / 4), x: ceil(width / 4 + width / 2), y: ceil(height / 8 + height / 4), onCreate: land => { packFlatlanders(land, 2, .2, { color: 5, pupilSize: random(.3, .6), eyelashes: {type: 'chief'} }) } }) // 6: Bottom right new Flatland({ bg: 6, width: ceil(width / 4), height: ceil(height / 4), x: ceil(width / 4 + width / 2), y: ceil(height / 8 + height / 2), onCreate: land => { let size = min(land.height, land.width) * .8 const resident = land.addResident(land.width / 2, land.height / 2, size, { eyelidTop: random(0.45, .8), eyelidBottom: random(0.45, .8), pupilSize: .9 }) // Rainbow stripes land.config = { rainbowSpacing: land.height / 4, stripes: [], maxScale: 0 } let scale = 0 for (let j = 0; j < max(width / resident.size * 3, height / resident.size * 3); j++) { for (let i = 0; i < land.colors.length; i++) { land.config.stripes.push({ canvas: land.canvas, colorMode: [HSL, 360, 100, 100, 1], size: resident.size + scale * land.config.rainbowSpacing, fill: land.colors[i], x: resident.x, y: resident.y }) scale++ } } land.config.maxScale = scale land.config.stripes = land.config.stripes.reverse() } }) // Bottom row new Flatland({ bg: 2, width, height: ceil(height / 8), y: height - ceil(height / 8), onCreate: land => { packFlatlanders(land, 8, .25, { body: 'random', possibleBodyTypes: ['triangle', 'rect', 'pentagon', 'star', 'heart'], bg: { fill: true } }) } }) // Noise overlay noiseOverlay.clear() noiseOverlay.colorMode(RGB) noiseOverlay.noStroke() noiseOverlay.fill(0, 0, 0, 15) let noiseScale = 2 for (let n = 0; n < 1; n++) { for (let x = 0; x < width / noiseScale; x++) { for (let y = 0; y < height / noiseScale; y++) { random() > .85 && noiseOverlay.rect(x * noiseScale, y * noiseScale, noiseScale, noiseScale) } } } } /** * Responsively fill a Flatland with residents given a column count * @param {*} flatland * @param {*} columns */ function packFlatlanders (flatland, columns, margin = 0.2, residentParams) { // Calculate a perfectly responsive set of columns/rows, so none stick out of the page let size = flatland.width / (columns + columns * margin) if (size > flatland.height) { size = flatland.height / (columns + columns * margin) } let rows = max(1, floor(flatland.height / size)) let offX = flatland.width - columns * size let offY = flatland.height - rows * size let extraWidth = max(0, flatland.width - (size / 2 + columns * size)) let extraMarginX = extraWidth / columns let extraHeight = max(0, flatland.height - (size / 2 + rows * size)) let extraMarginY = extraHeight / rows // Create the residents 👁 for (let x = 0; x < columns; x++) { for (let y = 0; y < rows; y++) { params = _.cloneDeep(residentParams) // (x, y, size, params) flatland.addResident( size / 2 + x * size + offX / 2 - extraWidth / 2 + extraMarginX * x, size / 2 + y * size + offY / 2 - extraHeight / 2 + extraMarginY * y, size - size * margin, params ) } } } /** * Tap with two fingers to recreate sketch */ function touchStarted () { if (touches.length > 1) { keyPressed() } } /** * Handle keypressed across multiple files */ function windowResized () { let size = min(windowWidth, windowHeight) resizeCanvas(size, size) noiseOverlay.resizeCanvas(size, size) _renderer.position(windowWidth / 2 - width / 2, windowHeight / 2 - height / 2, 'fixed') noiseOverlay.resizeCanvas(windowWidth, windowHeight) mouseX = width / 2 mouseY = height / 2 createFlatland() } /** * Handle keypressed across multiple files */ function keyPressed () { if (keyCode === 17) { _renderer.position(windowWidth / 2 - width / 2, windowHeight / 2 - height / 2, 'fixed') mouseX = width / 2 mouseY = height / 2 createFlatland() } } /** * Flatland.js 🔺🟩🔵👀 * A p5.js library for creating powerfully emotive generative stories & animations * using simple eyes and shapes with the least amount of code * --- * Built with passion and love by @pixelmoar * --- * https://pixelmoar.com * https://twitter.com/pixelmoar * https://instagram.com/pixel.moar * --- * @version 0.0.1 * @license "Apache 2.0" with the addendum that you cannot use this or its output for NFTs without permission * --- * This file was bundled with Rollup. See https://github.com/pixelmoar/flatland.js for the goods */ ;(function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Flatland = factory()); }(this, (function () { 'use strict'; /*! Tweakpane 3.0.5 (c) 2016 cocopon, licensed under the MIT license. */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Tweakpane = {})); }(window, (function (exports) { /*** * A simple semantic versioning perser. */ class Semver { /** * @hidden */ constructor(text) { const [core, prerelease] = text.split('-'); const coreComps = core.split('.'); this.major = parseInt(coreComps[0], 10); this.minor = parseInt(coreComps[1], 10); this.patch = parseInt(coreComps[2], 10); this.prerelease = prerelease !== null && prerelease !== void 0 ? prerelease : null; } toString() { const core = [this.major, this.minor, this.patch].join('.'); return this.prerelease !== null ? [core, this.prerelease].join('-') : core; } } class BladeApi { constructor(controller) { this.controller_ = controller; } get disabled() { return this.controller_.viewProps.get('disabled'); } set disabled(disabled) { this.controller_.viewProps.set('disabled', disabled); } get hidden() { return this.controller_.viewProps.get('hidden'); } set hidden(hidden) { this.controller_.viewProps.set('hidden', hidden); } dispose() { this.controller_.viewProps.set('disposed', true); } } class TpEvent { constructor(target) { this.target = target; } } class TpChangeEvent extends TpEvent { constructor(target, value, presetKey, last) { super(target); this.value = value; this.presetKey = presetKey; this.last = last !== null && last !== void 0 ? last : true; } } class TpUpdateEvent extends TpEvent { constructor(target, value, presetKey) { super(target); this.value = value; this.presetKey = presetKey; } } class TpFoldEvent extends TpEvent { constructor(target, expanded) { super(target); this.expanded = expanded; } } function forceCast(v) { return v; } function isEmpty(value) { return value === null || value === undefined; } function deepEqualsArray(a1, a2) { if (a1.length !== a2.length) { return false; } for (let i = 0; i < a1.length; i++) { if (a1[i] !== a2[i]) { return false; } } return true; } const CREATE_MESSAGE_MAP = { alreadydisposed: () => 'View has been already disposed', invalidparams: (context) => `Invalid parameters for '${context.name}'`, nomatchingcontroller: (context) => `No matching controller for '${context.key}'`, nomatchingview: (context) => `No matching view for '${JSON.stringify(context.params)}'`, notbindable: () => `Value is not bindable`, propertynotfound: (context) => `Property '${context.name}' not found`, shouldneverhappen: () => 'This error should never happen', }; class TpError { constructor(config) { var _a; this.message = (_a = CREATE_MESSAGE_MAP[config.type](forceCast(config.context))) !== null && _a !== void 0 ? _a : 'Unexpected error'; this.name = this.constructor.name; this.stack = new Error(this.message).stack; this.type = config.type; } static alreadyDisposed() { return new TpError({ type: 'alreadydisposed' }); } static notBindable() { return new TpError({ type: 'notbindable', }); } static propertyNotFound(name) { return new TpError({ type: 'propertynotfound', context: { name: name, }, }); } static shouldNeverHappen() { return new TpError({ type: 'shouldneverhappen' }); } } class BindingTarget { constructor(obj, key, opt_id) { this.obj_ = obj; this.key_ = key; this.presetKey_ = opt_id !== null && opt_id !== void 0 ? opt_id : key; } static isBindable(obj) { if (obj === null) { return false; } if (typeof obj !== 'object') { return false; } return true; } get key() { return this.key_; } get presetKey() { return this.presetKey_; } read() { return this.obj_[this.key_]; } write(value) { this.obj_[this.key_] = value; } writeProperty(name, value) { const valueObj = this.read(); if (!BindingTarget.isBindable(valueObj)) { throw TpError.notBindable(); } if (!(name in valueObj)) { throw TpError.propertyNotFound(name); } valueObj[name] = value; } } class ButtonApi extends BladeApi { get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } get title() { var _a; return (_a = this.controller_.valueController.props.get('title')) !== null && _a !== void 0 ? _a : ''; } set title(title) { this.controller_.valueController.props.set('title', title); } on(eventName, handler) { const bh = handler.bind(this); const emitter = this.controller_.valueController.emitter; emitter.on(eventName, () => { bh(new TpEvent(this)); }); return this; } } class Emitter { constructor() { this.observers_ = {}; } on(eventName, handler) { let observers = this.observers_[eventName]; if (!observers) { observers = this.observers_[eventName] = []; } observers.push({ handler: handler, }); return this; } off(eventName, handler) { const observers = this.observers_[eventName]; if (observers) { this.observers_[eventName] = observers.filter((observer) => { return observer.handler !== handler; }); } return this; } emit(eventName, event) { const observers = this.observers_[eventName]; if (!observers) { return; } observers.forEach((observer) => { observer.handler(event); }); } } const PREFIX = 'tp'; function ClassName(viewName) { const fn = (opt_elementName, opt_modifier) => { return [ PREFIX, '-', viewName, 'v', opt_elementName ? `_${opt_elementName}` : '', opt_modifier ? `-${opt_modifier}` : '', ].join(''); }; return fn; } function compose(h1, h2) { return (input) => h2(h1(input)); } function extractValue(ev) { return ev.rawValue; } function bindValue(value, applyValue) { value.emitter.on('change', compose(extractValue, applyValue)); applyValue(value.rawValue); } function bindValueMap(valueMap, key, applyValue) { bindValue(valueMap.value(key), applyValue); } function applyClass(elem, className, active) { if (active) { elem.classList.add(className); } else { elem.classList.remove(className); } } function valueToClassName(elem, className) { return (value) => { applyClass(elem, className, value); }; } function bindValueToTextContent(value, elem) { bindValue(value, (text) => { elem.textContent = text !== null && text !== void 0 ? text : ''; }); } const className$q = ClassName('btn'); class ButtonView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$q()); config.viewProps.bindClassModifiers(this.element); const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$q('b')); config.viewProps.bindDisabled(buttonElem); this.element.appendChild(buttonElem); this.buttonElement = buttonElem; const titleElem = doc.createElement('div'); titleElem.classList.add(className$q('t')); bindValueToTextContent(config.props.value('title'), titleElem); this.buttonElement.appendChild(titleElem); } } class ButtonController { constructor(doc, config) { this.emitter = new Emitter(); this.onClick_ = this.onClick_.bind(this); this.props = config.props; this.viewProps = config.viewProps; this.view = new ButtonView(doc, { props: this.props, viewProps: this.viewProps, }); this.view.buttonElement.addEventListener('click', this.onClick_); } onClick_() { this.emitter.emit('click', { sender: this, }); } } class BoundValue { constructor(initialValue, config) { var _a; this.constraint_ = config === null || config === void 0 ? void 0 : config.constraint; this.equals_ = (_a = config === null || config === void 0 ? void 0 : config.equals) !== null && _a !== void 0 ? _a : ((v1, v2) => v1 === v2); this.emitter = new Emitter(); this.rawValue_ = initialValue; } get constraint() { return this.constraint_; } get rawValue() { return this.rawValue_; } set rawValue(rawValue) { this.setRawValue(rawValue, { forceEmit: false, last: true, }); } setRawValue(rawValue, options) { const opts = options !== null && options !== void 0 ? options : { forceEmit: false, last: true, }; const constrainedValue = this.constraint_ ? this.constraint_.constrain(rawValue) : rawValue; const changed = !this.equals_(this.rawValue_, constrainedValue); if (!changed && !opts.forceEmit) { return; } this.emitter.emit('beforechange', { sender: this, }); this.rawValue_ = constrainedValue; this.emitter.emit('change', { options: opts, rawValue: constrainedValue, sender: this, }); } } class PrimitiveValue { constructor(initialValue) { this.emitter = new Emitter(); this.value_ = initialValue; } get rawValue() { return this.value_; } set rawValue(value) { this.setRawValue(value, { forceEmit: false, last: true, }); } setRawValue(value, options) { const opts = options !== null && options !== void 0 ? options : { forceEmit: false, last: true, }; if (this.value_ === value && !opts.forceEmit) { return; } this.emitter.emit('beforechange', { sender: this, }); this.value_ = value; this.emitter.emit('change', { options: opts, rawValue: this.value_, sender: this, }); } } function createValue(initialValue, config) { const constraint = config === null || config === void 0 ? void 0 : config.constraint; const equals = config === null || config === void 0 ? void 0 : config.equals; if (!constraint && !equals) { return new PrimitiveValue(initialValue); } return new BoundValue(initialValue, config); } class ValueMap { constructor(valueMap) { this.emitter = new Emitter(); this.valMap_ = valueMap; for (const key in this.valMap_) { const v = this.valMap_[key]; v.emitter.on('change', () => { this.emitter.emit('change', { key: key, sender: this, }); }); } } static createCore(initialValue) { const keys = Object.keys(initialValue); return keys.reduce((o, key) => { return Object.assign(o, { [key]: createValue(initialValue[key]), }); }, {}); } static fromObject(initialValue) { const core = this.createCore(initialValue); return new ValueMap(core); } get(key) { return this.valMap_[key].rawValue; } set(key, value) { this.valMap_[key].rawValue = value; } value(key) { return this.valMap_[key]; } } function parseObject(value, keyToParserMap) { const keys = Object.keys(keyToParserMap); const result = keys.reduce((tmp, key) => { if (tmp === undefined) { return undefined; } const parser = keyToParserMap[key]; const result = parser(value[key]); return result.succeeded ? Object.assign(Object.assign({}, tmp), { [key]: result.value }) : undefined; }, {}); return forceCast(result); } function parseArray(value, parseItem) { return value.reduce((tmp, item) => { if (tmp === undefined) { return undefined; } const result = parseItem(item); if (!result.succeeded || result.value === undefined) { return undefined; } return [...tmp, result.value]; }, []); } function isObject(value) { if (value === null) { return false; } return typeof value === 'object'; } function createParamsParserBuilder(parse) { return (optional) => (v) => { if (!optional && v === undefined) { return { succeeded: false, value: undefined, }; } if (optional && v === undefined) { return { succeeded: true, value: undefined, }; } const result = parse(v); return result !== undefined ? { succeeded: true, value: result, } : { succeeded: false, value: undefined, }; }; } function createParamsParserBuilders(optional) { return { custom: (parse) => createParamsParserBuilder(parse)(optional), boolean: createParamsParserBuilder((v) => typeof v === 'boolean' ? v : undefined)(optional), number: createParamsParserBuilder((v) => typeof v === 'number' ? v : undefined)(optional), string: createParamsParserBuilder((v) => typeof v === 'string' ? v : undefined)(optional), function: createParamsParserBuilder((v) => typeof v === 'function' ? v : undefined)(optional), constant: (value) => createParamsParserBuilder((v) => (v === value ? value : undefined))(optional), raw: createParamsParserBuilder((v) => v)(optional), object: (keyToParserMap) => createParamsParserBuilder((v) => { if (!isObject(v)) { return undefined; } return parseObject(v, keyToParserMap); })(optional), array: (itemParser) => createParamsParserBuilder((v) => { if (!Array.isArray(v)) { return undefined; } return parseArray(v, itemParser); })(optional), }; } const ParamsParsers = { optional: createParamsParserBuilders(true), required: createParamsParserBuilders(false), }; function parseParams(value, keyToParserMap) { const result = ParamsParsers.required.object(keyToParserMap)(value); return result.succeeded ? result.value : undefined; } function disposeElement(elem) { if (elem && elem.parentElement) { elem.parentElement.removeChild(elem); } return null; } function getAllBladePositions() { return ['veryfirst', 'first', 'last', 'verylast']; } const className$p = ClassName(''); const POS_TO_CLASS_NAME_MAP = { veryfirst: 'vfst', first: 'fst', last: 'lst', verylast: 'vlst', }; class BladeController { constructor(config) { this.parent_ = null; this.blade = config.blade; this.view = config.view; this.viewProps = config.viewProps; const elem = this.view.element; this.blade.value('positions').emitter.on('change', () => { getAllBladePositions().forEach((pos) => { elem.classList.remove(className$p(undefined, POS_TO_CLASS_NAME_MAP[pos])); }); this.blade.get('positions').forEach((pos) => { elem.classList.add(className$p(undefined, POS_TO_CLASS_NAME_MAP[pos])); }); }); this.viewProps.handleDispose(() => { disposeElement(elem); }); } get parent() { return this.parent_; } } const SVG_NS = 'http://www.w3.org/2000/svg'; function forceReflow(element) { element.offsetHeight; } function disableTransitionTemporarily(element, callback) { const t = element.style.transition; element.style.transition = 'none'; callback(); element.style.transition = t; } function supportsTouch(doc) { return doc.ontouchstart !== undefined; } function getGlobalObject() { return new Function('return this')(); } function getWindowDocument() { const globalObj = forceCast(getGlobalObject()); return globalObj.document; } function isBrowser() { return 'document' in getGlobalObject(); } function getCanvasContext(canvasElement) { return isBrowser() ? canvasElement.getContext('2d') : null; } const ICON_ID_TO_INNER_HTML_MAP = { check: '', dropdown: '', p2dpad: '', }; function createSvgIconElement(document, iconId) { const elem = document.createElementNS(SVG_NS, 'svg'); elem.innerHTML = ICON_ID_TO_INNER_HTML_MAP[iconId]; return elem; } function insertElementAt(parentElement, element, index) { parentElement.insertBefore(element, parentElement.children[index]); } function removeElement(element) { if (element.parentElement) { element.parentElement.removeChild(element); } } function removeChildElements(element) { while (element.children.length > 0) { element.removeChild(element.children[0]); } } function removeChildNodes(element) { while (element.childNodes.length > 0) { element.removeChild(element.childNodes[0]); } } function findNextTarget(ev) { if (ev.relatedTarget) { return forceCast(ev.relatedTarget); } if ('explicitOriginalTarget' in ev) { return ev.explicitOriginalTarget; } return null; } const className$o = ClassName('lbl'); function createLabelNode(doc, label) { const frag = doc.createDocumentFragment(); const lineNodes = label.split('\n').map((line) => { return doc.createTextNode(line); }); lineNodes.forEach((lineNode, index) => { if (index > 0) { frag.appendChild(doc.createElement('br')); } frag.appendChild(lineNode); }); return frag; } class LabelView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$o()); config.viewProps.bindClassModifiers(this.element); const labelElem = doc.createElement('div'); labelElem.classList.add(className$o('l')); bindValueMap(config.props, 'label', (value) => { if (isEmpty(value)) { this.element.classList.add(className$o(undefined, 'nol')); } else { this.element.classList.remove(className$o(undefined, 'nol')); removeChildNodes(labelElem); labelElem.appendChild(createLabelNode(doc, value)); } }); this.element.appendChild(labelElem); this.labelElement = labelElem; const valueElem = doc.createElement('div'); valueElem.classList.add(className$o('v')); this.element.appendChild(valueElem); this.valueElement = valueElem; } } class LabelController extends BladeController { constructor(doc, config) { const viewProps = config.valueController.viewProps; super(Object.assign(Object.assign({}, config), { view: new LabelView(doc, { props: config.props, viewProps: viewProps, }), viewProps: viewProps })); this.props = config.props; this.valueController = config.valueController; this.view.valueElement.appendChild(this.valueController.view.element); } } const ButtonBladePlugin = { id: 'button', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { title: p.required.string, view: p.required.constant('button'), label: p.optional.string, }); return result ? { params: result } : null; }, controller(args) { return new LabelController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: new ButtonController(args.document, { props: ValueMap.fromObject({ title: args.params.title, }), viewProps: args.viewProps, }), }); }, api(args) { if (!(args.controller instanceof LabelController)) { return null; } if (!(args.controller.valueController instanceof ButtonController)) { return null; } return new ButtonApi(args.controller); }, }; class ValueBladeController extends BladeController { constructor(config) { super(config); this.value = config.value; } } function createBlade() { return new ValueMap({ positions: createValue([], { equals: deepEqualsArray, }), }); } class Foldable extends ValueMap { constructor(valueMap) { super(valueMap); } static create(expanded) { const coreObj = { completed: true, expanded: expanded, expandedHeight: null, shouldFixHeight: false, temporaryExpanded: null, }; const core = ValueMap.createCore(coreObj); return new Foldable(core); } get styleExpanded() { var _a; return (_a = this.get('temporaryExpanded')) !== null && _a !== void 0 ? _a : this.get('expanded'); } get styleHeight() { if (!this.styleExpanded) { return '0'; } const exHeight = this.get('expandedHeight'); if (this.get('shouldFixHeight') && !isEmpty(exHeight)) { return `${exHeight}px`; } return 'auto'; } bindExpandedClass(elem, expandedClassName) { bindValueMap(this, 'expanded', () => { const expanded = this.styleExpanded; if (expanded) { elem.classList.add(expandedClassName); } else { elem.classList.remove(expandedClassName); } }); } } function computeExpandedFolderHeight(folder, containerElement) { let height = 0; disableTransitionTemporarily(containerElement, () => { folder.set('expandedHeight', null); folder.set('temporaryExpanded', true); forceReflow(containerElement); height = containerElement.clientHeight; folder.set('temporaryExpanded', null); forceReflow(containerElement); }); return height; } function applyHeight(foldable, elem) { elem.style.height = foldable.styleHeight; } function bindFoldable(foldable, elem) { foldable.value('expanded').emitter.on('beforechange', () => { foldable.set('completed', false); if (isEmpty(foldable.get('expandedHeight'))) { foldable.set('expandedHeight', computeExpandedFolderHeight(foldable, elem)); } foldable.set('shouldFixHeight', true); forceReflow(elem); }); foldable.emitter.on('change', () => { applyHeight(foldable, elem); }); applyHeight(foldable, elem); elem.addEventListener('transitionend', (ev) => { if (ev.propertyName !== 'height') { return; } foldable.set('shouldFixHeight', false); foldable.set('expandedHeight', null); foldable.set('completed', true); }); } class RackLikeApi extends BladeApi { constructor(controller, rackApi) { super(controller); this.rackApi_ = rackApi; } } function addButtonAsBlade(api, params) { return api.addBlade(Object.assign(Object.assign({}, params), { view: 'button' })); } function addFolderAsBlade(api, params) { return api.addBlade(Object.assign(Object.assign({}, params), { view: 'folder' })); } function addSeparatorAsBlade(api, opt_params) { const params = opt_params || {}; return api.addBlade(Object.assign(Object.assign({}, params), { view: 'separator' })); } function addTabAsBlade(api, params) { return api.addBlade(Object.assign(Object.assign({}, params), { view: 'tab' })); } class NestedOrderedSet { constructor(extract) { this.emitter = new Emitter(); this.items_ = []; this.cache_ = new Set(); this.onSubListAdd_ = this.onSubListAdd_.bind(this); this.onSubListRemove_ = this.onSubListRemove_.bind(this); this.extract_ = extract; } get items() { return this.items_; } allItems() { return Array.from(this.cache_); } find(callback) { for (const item of this.allItems()) { if (callback(item)) { return item; } } return null; } includes(item) { return this.cache_.has(item); } add(item, opt_index) { if (this.includes(item)) { throw TpError.shouldNeverHappen(); } const index = opt_index !== undefined ? opt_index : this.items_.length; this.items_.splice(index, 0, item); this.cache_.add(item); const subList = this.extract_(item); if (subList) { subList.emitter.on('add', this.onSubListAdd_); subList.emitter.on('remove', this.onSubListRemove_); subList.allItems().forEach((item) => { this.cache_.add(item); }); } this.emitter.emit('add', { index: index, item: item, root: this, target: this, }); } remove(item) { const index = this.items_.indexOf(item); if (index < 0) { return; } this.items_.splice(index, 1); this.cache_.delete(item); const subList = this.extract_(item); if (subList) { subList.emitter.off('add', this.onSubListAdd_); subList.emitter.off('remove', this.onSubListRemove_); } this.emitter.emit('remove', { index: index, item: item, root: this, target: this, }); } onSubListAdd_(ev) { this.cache_.add(ev.item); this.emitter.emit('add', { index: ev.index, item: ev.item, root: this, target: ev.target, }); } onSubListRemove_(ev) { this.cache_.delete(ev.item); this.emitter.emit('remove', { index: ev.index, item: ev.item, root: this, target: ev.target, }); } } class InputBindingApi extends BladeApi { constructor(controller) { super(controller); this.onBindingChange_ = this.onBindingChange_.bind(this); this.emitter_ = new Emitter(); this.controller_.binding.emitter.on('change', this.onBindingChange_); } get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } refresh() { this.controller_.binding.read(); } onBindingChange_(ev) { const value = ev.sender.target.read(); this.emitter_.emit('change', { event: new TpChangeEvent(this, forceCast(value), this.controller_.binding.target.presetKey, ev.options.last), }); } } class InputBindingController extends LabelController { constructor(doc, config) { super(doc, config); this.binding = config.binding; } } class MonitorBindingApi extends BladeApi { constructor(controller) { super(controller); this.onBindingUpdate_ = this.onBindingUpdate_.bind(this); this.emitter_ = new Emitter(); this.controller_.binding.emitter.on('update', this.onBindingUpdate_); } get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } refresh() { this.controller_.binding.read(); } onBindingUpdate_(ev) { const value = ev.sender.target.read(); this.emitter_.emit('update', { event: new TpUpdateEvent(this, forceCast(value), this.controller_.binding.target.presetKey), }); } } class MonitorBindingController extends LabelController { constructor(doc, config) { super(doc, config); this.binding = config.binding; this.viewProps.bindDisabled(this.binding.ticker); this.viewProps.handleDispose(() => { this.binding.dispose(); }); } } function findSubBladeApiSet(api) { if (api instanceof RackApi) { return api['apiSet_']; } if (api instanceof RackLikeApi) { return api['rackApi_']['apiSet_']; } return null; } function getApiByController(apiSet, controller) { const api = apiSet.find((api) => api.controller_ === controller); if (!api) { throw TpError.shouldNeverHappen(); } return api; } function createBindingTarget(obj, key, opt_id) { if (!BindingTarget.isBindable(obj)) { throw TpError.notBindable(); } return new BindingTarget(obj, key, opt_id); } class RackApi extends BladeApi { constructor(controller, pool) { super(controller); this.onRackAdd_ = this.onRackAdd_.bind(this); this.onRackRemove_ = this.onRackRemove_.bind(this); this.onRackInputChange_ = this.onRackInputChange_.bind(this); this.onRackMonitorUpdate_ = this.onRackMonitorUpdate_.bind(this); this.emitter_ = new Emitter(); this.apiSet_ = new NestedOrderedSet(findSubBladeApiSet); this.pool_ = pool; const rack = this.controller_.rack; rack.emitter.on('add', this.onRackAdd_); rack.emitter.on('remove', this.onRackRemove_); rack.emitter.on('inputchange', this.onRackInputChange_); rack.emitter.on('monitorupdate', this.onRackMonitorUpdate_); rack.children.forEach((bc) => { this.setUpApi_(bc); }); } get children() { return this.controller_.rack.children.map((bc) => getApiByController(this.apiSet_, bc)); } addInput(object, key, opt_params) { const params = opt_params || {}; const doc = this.controller_.view.element.ownerDocument; const bc = this.pool_.createInput(doc, createBindingTarget(object, key, params.presetKey), params); const api = new InputBindingApi(bc); return this.add(api, params.index); } addMonitor(object, key, opt_params) { const params = opt_params || {}; const doc = this.controller_.view.element.ownerDocument; const bc = this.pool_.createMonitor(doc, createBindingTarget(object, key), params); const api = new MonitorBindingApi(bc); return forceCast(this.add(api, params.index)); } addFolder(params) { return addFolderAsBlade(this, params); } addButton(params) { return addButtonAsBlade(this, params); } addSeparator(opt_params) { return addSeparatorAsBlade(this, opt_params); } addTab(params) { return addTabAsBlade(this, params); } add(api, opt_index) { this.controller_.rack.add(api.controller_, opt_index); const gapi = this.apiSet_.find((a) => a.controller_ === api.controller_); if (gapi) { this.apiSet_.remove(gapi); } this.apiSet_.add(api); return api; } remove(api) { this.controller_.rack.remove(api.controller_); } addBlade(params) { const doc = this.controller_.view.element.ownerDocument; const bc = this.pool_.createBlade(doc, params); const api = this.pool_.createBladeApi(bc); return this.add(api, params.index); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } setUpApi_(bc) { const api = this.apiSet_.find((api) => api.controller_ === bc); if (!api) { this.apiSet_.add(this.pool_.createBladeApi(bc)); } } onRackAdd_(ev) { this.setUpApi_(ev.bladeController); } onRackRemove_(ev) { if (ev.isRoot) { const api = getApiByController(this.apiSet_, ev.bladeController); this.apiSet_.remove(api); } } onRackInputChange_(ev) { const bc = ev.bladeController; if (bc instanceof InputBindingController) { const api = getApiByController(this.apiSet_, bc); const binding = bc.binding; this.emitter_.emit('change', { event: new TpChangeEvent(api, forceCast(binding.target.read()), binding.target.presetKey, ev.options.last), }); } else if (bc instanceof ValueBladeController) { const api = getApiByController(this.apiSet_, bc); this.emitter_.emit('change', { event: new TpChangeEvent(api, bc.value.rawValue, undefined, ev.options.last), }); } } onRackMonitorUpdate_(ev) { if (!(ev.bladeController instanceof MonitorBindingController)) { throw TpError.shouldNeverHappen(); } const api = getApiByController(this.apiSet_, ev.bladeController); const binding = ev.bladeController.binding; this.emitter_.emit('update', { event: new TpUpdateEvent(api, forceCast(binding.target.read()), binding.target.presetKey), }); } } class FolderApi extends RackLikeApi { constructor(controller, pool) { super(controller, new RackApi(controller.rackController, pool)); this.emitter_ = new Emitter(); this.controller_.foldable .value('expanded') .emitter.on('change', (ev) => { this.emitter_.emit('fold', { event: new TpFoldEvent(this, ev.sender.rawValue), }); }); this.rackApi_.on('change', (ev) => { this.emitter_.emit('change', { event: ev, }); }); this.rackApi_.on('update', (ev) => { this.emitter_.emit('update', { event: ev, }); }); } get expanded() { return this.controller_.foldable.get('expanded'); } set expanded(expanded) { this.controller_.foldable.set('expanded', expanded); } get title() { return this.controller_.props.get('title'); } set title(title) { this.controller_.props.set('title', title); } get children() { return this.rackApi_.children; } addInput(object, key, opt_params) { return this.rackApi_.addInput(object, key, opt_params); } addMonitor(object, key, opt_params) { return this.rackApi_.addMonitor(object, key, opt_params); } addFolder(params) { return this.rackApi_.addFolder(params); } addButton(params) { return this.rackApi_.addButton(params); } addSeparator(opt_params) { return this.rackApi_.addSeparator(opt_params); } addTab(params) { return this.rackApi_.addTab(params); } add(api, opt_index) { return this.rackApi_.add(api, opt_index); } remove(api) { this.rackApi_.remove(api); } addBlade(params) { return this.rackApi_.addBlade(params); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } } class RackLikeController extends BladeController { constructor(config) { super({ blade: config.blade, view: config.view, viewProps: config.rackController.viewProps, }); this.rackController = config.rackController; } } class PlainView { constructor(doc, config) { const className = ClassName(config.viewName); this.element = doc.createElement('div'); this.element.classList.add(className()); config.viewProps.bindClassModifiers(this.element); } } function findInputBindingController(bcs, b) { for (let i = 0; i < bcs.length; i++) { const bc = bcs[i]; if (bc instanceof InputBindingController && bc.binding === b) { return bc; } } return null; } function findMonitorBindingController(bcs, b) { for (let i = 0; i < bcs.length; i++) { const bc = bcs[i]; if (bc instanceof MonitorBindingController && bc.binding === b) { return bc; } } return null; } function findValueBladeController(bcs, v) { for (let i = 0; i < bcs.length; i++) { const bc = bcs[i]; if (bc instanceof ValueBladeController && bc.value === v) { return bc; } } return null; } function findSubRack(bc) { if (bc instanceof RackController) { return bc.rack; } if (bc instanceof RackLikeController) { return bc.rackController.rack; } return null; } function findSubBladeControllerSet(bc) { const rack = findSubRack(bc); return rack ? rack['bcSet_'] : null; } class BladeRack { constructor(blade) { var _a; this.onBladePositionsChange_ = this.onBladePositionsChange_.bind(this); this.onSetAdd_ = this.onSetAdd_.bind(this); this.onSetRemove_ = this.onSetRemove_.bind(this); this.onChildDispose_ = this.onChildDispose_.bind(this); this.onChildPositionsChange_ = this.onChildPositionsChange_.bind(this); this.onChildInputChange_ = this.onChildInputChange_.bind(this); this.onChildMonitorUpdate_ = this.onChildMonitorUpdate_.bind(this); this.onChildValueChange_ = this.onChildValueChange_.bind(this); this.onChildViewPropsChange_ = this.onChildViewPropsChange_.bind(this); this.onDescendantLayout_ = this.onDescendantLayout_.bind(this); this.onDescendantInputChange_ = this.onDescendantInputChange_.bind(this); this.onDescendantMonitorUpdate_ = this.onDescendantMonitorUpdate_.bind(this); this.emitter = new Emitter(); this.blade_ = blade !== null && blade !== void 0 ? blade : null; (_a = this.blade_) === null || _a === void 0 ? void 0 : _a.value('positions').emitter.on('change', this.onBladePositionsChange_); this.bcSet_ = new NestedOrderedSet(findSubBladeControllerSet); this.bcSet_.emitter.on('add', this.onSetAdd_); this.bcSet_.emitter.on('remove', this.onSetRemove_); } get children() { return this.bcSet_.items; } add(bc, opt_index) { if (bc.parent) { bc.parent.remove(bc); } bc['parent_'] = this; this.bcSet_.add(bc, opt_index); } remove(bc) { bc['parent_'] = null; this.bcSet_.remove(bc); } find(controllerClass) { return forceCast(this.bcSet_.allItems().filter((bc) => { return bc instanceof controllerClass; })); } onSetAdd_(ev) { this.updatePositions_(); const isRoot = ev.target === ev.root; this.emitter.emit('add', { bladeController: ev.item, index: ev.index, isRoot: isRoot, sender: this, }); if (!isRoot) { return; } const bc = ev.item; bc.viewProps.emitter.on('change', this.onChildViewPropsChange_); bc.blade .value('positions') .emitter.on('change', this.onChildPositionsChange_); bc.viewProps.handleDispose(this.onChildDispose_); if (bc instanceof InputBindingController) { bc.binding.emitter.on('change', this.onChildInputChange_); } else if (bc instanceof MonitorBindingController) { bc.binding.emitter.on('update', this.onChildMonitorUpdate_); } else if (bc instanceof ValueBladeController) { bc.value.emitter.on('change', this.onChildValueChange_); } else { const rack = findSubRack(bc); if (rack) { const emitter = rack.emitter; emitter.on('layout', this.onDescendantLayout_); emitter.on('inputchange', this.onDescendantInputChange_); emitter.on('monitorupdate', this.onDescendantMonitorUpdate_); } } } onSetRemove_(ev) { this.updatePositions_(); const isRoot = ev.target === ev.root; this.emitter.emit('remove', { bladeController: ev.item, isRoot: isRoot, sender: this, }); if (!isRoot) { return; } const bc = ev.item; if (bc instanceof InputBindingController) { bc.binding.emitter.off('change', this.onChildInputChange_); } else if (bc instanceof MonitorBindingController) { bc.binding.emitter.off('update', this.onChildMonitorUpdate_); } else if (bc instanceof ValueBladeController) { bc.value.emitter.off('change', this.onChildValueChange_); } else { const rack = findSubRack(bc); if (rack) { const emitter = rack.emitter; emitter.off('layout', this.onDescendantLayout_); emitter.off('inputchange', this.onDescendantInputChange_); emitter.off('monitorupdate', this.onDescendantMonitorUpdate_); } } } updatePositions_() { const visibleItems = this.bcSet_.items.filter((bc) => !bc.viewProps.get('hidden')); const firstVisibleItem = visibleItems[0]; const lastVisibleItem = visibleItems[visibleItems.length - 1]; this.bcSet_.items.forEach((bc) => { const ps = []; if (bc === firstVisibleItem) { ps.push('first'); if (!this.blade_ || this.blade_.get('positions').includes('veryfirst')) { ps.push('veryfirst'); } } if (bc === lastVisibleItem) { ps.push('last'); if (!this.blade_ || this.blade_.get('positions').includes('verylast')) { ps.push('verylast'); } } bc.blade.set('positions', ps); }); } onChildPositionsChange_() { this.updatePositions_(); this.emitter.emit('layout', { sender: this, }); } onChildViewPropsChange_(_ev) { this.updatePositions_(); this.emitter.emit('layout', { sender: this, }); } onChildDispose_() { const disposedUcs = this.bcSet_.items.filter((bc) => { return bc.viewProps.get('disposed'); }); disposedUcs.forEach((bc) => { this.bcSet_.remove(bc); }); } onChildInputChange_(ev) { const bc = findInputBindingController(this.find(InputBindingController), ev.sender); if (!bc) { throw TpError.shouldNeverHappen(); } this.emitter.emit('inputchange', { bladeController: bc, options: ev.options, sender: this, }); } onChildMonitorUpdate_(ev) { const bc = findMonitorBindingController(this.find(MonitorBindingController), ev.sender); if (!bc) { throw TpError.shouldNeverHappen(); } this.emitter.emit('monitorupdate', { bladeController: bc, sender: this, }); } onChildValueChange_(ev) { const bc = findValueBladeController(this.find(ValueBladeController), ev.sender); if (!bc) { throw TpError.shouldNeverHappen(); } this.emitter.emit('inputchange', { bladeController: bc, options: ev.options, sender: this, }); } onDescendantLayout_(_) { this.updatePositions_(); this.emitter.emit('layout', { sender: this, }); } onDescendantInputChange_(ev) { this.emitter.emit('inputchange', { bladeController: ev.bladeController, options: ev.options, sender: this, }); } onDescendantMonitorUpdate_(ev) { this.emitter.emit('monitorupdate', { bladeController: ev.bladeController, sender: this, }); } onBladePositionsChange_() { this.updatePositions_(); } } class RackController extends BladeController { constructor(doc, config) { super(Object.assign(Object.assign({}, config), { view: new PlainView(doc, { viewName: 'brk', viewProps: config.viewProps, }) })); this.onRackAdd_ = this.onRackAdd_.bind(this); this.onRackRemove_ = this.onRackRemove_.bind(this); const rack = new BladeRack(config.root ? undefined : config.blade); rack.emitter.on('add', this.onRackAdd_); rack.emitter.on('remove', this.onRackRemove_); this.rack = rack; this.viewProps.handleDispose(() => { for (let i = this.rack.children.length - 1; i >= 0; i--) { const bc = this.rack.children[i]; bc.viewProps.set('disposed', true); } }); } onRackAdd_(ev) { if (!ev.isRoot) { return; } insertElementAt(this.view.element, ev.bladeController.view.element, ev.index); } onRackRemove_(ev) { if (!ev.isRoot) { return; } removeElement(ev.bladeController.view.element); } } const bladeContainerClassName = ClassName('cnt'); class FolderView { constructor(doc, config) { this.className_ = ClassName(config.viewName || 'fld'); this.element = doc.createElement('div'); this.element.classList.add(this.className_(), bladeContainerClassName()); config.viewProps.bindClassModifiers(this.element); this.foldable_ = config.foldable; this.foldable_.bindExpandedClass(this.element, this.className_(undefined, 'expanded')); bindValueMap(this.foldable_, 'completed', valueToClassName(this.element, this.className_(undefined, 'cpl'))); const buttonElem = doc.createElement('button'); buttonElem.classList.add(this.className_('b')); bindValueMap(config.props, 'title', (title) => { if (isEmpty(title)) { this.element.classList.add(this.className_(undefined, 'not')); } else { this.element.classList.remove(this.className_(undefined, 'not')); } }); config.viewProps.bindDisabled(buttonElem); this.element.appendChild(buttonElem); this.buttonElement = buttonElem; const titleElem = doc.createElement('div'); titleElem.classList.add(this.className_('t')); bindValueToTextContent(config.props.value('title'), titleElem); this.buttonElement.appendChild(titleElem); this.titleElement = titleElem; const markElem = doc.createElement('div'); markElem.classList.add(this.className_('m')); this.buttonElement.appendChild(markElem); const containerElem = config.containerElement; containerElem.classList.add(this.className_('c')); this.element.appendChild(containerElem); this.containerElement = containerElem; } } class FolderController extends RackLikeController { constructor(doc, config) { var _a; const foldable = Foldable.create((_a = config.expanded) !== null && _a !== void 0 ? _a : true); const rc = new RackController(doc, { blade: config.blade, root: config.root, viewProps: config.viewProps, }); super(Object.assign(Object.assign({}, config), { rackController: rc, view: new FolderView(doc, { containerElement: rc.view.element, foldable: foldable, props: config.props, viewName: config.root ? 'rot' : undefined, viewProps: config.viewProps, }) })); this.onTitleClick_ = this.onTitleClick_.bind(this); this.props = config.props; this.foldable = foldable; bindFoldable(this.foldable, this.view.containerElement); this.view.buttonElement.addEventListener('click', this.onTitleClick_); } get document() { return this.view.element.ownerDocument; } onTitleClick_() { this.foldable.set('expanded', !this.foldable.get('expanded')); } } const FolderBladePlugin = { id: 'folder', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { title: p.required.string, view: p.required.constant('folder'), expanded: p.optional.boolean, }); return result ? { params: result } : null; }, controller(args) { return new FolderController(args.document, { blade: args.blade, expanded: args.params.expanded, props: ValueMap.fromObject({ title: args.params.title, }), viewProps: args.viewProps, }); }, api(args) { if (!(args.controller instanceof FolderController)) { return null; } return new FolderApi(args.controller, args.pool); }, }; class LabeledValueController extends ValueBladeController { constructor(doc, config) { const viewProps = config.valueController.viewProps; super(Object.assign(Object.assign({}, config), { value: config.valueController.value, view: new LabelView(doc, { props: config.props, viewProps: viewProps, }), viewProps: viewProps })); this.props = config.props; this.valueController = config.valueController; this.view.valueElement.appendChild(this.valueController.view.element); } } class SeparatorApi extends BladeApi { } const className$n = ClassName('spr'); class SeparatorView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$n()); config.viewProps.bindClassModifiers(this.element); const hrElem = doc.createElement('hr'); hrElem.classList.add(className$n('r')); this.element.appendChild(hrElem); } } class SeparatorController extends BladeController { constructor(doc, config) { super(Object.assign(Object.assign({}, config), { view: new SeparatorView(doc, { viewProps: config.viewProps, }) })); } } const SeparatorBladePlugin = { id: 'separator', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { view: p.required.constant('separator'), }); return result ? { params: result } : null; }, controller(args) { return new SeparatorController(args.document, { blade: args.blade, viewProps: args.viewProps, }); }, api(args) { if (!(args.controller instanceof SeparatorController)) { return null; } return new SeparatorApi(args.controller); }, }; const className$m = ClassName(''); function valueToModifier(elem, modifier) { return valueToClassName(elem, className$m(undefined, modifier)); } class ViewProps extends ValueMap { constructor(valueMap) { super(valueMap); } static create(opt_initialValue) { var _a, _b; const initialValue = opt_initialValue !== null && opt_initialValue !== void 0 ? opt_initialValue : {}; const coreObj = { disabled: (_a = initialValue.disabled) !== null && _a !== void 0 ? _a : false, disposed: false, hidden: (_b = initialValue.hidden) !== null && _b !== void 0 ? _b : false, }; const core = ValueMap.createCore(coreObj); return new ViewProps(core); } bindClassModifiers(elem) { bindValueMap(this, 'disabled', valueToModifier(elem, 'disabled')); bindValueMap(this, 'hidden', valueToModifier(elem, 'hidden')); } bindDisabled(target) { bindValueMap(this, 'disabled', (disabled) => { target.disabled = disabled; }); } bindTabIndex(elem) { bindValueMap(this, 'disabled', (disabled) => { elem.tabIndex = disabled ? -1 : 0; }); } handleDispose(callback) { this.value('disposed').emitter.on('change', (disposed) => { if (disposed) { callback(); } }); } } const className$l = ClassName('tbi'); class TabItemView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$l()); config.viewProps.bindClassModifiers(this.element); bindValueMap(config.props, 'selected', (selected) => { if (selected) { this.element.classList.add(className$l(undefined, 'sel')); } else { this.element.classList.remove(className$l(undefined, 'sel')); } }); const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$l('b')); config.viewProps.bindDisabled(buttonElem); this.element.appendChild(buttonElem); this.buttonElement = buttonElem; const titleElem = doc.createElement('div'); titleElem.classList.add(className$l('t')); bindValueToTextContent(config.props.value('title'), titleElem); this.buttonElement.appendChild(titleElem); this.titleElement = titleElem; } } class TabItemController { constructor(doc, config) { this.emitter = new Emitter(); this.onClick_ = this.onClick_.bind(this); this.props = config.props; this.viewProps = config.viewProps; this.view = new TabItemView(doc, { props: config.props, viewProps: config.viewProps, }); this.view.buttonElement.addEventListener('click', this.onClick_); } onClick_() { this.emitter.emit('click', { sender: this, }); } } class TabPageController { constructor(doc, config) { this.onItemClick_ = this.onItemClick_.bind(this); this.ic_ = new TabItemController(doc, { props: config.itemProps, viewProps: ViewProps.create(), }); this.ic_.emitter.on('click', this.onItemClick_); this.cc_ = new RackController(doc, { blade: createBlade(), viewProps: ViewProps.create(), }); this.props = config.props; bindValueMap(this.props, 'selected', (selected) => { this.itemController.props.set('selected', selected); this.contentController.viewProps.set('hidden', !selected); }); } get itemController() { return this.ic_; } get contentController() { return this.cc_; } onItemClick_() { this.props.set('selected', true); } } class TabPageApi { constructor(controller, contentRackApi) { this.controller_ = controller; this.rackApi_ = contentRackApi; } get title() { var _a; return (_a = this.controller_.itemController.props.get('title')) !== null && _a !== void 0 ? _a : ''; } set title(title) { this.controller_.itemController.props.set('title', title); } get selected() { return this.controller_.props.get('selected'); } set selected(selected) { this.controller_.props.set('selected', selected); } get children() { return this.rackApi_.children; } addButton(params) { return this.rackApi_.addButton(params); } addFolder(params) { return this.rackApi_.addFolder(params); } addSeparator(opt_params) { return this.rackApi_.addSeparator(opt_params); } addTab(params) { return this.rackApi_.addTab(params); } add(api, opt_index) { this.rackApi_.add(api, opt_index); } remove(api) { this.rackApi_.remove(api); } addInput(object, key, opt_params) { return this.rackApi_.addInput(object, key, opt_params); } addMonitor(object, key, opt_params) { return this.rackApi_.addMonitor(object, key, opt_params); } addBlade(params) { return this.rackApi_.addBlade(params); } } class TabApi extends RackLikeApi { constructor(controller, pool) { super(controller, new RackApi(controller.rackController, pool)); this.onPageAdd_ = this.onPageAdd_.bind(this); this.onPageRemove_ = this.onPageRemove_.bind(this); this.emitter_ = new Emitter(); this.pageApiMap_ = new Map(); this.rackApi_.on('change', (ev) => { this.emitter_.emit('change', { event: ev, }); }); this.rackApi_.on('update', (ev) => { this.emitter_.emit('update', { event: ev, }); }); this.controller_.pageSet.emitter.on('add', this.onPageAdd_); this.controller_.pageSet.emitter.on('remove', this.onPageRemove_); this.controller_.pageSet.items.forEach((pc) => { this.setUpPageApi_(pc); }); } get pages() { return this.controller_.pageSet.items.map((pc) => { const api = this.pageApiMap_.get(pc); if (!api) { throw TpError.shouldNeverHappen(); } return api; }); } addPage(params) { const doc = this.controller_.view.element.ownerDocument; const pc = new TabPageController(doc, { itemProps: ValueMap.fromObject({ selected: false, title: params.title, }), props: ValueMap.fromObject({ selected: false, }), }); this.controller_.add(pc, params.index); const api = this.pageApiMap_.get(pc); if (!api) { throw TpError.shouldNeverHappen(); } return api; } removePage(index) { this.controller_.remove(index); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } setUpPageApi_(pc) { const rackApi = this.rackApi_['apiSet_'].find((api) => api.controller_ === pc.contentController); if (!rackApi) { throw TpError.shouldNeverHappen(); } const api = new TabPageApi(pc, rackApi); this.pageApiMap_.set(pc, api); } onPageAdd_(ev) { this.setUpPageApi_(ev.item); } onPageRemove_(ev) { const api = this.pageApiMap_.get(ev.item); if (!api) { throw TpError.shouldNeverHappen(); } this.pageApiMap_.delete(ev.item); } } const className$k = ClassName('tab'); class TabView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$k(), bladeContainerClassName()); config.viewProps.bindClassModifiers(this.element); bindValue(config.empty, valueToClassName(this.element, className$k(undefined, 'nop'))); const itemsElem = doc.createElement('div'); itemsElem.classList.add(className$k('i')); this.element.appendChild(itemsElem); this.itemsElement = itemsElem; const contentsElem = config.contentsElement; contentsElem.classList.add(className$k('c')); this.element.appendChild(contentsElem); this.contentsElement = contentsElem; } } class TabController extends RackLikeController { constructor(doc, config) { const cr = new RackController(doc, { blade: config.blade, viewProps: config.viewProps, }); const empty = createValue(true); super({ blade: config.blade, rackController: cr, view: new TabView(doc, { contentsElement: cr.view.element, empty: empty, viewProps: config.viewProps, }), }); this.onPageAdd_ = this.onPageAdd_.bind(this); this.onPageRemove_ = this.onPageRemove_.bind(this); this.onPageSelectedChange_ = this.onPageSelectedChange_.bind(this); this.pageSet_ = new NestedOrderedSet(() => null); this.pageSet_.emitter.on('add', this.onPageAdd_); this.pageSet_.emitter.on('remove', this.onPageRemove_); this.empty_ = empty; this.applyPages_(); } get pageSet() { return this.pageSet_; } add(pc, opt_index) { this.pageSet_.add(pc, opt_index !== null && opt_index !== void 0 ? opt_index : this.pageSet_.items.length); } remove(index) { this.pageSet_.remove(this.pageSet_.items[index]); } applyPages_() { this.keepSelection_(); this.empty_.rawValue = this.pageSet_.items.length === 0; } onPageAdd_(ev) { const pc = ev.item; insertElementAt(this.view.itemsElement, pc.itemController.view.element, ev.index); this.rackController.rack.add(pc.contentController, ev.index); pc.props.value('selected').emitter.on('change', this.onPageSelectedChange_); this.applyPages_(); } onPageRemove_(ev) { const pc = ev.item; removeElement(pc.itemController.view.element); this.rackController.rack.remove(pc.contentController); pc.props .value('selected') .emitter.off('change', this.onPageSelectedChange_); this.applyPages_(); } keepSelection_() { if (this.pageSet_.items.length === 0) { return; } const firstSelIndex = this.pageSet_.items.findIndex((pc) => pc.props.get('selected')); if (firstSelIndex < 0) { this.pageSet_.items.forEach((pc, i) => { pc.props.set('selected', i === 0); }); } else { this.pageSet_.items.forEach((pc, i) => { pc.props.set('selected', i === firstSelIndex); }); } } onPageSelectedChange_(ev) { if (ev.rawValue) { const index = this.pageSet_.items.findIndex((pc) => pc.props.value('selected') === ev.sender); this.pageSet_.items.forEach((pc, i) => { pc.props.set('selected', i === index); }); } else { this.keepSelection_(); } } } const TabBladePlugin = { id: 'tab', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { pages: p.required.array(p.required.object({ title: p.required.string })), view: p.required.constant('tab'), }); if (!result || result.pages.length === 0) { return null; } return { params: result }; }, controller(args) { const c = new TabController(args.document, { blade: args.blade, viewProps: args.viewProps, }); args.params.pages.forEach((p) => { const pc = new TabPageController(args.document, { itemProps: ValueMap.fromObject({ selected: false, title: p.title, }), props: ValueMap.fromObject({ selected: false, }), }); c.add(pc); }); return c; }, api(args) { if (!(args.controller instanceof TabController)) { return null; } return new TabApi(args.controller, args.pool); }, }; function createBladeController(plugin, args) { const ac = plugin.accept(args.params); if (!ac) { return null; } const disabled = ParamsParsers.optional.boolean(args.params['disabled']).value; const hidden = ParamsParsers.optional.boolean(args.params['hidden']).value; return plugin.controller({ blade: createBlade(), document: args.document, params: forceCast(Object.assign(Object.assign({}, ac.params), { disabled: disabled, hidden: hidden })), viewProps: ViewProps.create({ disabled: disabled, hidden: hidden, }), }); } class ManualTicker { constructor() { this.disabled = false; this.emitter = new Emitter(); } dispose() { } tick() { if (this.disabled) { return; } this.emitter.emit('tick', { sender: this, }); } } class IntervalTicker { constructor(doc, interval) { this.disabled_ = false; this.timerId_ = null; this.onTick_ = this.onTick_.bind(this); this.doc_ = doc; this.emitter = new Emitter(); this.interval_ = interval; this.setTimer_(); } get disabled() { return this.disabled_; } set disabled(inactive) { this.disabled_ = inactive; if (this.disabled_) { this.clearTimer_(); } else { this.setTimer_(); } } dispose() { this.clearTimer_(); } clearTimer_() { if (this.timerId_ === null) { return; } const win = this.doc_.defaultView; if (win) { win.clearInterval(this.timerId_); } this.timerId_ = null; } setTimer_() { this.clearTimer_(); if (this.interval_ <= 0) { return; } const win = this.doc_.defaultView; if (win) { this.timerId_ = win.setInterval(this.onTick_, this.interval_); } } onTick_() { if (this.disabled_) { return; } this.emitter.emit('tick', { sender: this, }); } } class CompositeConstraint { constructor(constraints) { this.constraints = constraints; } constrain(value) { return this.constraints.reduce((result, c) => { return c.constrain(result); }, value); } } function findConstraint(c, constraintClass) { if (c instanceof constraintClass) { return c; } if (c instanceof CompositeConstraint) { const result = c.constraints.reduce((tmpResult, sc) => { if (tmpResult) { return tmpResult; } return sc instanceof constraintClass ? sc : null; }, null); if (result) { return result; } } return null; } class ListConstraint { constructor(options) { this.options = options; } constrain(value) { const opts = this.options; if (opts.length === 0) { return value; } const matched = opts.filter((item) => { return item.value === value; }).length > 0; return matched ? value : opts[0].value; } } class RangeConstraint { constructor(config) { this.maxValue = config.max; this.minValue = config.min; } constrain(value) { let result = value; if (!isEmpty(this.minValue)) { result = Math.max(result, this.minValue); } if (!isEmpty(this.maxValue)) { result = Math.min(result, this.maxValue); } return result; } } class StepConstraint { constructor(step) { this.step = step; } constrain(value) { const r = value < 0 ? -Math.round(-value / this.step) : Math.round(value / this.step); return r * this.step; } } const className$j = ClassName('lst'); class ListView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); this.props_ = config.props; this.element = doc.createElement('div'); this.element.classList.add(className$j()); config.viewProps.bindClassModifiers(this.element); const selectElem = doc.createElement('select'); selectElem.classList.add(className$j('s')); bindValueMap(this.props_, 'options', (opts) => { removeChildElements(selectElem); opts.forEach((item, index) => { const optionElem = doc.createElement('option'); optionElem.dataset.index = String(index); optionElem.textContent = item.text; optionElem.value = String(item.value); selectElem.appendChild(optionElem); }); }); config.viewProps.bindDisabled(selectElem); this.element.appendChild(selectElem); this.selectElement = selectElem; const markElem = doc.createElement('div'); markElem.classList.add(className$j('m')); markElem.appendChild(createSvgIconElement(doc, 'dropdown')); this.element.appendChild(markElem); config.value.emitter.on('change', this.onValueChange_); this.value_ = config.value; this.update_(); } update_() { this.selectElement.value = String(this.value_.rawValue); } onValueChange_() { this.update_(); } } class ListController { constructor(doc, config) { this.onSelectChange_ = this.onSelectChange_.bind(this); this.props = config.props; this.value = config.value; this.viewProps = config.viewProps; this.view = new ListView(doc, { props: this.props, value: this.value, viewProps: this.viewProps, }); this.view.selectElement.addEventListener('change', this.onSelectChange_); } onSelectChange_(e) { const selectElem = forceCast(e.currentTarget); const optElem = selectElem.selectedOptions.item(0); if (!optElem) { return; } const itemIndex = Number(optElem.dataset.index); this.value.rawValue = this.props.get('options')[itemIndex].value; } } const className$i = ClassName('pop'); class PopupView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$i()); config.viewProps.bindClassModifiers(this.element); bindValue(config.shows, valueToClassName(this.element, className$i(undefined, 'v'))); } } class PopupController { constructor(doc, config) { this.shows = createValue(false); this.viewProps = config.viewProps; this.view = new PopupView(doc, { shows: this.shows, viewProps: this.viewProps, }); } } const className$h = ClassName('txt'); class TextView { constructor(doc, config) { this.onChange_ = this.onChange_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className$h()); config.viewProps.bindClassModifiers(this.element); this.props_ = config.props; this.props_.emitter.on('change', this.onChange_); const inputElem = doc.createElement('input'); inputElem.classList.add(className$h('i')); inputElem.type = 'text'; config.viewProps.bindDisabled(inputElem); this.element.appendChild(inputElem); this.inputElement = inputElem; config.value.emitter.on('change', this.onChange_); this.value_ = config.value; this.refresh(); } refresh() { const formatter = this.props_.get('formatter'); this.inputElement.value = formatter(this.value_.rawValue); } onChange_() { this.refresh(); } } class TextController { constructor(doc, config) { this.onInputChange_ = this.onInputChange_.bind(this); this.parser_ = config.parser; this.props = config.props; this.value = config.value; this.viewProps = config.viewProps; this.view = new TextView(doc, { props: config.props, value: this.value, viewProps: this.viewProps, }); this.view.inputElement.addEventListener('change', this.onInputChange_); } onInputChange_(e) { const inputElem = forceCast(e.currentTarget); const value = inputElem.value; const parsedValue = this.parser_(value); if (!isEmpty(parsedValue)) { this.value.rawValue = parsedValue; } this.view.refresh(); } } function boolToString(value) { return String(value); } function boolFromUnknown(value) { if (value === 'false') { return false; } return !!value; } function BooleanFormatter(value) { return boolToString(value); } class NumberLiteralNode { constructor(text) { this.text = text; } evaluate() { return Number(this.text); } toString() { return this.text; } } const BINARY_OPERATION_MAP = { '**': (v1, v2) => Math.pow(v1, v2), '*': (v1, v2) => v1 * v2, '/': (v1, v2) => v1 / v2, '%': (v1, v2) => v1 % v2, '+': (v1, v2) => v1 + v2, '-': (v1, v2) => v1 - v2, '<<': (v1, v2) => v1 << v2, '>>': (v1, v2) => v1 >> v2, '>>>': (v1, v2) => v1 >>> v2, '&': (v1, v2) => v1 & v2, '^': (v1, v2) => v1 ^ v2, '|': (v1, v2) => v1 | v2, }; class BinaryOperationNode { constructor(operator, left, right) { this.left = left; this.operator = operator; this.right = right; } evaluate() { const op = BINARY_OPERATION_MAP[this.operator]; if (!op) { throw new Error(`unexpected binary operator: '${this.operator}`); } return op(this.left.evaluate(), this.right.evaluate()); } toString() { return [ 'b(', this.left.toString(), this.operator, this.right.toString(), ')', ].join(' '); } } const UNARY_OPERATION_MAP = { '+': (v) => v, '-': (v) => -v, '~': (v) => ~v, }; class UnaryOperationNode { constructor(operator, expr) { this.operator = operator; this.expression = expr; } evaluate() { const op = UNARY_OPERATION_MAP[this.operator]; if (!op) { throw new Error(`unexpected unary operator: '${this.operator}`); } return op(this.expression.evaluate()); } toString() { return ['u(', this.operator, this.expression.toString(), ')'].join(' '); } } function combineReader(parsers) { return (text, cursor) => { for (let i = 0; i < parsers.length; i++) { const result = parsers[i](text, cursor); if (result !== '') { return result; } } return ''; }; } function readWhitespace(text, cursor) { var _a; const m = text.substr(cursor).match(/^\s+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readNonZeroDigit(text, cursor) { const ch = text.substr(cursor, 1); return ch.match(/^[1-9]$/) ? ch : ''; } function readDecimalDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-9]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readSignedInteger(text, cursor) { const ds = readDecimalDigits(text, cursor); if (ds !== '') { return ds; } const sign = text.substr(cursor, 1); cursor += 1; if (sign !== '-' && sign !== '+') { return ''; } const sds = readDecimalDigits(text, cursor); if (sds === '') { return ''; } return sign + sds; } function readExponentPart(text, cursor) { const e = text.substr(cursor, 1); cursor += 1; if (e.toLowerCase() !== 'e') { return ''; } const si = readSignedInteger(text, cursor); if (si === '') { return ''; } return e + si; } function readDecimalIntegerLiteral(text, cursor) { const ch = text.substr(cursor, 1); if (ch === '0') { return ch; } const nzd = readNonZeroDigit(text, cursor); cursor += nzd.length; if (nzd === '') { return ''; } return nzd + readDecimalDigits(text, cursor); } function readDecimalLiteral1(text, cursor) { const dil = readDecimalIntegerLiteral(text, cursor); cursor += dil.length; if (dil === '') { return ''; } const dot = text.substr(cursor, 1); cursor += dot.length; if (dot !== '.') { return ''; } const dds = readDecimalDigits(text, cursor); cursor += dds.length; return dil + dot + dds + readExponentPart(text, cursor); } function readDecimalLiteral2(text, cursor) { const dot = text.substr(cursor, 1); cursor += dot.length; if (dot !== '.') { return ''; } const dds = readDecimalDigits(text, cursor); cursor += dds.length; if (dds === '') { return ''; } return dot + dds + readExponentPart(text, cursor); } function readDecimalLiteral3(text, cursor) { const dil = readDecimalIntegerLiteral(text, cursor); cursor += dil.length; if (dil === '') { return ''; } return dil + readExponentPart(text, cursor); } const readDecimalLiteral = combineReader([ readDecimalLiteral1, readDecimalLiteral2, readDecimalLiteral3, ]); function parseBinaryDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[01]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readBinaryIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0b') { return ''; } const bds = parseBinaryDigits(text, cursor); if (bds === '') { return ''; } return prefix + bds; } function readOctalDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-7]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readOctalIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0o') { return ''; } const ods = readOctalDigits(text, cursor); if (ods === '') { return ''; } return prefix + ods; } function readHexDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-9a-f]+/i); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readHexIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0x') { return ''; } const hds = readHexDigits(text, cursor); if (hds === '') { return ''; } return prefix + hds; } const readNonDecimalIntegerLiteral = combineReader([ readBinaryIntegerLiteral, readOctalIntegerLiteral, readHexIntegerLiteral, ]); const readNumericLiteral = combineReader([ readNonDecimalIntegerLiteral, readDecimalLiteral, ]); function parseLiteral(text, cursor) { const num = readNumericLiteral(text, cursor); cursor += num.length; if (num === '') { return null; } return { evaluable: new NumberLiteralNode(num), cursor: cursor, }; } function parseParenthesizedExpression(text, cursor) { const op = text.substr(cursor, 1); cursor += op.length; if (op !== '(') { return null; } const expr = parseExpression(text, cursor); if (!expr) { return null; } cursor = expr.cursor; cursor += readWhitespace(text, cursor).length; const cl = text.substr(cursor, 1); cursor += cl.length; if (cl !== ')') { return null; } return { evaluable: expr.evaluable, cursor: cursor, }; } function parsePrimaryExpression(text, cursor) { return (parseLiteral(text, cursor) || parseParenthesizedExpression(text, cursor)); } function parseUnaryExpression(text, cursor) { const expr = parsePrimaryExpression(text, cursor); if (expr) { return expr; } const op = text.substr(cursor, 1); cursor += op.length; if (op !== '+' && op !== '-' && op !== '~') { return null; } const num = parseUnaryExpression(text, cursor); if (!num) { return null; } cursor = num.cursor; return { cursor: cursor, evaluable: new UnaryOperationNode(op, num.evaluable), }; } function readBinaryOperator(ops, text, cursor) { cursor += readWhitespace(text, cursor).length; const op = ops.filter((op) => text.startsWith(op, cursor))[0]; if (!op) { return null; } cursor += op.length; cursor += readWhitespace(text, cursor).length; return { cursor: cursor, operator: op, }; } function createBinaryOperationExpressionParser(exprParser, ops) { return (text, cursor) => { const firstExpr = exprParser(text, cursor); if (!firstExpr) { return null; } cursor = firstExpr.cursor; let expr = firstExpr.evaluable; for (;;) { const op = readBinaryOperator(ops, text, cursor); if (!op) { break; } cursor = op.cursor; const nextExpr = exprParser(text, cursor); if (!nextExpr) { return null; } cursor = nextExpr.cursor; expr = new BinaryOperationNode(op.operator, expr, nextExpr.evaluable); } return expr ? { cursor: cursor, evaluable: expr, } : null; }; } const parseBinaryOperationExpression = [ ['**'], ['*', '/', '%'], ['+', '-'], ['<<', '>>>', '>>'], ['&'], ['^'], ['|'], ].reduce((parser, ops) => { return createBinaryOperationExpressionParser(parser, ops); }, parseUnaryExpression); function parseExpression(text, cursor) { cursor += readWhitespace(text, cursor).length; return parseBinaryOperationExpression(text, cursor); } function parseEcmaNumberExpression(text) { const expr = parseExpression(text, 0); if (!expr) { return null; } const cursor = expr.cursor + readWhitespace(text, expr.cursor).length; if (cursor !== text.length) { return null; } return expr.evaluable; } function parseNumber(text) { var _a; const r = parseEcmaNumberExpression(text); return (_a = r === null || r === void 0 ? void 0 : r.evaluate()) !== null && _a !== void 0 ? _a : null; } function numberFromUnknown(value) { if (typeof value === 'number') { return value; } if (typeof value === 'string') { const pv = parseNumber(value); if (!isEmpty(pv)) { return pv; } } return 0; } function numberToString(value) { return String(value); } function createNumberFormatter(digits) { return (value) => { return value.toFixed(Math.max(Math.min(digits, 20), 0)); }; } const innerFormatter = createNumberFormatter(0); function formatPercentage(value) { return innerFormatter(value) + '%'; } function stringFromUnknown(value) { return String(value); } function formatString(value) { return value; } function fillBuffer(buffer, bufferSize) { while (buffer.length < bufferSize) { buffer.push(undefined); } } function initializeBuffer(bufferSize) { const buffer = []; fillBuffer(buffer, bufferSize); return createValue(buffer); } function createTrimmedBuffer(buffer) { const index = buffer.indexOf(undefined); return forceCast(index < 0 ? buffer : buffer.slice(0, index)); } function createPushedBuffer(buffer, newValue) { const newBuffer = [...createTrimmedBuffer(buffer), newValue]; if (newBuffer.length > buffer.length) { newBuffer.splice(0, newBuffer.length - buffer.length); } else { fillBuffer(newBuffer, buffer.length); } return newBuffer; } function connectValues({ primary, secondary, forward, backward, }) { let changing = false; function preventFeedback(callback) { if (changing) { return; } changing = true; callback(); changing = false; } primary.emitter.on('change', (ev) => { preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), ev.options); }); }); secondary.emitter.on('change', (ev) => { preventFeedback(() => { primary.setRawValue(backward(primary, secondary), ev.options); }); preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), ev.options); }); }); preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), { forceEmit: false, last: true, }); }); } function getStepForKey(baseStep, keys) { const step = baseStep * (keys.altKey ? 0.1 : 1) * (keys.shiftKey ? 10 : 1); if (keys.upKey) { return +step; } else if (keys.downKey) { return -step; } return 0; } function getVerticalStepKeys(ev) { return { altKey: ev.altKey, downKey: ev.key === 'ArrowDown', shiftKey: ev.shiftKey, upKey: ev.key === 'ArrowUp', }; } function getHorizontalStepKeys(ev) { return { altKey: ev.altKey, downKey: ev.key === 'ArrowLeft', shiftKey: ev.shiftKey, upKey: ev.key === 'ArrowRight', }; } function isVerticalArrowKey(key) { return key === 'ArrowUp' || key === 'ArrowDown'; } function isArrowKey(key) { return isVerticalArrowKey(key) || key === 'ArrowLeft' || key === 'ArrowRight'; } function computeOffset$1(ev, elem) { const win = elem.ownerDocument.defaultView; const rect = elem.getBoundingClientRect(); return { x: ev.pageX - (((win && win.scrollX) || 0) + rect.left), y: ev.pageY - (((win && win.scrollY) || 0) + rect.top), }; } class PointerHandler { constructor(element) { this.lastTouch_ = null; this.onDocumentMouseMove_ = this.onDocumentMouseMove_.bind(this); this.onDocumentMouseUp_ = this.onDocumentMouseUp_.bind(this); this.onMouseDown_ = this.onMouseDown_.bind(this); this.onTouchEnd_ = this.onTouchEnd_.bind(this); this.onTouchMove_ = this.onTouchMove_.bind(this); this.onTouchStart_ = this.onTouchStart_.bind(this); this.elem_ = element; this.emitter = new Emitter(); element.addEventListener('touchstart', this.onTouchStart_); element.addEventListener('touchmove', this.onTouchMove_); element.addEventListener('touchend', this.onTouchEnd_); element.addEventListener('mousedown', this.onMouseDown_); } computePosition_(offset) { const rect = this.elem_.getBoundingClientRect(); return { bounds: { width: rect.width, height: rect.height, }, point: offset ? { x: offset.x, y: offset.y, } : null, }; } onMouseDown_(ev) { var _a; ev.preventDefault(); (_a = ev.currentTarget) === null || _a === void 0 ? void 0 : _a.focus(); const doc = this.elem_.ownerDocument; doc.addEventListener('mousemove', this.onDocumentMouseMove_); doc.addEventListener('mouseup', this.onDocumentMouseUp_); this.emitter.emit('down', { altKey: ev.altKey, data: this.computePosition_(computeOffset$1(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onDocumentMouseMove_(ev) { this.emitter.emit('move', { altKey: ev.altKey, data: this.computePosition_(computeOffset$1(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onDocumentMouseUp_(ev) { const doc = this.elem_.ownerDocument; doc.removeEventListener('mousemove', this.onDocumentMouseMove_); doc.removeEventListener('mouseup', this.onDocumentMouseUp_); this.emitter.emit('up', { altKey: ev.altKey, data: this.computePosition_(computeOffset$1(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onTouchStart_(ev) { ev.preventDefault(); const touch = ev.targetTouches.item(0); const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('down', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); this.lastTouch_ = touch; } onTouchMove_(ev) { const touch = ev.targetTouches.item(0); const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('move', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); this.lastTouch_ = touch; } onTouchEnd_(ev) { var _a; const touch = (_a = ev.targetTouches.item(0)) !== null && _a !== void 0 ? _a : this.lastTouch_; const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('up', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); } } function mapRange(value, start1, end1, start2, end2) { const p = (value - start1) / (end1 - start1); return start2 + p * (end2 - start2); } function getDecimalDigits(value) { const text = String(value.toFixed(10)); const frac = text.split('.')[1]; return frac.replace(/0+$/, '').length; } function constrainRange(value, min, max) { return Math.min(Math.max(value, min), max); } function loopRange(value, max) { return ((value % max) + max) % max; } const className$g = ClassName('txt'); class NumberTextView { constructor(doc, config) { this.onChange_ = this.onChange_.bind(this); this.props_ = config.props; this.props_.emitter.on('change', this.onChange_); this.element = doc.createElement('div'); this.element.classList.add(className$g(), className$g(undefined, 'num')); if (config.arrayPosition) { this.element.classList.add(className$g(undefined, config.arrayPosition)); } config.viewProps.bindClassModifiers(this.element); const inputElem = doc.createElement('input'); inputElem.classList.add(className$g('i')); inputElem.type = 'text'; config.viewProps.bindDisabled(inputElem); this.element.appendChild(inputElem); this.inputElement = inputElem; this.onDraggingChange_ = this.onDraggingChange_.bind(this); this.dragging_ = config.dragging; this.dragging_.emitter.on('change', this.onDraggingChange_); this.element.classList.add(className$g()); this.inputElement.classList.add(className$g('i')); const knobElem = doc.createElement('div'); knobElem.classList.add(className$g('k')); this.element.appendChild(knobElem); this.knobElement = knobElem; const guideElem = doc.createElementNS(SVG_NS, 'svg'); guideElem.classList.add(className$g('g')); this.knobElement.appendChild(guideElem); const bodyElem = doc.createElementNS(SVG_NS, 'path'); bodyElem.classList.add(className$g('gb')); guideElem.appendChild(bodyElem); this.guideBodyElem_ = bodyElem; const headElem = doc.createElementNS(SVG_NS, 'path'); headElem.classList.add(className$g('gh')); guideElem.appendChild(headElem); this.guideHeadElem_ = headElem; const tooltipElem = doc.createElement('div'); tooltipElem.classList.add(ClassName('tt')()); this.knobElement.appendChild(tooltipElem); this.tooltipElem_ = tooltipElem; config.value.emitter.on('change', this.onChange_); this.value = config.value; this.refresh(); } onDraggingChange_(ev) { if (ev.rawValue === null) { this.element.classList.remove(className$g(undefined, 'drg')); return; } this.element.classList.add(className$g(undefined, 'drg')); const x = ev.rawValue / this.props_.get('draggingScale'); const aox = x + (x > 0 ? -1 : x < 0 ? +1 : 0); const adx = constrainRange(-aox, -4, +4); this.guideHeadElem_.setAttributeNS(null, 'd', [`M ${aox + adx},0 L${aox},4 L${aox + adx},8`, `M ${x},-1 L${x},9`].join(' ')); this.guideBodyElem_.setAttributeNS(null, 'd', `M 0,4 L${x},4`); const formatter = this.props_.get('formatter'); this.tooltipElem_.textContent = formatter(this.value.rawValue); this.tooltipElem_.style.left = `${x}px`; } refresh() { const formatter = this.props_.get('formatter'); this.inputElement.value = formatter(this.value.rawValue); } onChange_() { this.refresh(); } } class NumberTextController { constructor(doc, config) { this.originRawValue_ = 0; this.onInputChange_ = this.onInputChange_.bind(this); this.onInputKeyDown_ = this.onInputKeyDown_.bind(this); this.onInputKeyUp_ = this.onInputKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.baseStep_ = config.baseStep; this.parser_ = config.parser; this.props = config.props; this.value = config.value; this.viewProps = config.viewProps; this.dragging_ = createValue(null); this.view = new NumberTextView(doc, { arrayPosition: config.arrayPosition, dragging: this.dragging_, props: this.props, value: this.value, viewProps: this.viewProps, }); this.view.inputElement.addEventListener('change', this.onInputChange_); this.view.inputElement.addEventListener('keydown', this.onInputKeyDown_); this.view.inputElement.addEventListener('keyup', this.onInputKeyUp_); const ph = new PointerHandler(this.view.knobElement); ph.emitter.on('down', this.onPointerDown_); ph.emitter.on('move', this.onPointerMove_); ph.emitter.on('up', this.onPointerUp_); } onInputChange_(e) { const inputElem = forceCast(e.currentTarget); const value = inputElem.value; const parsedValue = this.parser_(value); if (!isEmpty(parsedValue)) { this.value.rawValue = parsedValue; } this.view.refresh(); } onInputKeyDown_(ev) { const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue + step, { forceEmit: false, last: false, }); } onInputKeyUp_(ev) { const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } onPointerDown_() { this.originRawValue_ = this.value.rawValue; this.dragging_.rawValue = 0; } computeDraggingValue_(data) { if (!data.point) { return null; } const dx = data.point.x - data.bounds.width / 2; return this.originRawValue_ + dx * this.props.get('draggingScale'); } onPointerMove_(ev) { const v = this.computeDraggingValue_(ev.data); if (v === null) { return; } this.value.setRawValue(v, { forceEmit: false, last: false, }); this.dragging_.rawValue = this.value.rawValue - this.originRawValue_; } onPointerUp_(ev) { const v = this.computeDraggingValue_(ev.data); if (v === null) { return; } this.value.setRawValue(v, { forceEmit: true, last: true, }); this.dragging_.rawValue = null; } } const className$f = ClassName('sld'); class SliderView { constructor(doc, config) { this.onChange_ = this.onChange_.bind(this); this.props_ = config.props; this.props_.emitter.on('change', this.onChange_); this.element = doc.createElement('div'); this.element.classList.add(className$f()); config.viewProps.bindClassModifiers(this.element); const trackElem = doc.createElement('div'); trackElem.classList.add(className$f('t')); config.viewProps.bindTabIndex(trackElem); this.element.appendChild(trackElem); this.trackElement = trackElem; const knobElem = doc.createElement('div'); knobElem.classList.add(className$f('k')); this.trackElement.appendChild(knobElem); this.knobElement = knobElem; config.value.emitter.on('change', this.onChange_); this.value = config.value; this.update_(); } update_() { const p = constrainRange(mapRange(this.value.rawValue, this.props_.get('minValue'), this.props_.get('maxValue'), 0, 100), 0, 100); this.knobElement.style.width = `${p}%`; } onChange_() { this.update_(); } } class SliderController { constructor(doc, config) { this.onKeyDown_ = this.onKeyDown_.bind(this); this.onKeyUp_ = this.onKeyUp_.bind(this); this.onPointerDownOrMove_ = this.onPointerDownOrMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.baseStep_ = config.baseStep; this.value = config.value; this.viewProps = config.viewProps; this.props = config.props; this.view = new SliderView(doc, { props: this.props, value: this.value, viewProps: this.viewProps, }); this.ptHandler_ = new PointerHandler(this.view.trackElement); this.ptHandler_.emitter.on('down', this.onPointerDownOrMove_); this.ptHandler_.emitter.on('move', this.onPointerDownOrMove_); this.ptHandler_.emitter.on('up', this.onPointerUp_); this.view.trackElement.addEventListener('keydown', this.onKeyDown_); this.view.trackElement.addEventListener('keyup', this.onKeyUp_); } handlePointerEvent_(d, opts) { if (!d.point) { return; } this.value.setRawValue(mapRange(constrainRange(d.point.x, 0, d.bounds.width), 0, d.bounds.width, this.props.get('minValue'), this.props.get('maxValue')), opts); } onPointerDownOrMove_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: true, last: true, }); } onKeyDown_(ev) { const step = getStepForKey(this.baseStep_, getHorizontalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue + step, { forceEmit: false, last: false, }); } onKeyUp_(ev) { const step = getStepForKey(this.baseStep_, getHorizontalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } const className$e = ClassName('sldtxt'); class SliderTextView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$e()); const sliderElem = doc.createElement('div'); sliderElem.classList.add(className$e('s')); this.sliderView_ = config.sliderView; sliderElem.appendChild(this.sliderView_.element); this.element.appendChild(sliderElem); const textElem = doc.createElement('div'); textElem.classList.add(className$e('t')); this.textView_ = config.textView; textElem.appendChild(this.textView_.element); this.element.appendChild(textElem); } } class SliderTextController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.sliderC_ = new SliderController(doc, { baseStep: config.baseStep, props: config.sliderProps, value: config.value, viewProps: this.viewProps, }); this.textC_ = new NumberTextController(doc, { baseStep: config.baseStep, parser: config.parser, props: config.textProps, value: config.value, viewProps: config.viewProps, }); this.view = new SliderTextView(doc, { sliderView: this.sliderC_.view, textView: this.textC_.view, }); } get sliderController() { return this.sliderC_; } get textController() { return this.textC_; } } function writePrimitive(target, value) { target.write(value); } function parseListOptions(value) { const p = ParamsParsers; if (Array.isArray(value)) { return p.required.array(p.required.object({ text: p.required.string, value: p.required.raw, }))(value).value; } if (typeof value === 'object') { return p.required.raw(value) .value; } return undefined; } function parsePickerLayout(value) { if (value === 'inline' || value === 'popup') { return value; } return undefined; } function parsePointDimensionParams(value) { const p = ParamsParsers; return p.required.object({ max: p.optional.number, min: p.optional.number, step: p.optional.number, })(value).value; } function normalizeListOptions(options) { if (Array.isArray(options)) { return options; } const items = []; Object.keys(options).forEach((text) => { items.push({ text: text, value: options[text] }); }); return items; } function createListConstraint(options) { return !isEmpty(options) ? new ListConstraint(normalizeListOptions(forceCast(options))) : null; } function findListItems(constraint) { const c = constraint ? findConstraint(constraint, ListConstraint) : null; if (!c) { return null; } return c.options; } function findStep(constraint) { const c = constraint ? findConstraint(constraint, StepConstraint) : null; if (!c) { return null; } return c.step; } function getSuitableDecimalDigits(constraint, rawValue) { const sc = constraint && findConstraint(constraint, StepConstraint); if (sc) { return getDecimalDigits(sc.step); } return Math.max(getDecimalDigits(rawValue), 2); } function getBaseStep(constraint) { const step = findStep(constraint); return step !== null && step !== void 0 ? step : 1; } function getSuitableDraggingScale(constraint, rawValue) { var _a; const sc = constraint && findConstraint(constraint, StepConstraint); const base = Math.abs((_a = sc === null || sc === void 0 ? void 0 : sc.step) !== null && _a !== void 0 ? _a : rawValue); return base === 0 ? 0.1 : Math.pow(10, Math.floor(Math.log10(base)) - 1); } const className$d = ClassName('ckb'); class CheckboxView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className$d()); config.viewProps.bindClassModifiers(this.element); const labelElem = doc.createElement('label'); labelElem.classList.add(className$d('l')); this.element.appendChild(labelElem); const inputElem = doc.createElement('input'); inputElem.classList.add(className$d('i')); inputElem.type = 'checkbox'; labelElem.appendChild(inputElem); this.inputElement = inputElem; config.viewProps.bindDisabled(this.inputElement); const wrapperElem = doc.createElement('div'); wrapperElem.classList.add(className$d('w')); labelElem.appendChild(wrapperElem); const markElem = createSvgIconElement(doc, 'check'); wrapperElem.appendChild(markElem); config.value.emitter.on('change', this.onValueChange_); this.value = config.value; this.update_(); } update_() { this.inputElement.checked = this.value.rawValue; } onValueChange_() { this.update_(); } } class CheckboxController { constructor(doc, config) { this.onInputChange_ = this.onInputChange_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.view = new CheckboxView(doc, { value: this.value, viewProps: this.viewProps, }); this.view.inputElement.addEventListener('change', this.onInputChange_); } onInputChange_(e) { const inputElem = forceCast(e.currentTarget); this.value.rawValue = inputElem.checked; } } function createConstraint$5(params) { const constraints = []; const lc = createListConstraint(params.options); if (lc) { constraints.push(lc); } return new CompositeConstraint(constraints); } const BooleanInputPlugin = { id: 'input-bool', type: 'input', accept: (value, params) => { if (typeof value !== 'boolean') { return null; } const p = ParamsParsers; const result = parseParams(params, { options: p.optional.custom(parseListOptions), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => boolFromUnknown, constraint: (args) => createConstraint$5(args.params), writer: (_args) => writePrimitive, }, controller: (args) => { var _a; const doc = args.document; const value = args.value; const c = args.constraint; if (c && findConstraint(c, ListConstraint)) { return new ListController(doc, { props: ValueMap.fromObject({ options: (_a = findListItems(c)) !== null && _a !== void 0 ? _a : [], }), value: value, viewProps: args.viewProps, }); } return new CheckboxController(doc, { value: value, viewProps: args.viewProps, }); }, }; const className$c = ClassName('col'); class ColorView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$c()); config.foldable.bindExpandedClass(this.element, className$c(undefined, 'expanded')); bindValueMap(config.foldable, 'completed', valueToClassName(this.element, className$c(undefined, 'cpl'))); const headElem = doc.createElement('div'); headElem.classList.add(className$c('h')); this.element.appendChild(headElem); const swatchElem = doc.createElement('div'); swatchElem.classList.add(className$c('s')); headElem.appendChild(swatchElem); this.swatchElement = swatchElem; const textElem = doc.createElement('div'); textElem.classList.add(className$c('t')); headElem.appendChild(textElem); this.textElement = textElem; if (config.pickerLayout === 'inline') { const pickerElem = doc.createElement('div'); pickerElem.classList.add(className$c('p')); this.element.appendChild(pickerElem); this.pickerElement = pickerElem; } else { this.pickerElement = null; } } } function rgbToHsl(r, g, b) { const rp = constrainRange(r / 255, 0, 1); const gp = constrainRange(g / 255, 0, 1); const bp = constrainRange(b / 255, 0, 1); const cmax = Math.max(rp, gp, bp); const cmin = Math.min(rp, gp, bp); const c = cmax - cmin; let h = 0; let s = 0; const l = (cmin + cmax) / 2; if (c !== 0) { s = c / (1 - Math.abs(cmax + cmin - 1)); if (rp === cmax) { h = (gp - bp) / c; } else if (gp === cmax) { h = 2 + (bp - rp) / c; } else { h = 4 + (rp - gp) / c; } h = h / 6 + (h < 0 ? 1 : 0); } return [h * 360, s * 100, l * 100]; } function hslToRgb(h, s, l) { const hp = ((h % 360) + 360) % 360; const sp = constrainRange(s / 100, 0, 1); const lp = constrainRange(l / 100, 0, 1); const c = (1 - Math.abs(2 * lp - 1)) * sp; const x = c * (1 - Math.abs(((hp / 60) % 2) - 1)); const m = lp - c / 2; let rp, gp, bp; if (hp >= 0 && hp < 60) { [rp, gp, bp] = [c, x, 0]; } else if (hp >= 60 && hp < 120) { [rp, gp, bp] = [x, c, 0]; } else if (hp >= 120 && hp < 180) { [rp, gp, bp] = [0, c, x]; } else if (hp >= 180 && hp < 240) { [rp, gp, bp] = [0, x, c]; } else if (hp >= 240 && hp < 300) { [rp, gp, bp] = [x, 0, c]; } else { [rp, gp, bp] = [c, 0, x]; } return [(rp + m) * 255, (gp + m) * 255, (bp + m) * 255]; } function rgbToHsv(r, g, b) { const rp = constrainRange(r / 255, 0, 1); const gp = constrainRange(g / 255, 0, 1); const bp = constrainRange(b / 255, 0, 1); const cmax = Math.max(rp, gp, bp); const cmin = Math.min(rp, gp, bp); const d = cmax - cmin; let h; if (d === 0) { h = 0; } else if (cmax === rp) { h = 60 * (((((gp - bp) / d) % 6) + 6) % 6); } else if (cmax === gp) { h = 60 * ((bp - rp) / d + 2); } else { h = 60 * ((rp - gp) / d + 4); } const s = cmax === 0 ? 0 : d / cmax; const v = cmax; return [h, s * 100, v * 100]; } function hsvToRgb(h, s, v) { const hp = loopRange(h, 360); const sp = constrainRange(s / 100, 0, 1); const vp = constrainRange(v / 100, 0, 1); const c = vp * sp; const x = c * (1 - Math.abs(((hp / 60) % 2) - 1)); const m = vp - c; let rp, gp, bp; if (hp >= 0 && hp < 60) { [rp, gp, bp] = [c, x, 0]; } else if (hp >= 60 && hp < 120) { [rp, gp, bp] = [x, c, 0]; } else if (hp >= 120 && hp < 180) { [rp, gp, bp] = [0, c, x]; } else if (hp >= 180 && hp < 240) { [rp, gp, bp] = [0, x, c]; } else if (hp >= 240 && hp < 300) { [rp, gp, bp] = [x, 0, c]; } else { [rp, gp, bp] = [c, 0, x]; } return [(rp + m) * 255, (gp + m) * 255, (bp + m) * 255]; } function hslToHsv(h, s, l) { const sd = l + (s * (100 - Math.abs(2 * l - 100))) / (2 * 100); return [ h, sd !== 0 ? (s * (100 - Math.abs(2 * l - 100))) / sd : 0, l + (s * (100 - Math.abs(2 * l - 100))) / (2 * 100), ]; } function hsvToHsl(h, s, v) { const sd = 100 - Math.abs((v * (200 - s)) / 100 - 100); return [h, sd !== 0 ? (s * v) / sd : 0, (v * (200 - s)) / (2 * 100)]; } function removeAlphaComponent(comps) { return [comps[0], comps[1], comps[2]]; } function appendAlphaComponent(comps, alpha) { return [comps[0], comps[1], comps[2], alpha]; } const MODE_CONVERTER_MAP = { hsl: { hsl: (h, s, l) => [h, s, l], hsv: hslToHsv, rgb: hslToRgb, }, hsv: { hsl: hsvToHsl, hsv: (h, s, v) => [h, s, v], rgb: hsvToRgb, }, rgb: { hsl: rgbToHsl, hsv: rgbToHsv, rgb: (r, g, b) => [r, g, b], }, }; function convertColorMode(components, fromMode, toMode) { return MODE_CONVERTER_MAP[fromMode][toMode](...components); } const CONSTRAINT_MAP = { hsl: (comps) => { var _a; return [ loopRange(comps[0], 360), constrainRange(comps[1], 0, 100), constrainRange(comps[2], 0, 100), constrainRange((_a = comps[3]) !== null && _a !== void 0 ? _a : 1, 0, 1), ]; }, hsv: (comps) => { var _a; return [ loopRange(comps[0], 360), constrainRange(comps[1], 0, 100), constrainRange(comps[2], 0, 100), constrainRange((_a = comps[3]) !== null && _a !== void 0 ? _a : 1, 0, 1), ]; }, rgb: (comps) => { var _a; return [ constrainRange(comps[0], 0, 255), constrainRange(comps[1], 0, 255), constrainRange(comps[2], 0, 255), constrainRange((_a = comps[3]) !== null && _a !== void 0 ? _a : 1, 0, 1), ]; }, }; function isRgbColorComponent(obj, key) { if (typeof obj !== 'object' || isEmpty(obj)) { return false; } return key in obj && typeof obj[key] === 'number'; } class Color { constructor(comps, mode) { this.mode_ = mode; this.comps_ = CONSTRAINT_MAP[mode](comps); } static black() { return new Color([0, 0, 0], 'rgb'); } static fromObject(obj) { const comps = 'a' in obj ? [obj.r, obj.g, obj.b, obj.a] : [obj.r, obj.g, obj.b]; return new Color(comps, 'rgb'); } static toRgbaObject(color) { return color.toRgbaObject(); } static isRgbColorObject(obj) { return (isRgbColorComponent(obj, 'r') && isRgbColorComponent(obj, 'g') && isRgbColorComponent(obj, 'b')); } static isRgbaColorObject(obj) { return this.isRgbColorObject(obj) && isRgbColorComponent(obj, 'a'); } static isColorObject(obj) { return this.isRgbColorObject(obj); } static equals(v1, v2) { if (v1.mode_ !== v2.mode_) { return false; } const comps1 = v1.comps_; const comps2 = v2.comps_; for (let i = 0; i < comps1.length; i++) { if (comps1[i] !== comps2[i]) { return false; } } return true; } get mode() { return this.mode_; } getComponents(opt_mode) { return appendAlphaComponent(convertColorMode(removeAlphaComponent(this.comps_), this.mode_, opt_mode || this.mode_), this.comps_[3]); } toRgbaObject() { const rgbComps = this.getComponents('rgb'); return { r: rgbComps[0], g: rgbComps[1], b: rgbComps[2], a: rgbComps[3], }; } } const className$b = ClassName('colp'); class ColorPickerView { constructor(doc, config) { this.alphaViews_ = null; this.element = doc.createElement('div'); this.element.classList.add(className$b()); const hsvElem = doc.createElement('div'); hsvElem.classList.add(className$b('hsv')); const svElem = doc.createElement('div'); svElem.classList.add(className$b('sv')); this.svPaletteView_ = config.svPaletteView; svElem.appendChild(this.svPaletteView_.element); hsvElem.appendChild(svElem); const hElem = doc.createElement('div'); hElem.classList.add(className$b('h')); this.hPaletteView_ = config.hPaletteView; hElem.appendChild(this.hPaletteView_.element); hsvElem.appendChild(hElem); this.element.appendChild(hsvElem); const rgbElem = doc.createElement('div'); rgbElem.classList.add(className$b('rgb')); this.textView_ = config.textView; rgbElem.appendChild(this.textView_.element); this.element.appendChild(rgbElem); if (config.alphaViews) { this.alphaViews_ = { palette: config.alphaViews.palette, text: config.alphaViews.text, }; const aElem = doc.createElement('div'); aElem.classList.add(className$b('a')); const apElem = doc.createElement('div'); apElem.classList.add(className$b('ap')); apElem.appendChild(this.alphaViews_.palette.element); aElem.appendChild(apElem); const atElem = doc.createElement('div'); atElem.classList.add(className$b('at')); atElem.appendChild(this.alphaViews_.text.element); aElem.appendChild(atElem); this.element.appendChild(aElem); } } get allFocusableElements() { const elems = [ this.svPaletteView_.element, this.hPaletteView_.element, this.textView_.modeSelectElement, ...this.textView_.textViews.map((v) => v.inputElement), ]; if (this.alphaViews_) { elems.push(this.alphaViews_.palette.element, this.alphaViews_.text.inputElement); } return elems; } } function parseColorInputParams(params) { const p = ParamsParsers; return parseParams(params, { alpha: p.optional.boolean, expanded: p.optional.boolean, picker: p.optional.custom(parsePickerLayout), }); } function getBaseStepForColor(forAlpha) { return forAlpha ? 0.1 : 1; } function parseCssNumberOrPercentage(text, maxValue) { const m = text.match(/^(.+)%$/); if (!m) { return Math.min(parseFloat(text), maxValue); } return Math.min(parseFloat(m[1]) * 0.01 * maxValue, maxValue); } const ANGLE_TO_DEG_MAP = { deg: (angle) => angle, grad: (angle) => (angle * 360) / 400, rad: (angle) => (angle * 360) / (2 * Math.PI), turn: (angle) => angle * 360, }; function parseCssNumberOrAngle(text) { const m = text.match(/^([0-9.]+?)(deg|grad|rad|turn)$/); if (!m) { return parseFloat(text); } const angle = parseFloat(m[1]); const unit = m[2]; return ANGLE_TO_DEG_MAP[unit](angle); } const NOTATION_TO_PARSER_MAP = { 'func.rgb': (text) => { const m = text.match(/^rgb$\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*$$/); if (!m) { return null; } const comps = [ parseCssNumberOrPercentage(m[1], 255), parseCssNumberOrPercentage(m[2], 255), parseCssNumberOrPercentage(m[3], 255), ]; if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2])) { return null; } return new Color(comps, 'rgb'); }, 'func.rgba': (text) => { const m = text.match(/^rgba$\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*$$/); if (!m) { return null; } const comps = [ parseCssNumberOrPercentage(m[1], 255), parseCssNumberOrPercentage(m[2], 255), parseCssNumberOrPercentage(m[3], 255), parseCssNumberOrPercentage(m[4], 1), ]; if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2]) || isNaN(comps[3])) { return null; } return new Color(comps, 'rgb'); }, 'func.hsl': (text) => { const m = text.match(/^hsl$\s*([0-9A-Fa-f.]+(?:deg|grad|rad|turn)?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*$$/); if (!m) { return null; } const comps = [ parseCssNumberOrAngle(m[1]), parseCssNumberOrPercentage(m[2], 100), parseCssNumberOrPercentage(m[3], 100), ]; if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2])) { return null; } return new Color(comps, 'hsl'); }, 'func.hsla': (text) => { const m = text.match(/^hsla$\s*([0-9A-Fa-f.]+(?:deg|grad|rad|turn)?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*$$/); if (!m) { return null; } const comps = [ parseCssNumberOrAngle(m[1]), parseCssNumberOrPercentage(m[2], 100), parseCssNumberOrPercentage(m[3], 100), parseCssNumberOrPercentage(m[4], 1), ]; if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2]) || isNaN(comps[3])) { return null; } return new Color(comps, 'hsl'); }, 'hex.rgb': (text) => { const mRgb = text.match(/^#([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])$/); if (mRgb) { return new Color([ parseInt(mRgb[1] + mRgb[1], 16), parseInt(mRgb[2] + mRgb[2], 16), parseInt(mRgb[3] + mRgb[3], 16), ], 'rgb'); } const mRrggbb = text.match(/^(?:#|0x)([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/); if (mRrggbb) { return new Color([ parseInt(mRrggbb[1], 16), parseInt(mRrggbb[2], 16), parseInt(mRrggbb[3], 16), ], 'rgb'); } return null; }, 'hex.rgba': (text) => { const mRgb = text.match(/^#?([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])$/); if (mRgb) { return new Color([ parseInt(mRgb[1] + mRgb[1], 16), parseInt(mRgb[2] + mRgb[2], 16), parseInt(mRgb[3] + mRgb[3], 16), mapRange(parseInt(mRgb[4] + mRgb[4], 16), 0, 255, 0, 1), ], 'rgb'); } const mRrggbb = text.match(/^(?:#|0x)?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/); if (mRrggbb) { return new Color([ parseInt(mRrggbb[1], 16), parseInt(mRrggbb[2], 16), parseInt(mRrggbb[3], 16), mapRange(parseInt(mRrggbb[4], 16), 0, 255, 0, 1), ], 'rgb'); } return null; }, }; function getColorNotation(text) { const notations = Object.keys(NOTATION_TO_PARSER_MAP); return notations.reduce((result, notation) => { if (result) { return result; } const subparser = NOTATION_TO_PARSER_MAP[notation]; return subparser(text) ? notation : null; }, null); } const CompositeColorParser = (text) => { const notation = getColorNotation(text); return notation ? NOTATION_TO_PARSER_MAP[notation](text) : null; }; function hasAlphaComponent(notation) { return (notation === 'func.hsla' || notation === 'func.rgba' || notation === 'hex.rgba'); } function colorFromString(value) { if (typeof value === 'string') { const cv = CompositeColorParser(value); if (cv) { return cv; } } return Color.black(); } function zerofill(comp) { const hex = constrainRange(Math.floor(comp), 0, 255).toString(16); return hex.length === 1 ? `0${hex}` : hex; } function colorToHexRgbString(value, prefix = '#') { const hexes = removeAlphaComponent(value.getComponents('rgb')) .map(zerofill) .join(''); return `${prefix}${hexes}`; } function colorToHexRgbaString(value, prefix = '#') { const rgbaComps = value.getComponents('rgb'); const hexes = [rgbaComps[0], rgbaComps[1], rgbaComps[2], rgbaComps[3] * 255] .map(zerofill) .join(''); return `${prefix}${hexes}`; } function colorToFunctionalRgbString(value) { const formatter = createNumberFormatter(0); const comps = removeAlphaComponent(value.getComponents('rgb')).map((comp) => formatter(comp)); return `rgb(${comps.join(', ')})`; } function colorToFunctionalRgbaString(value) { const aFormatter = createNumberFormatter(2); const rgbFormatter = createNumberFormatter(0); const comps = value.getComponents('rgb').map((comp, index) => { const formatter = index === 3 ? aFormatter : rgbFormatter; return formatter(comp); }); return `rgba(${comps.join(', ')})`; } function colorToFunctionalHslString(value) { const formatters = [ createNumberFormatter(0), formatPercentage, formatPercentage, ]; const comps = removeAlphaComponent(value.getComponents('hsl')).map((comp, index) => formatters[index](comp)); return `hsl(${comps.join(', ')})`; } function colorToFunctionalHslaString(value) { const formatters = [ createNumberFormatter(0), formatPercentage, formatPercentage, createNumberFormatter(2), ]; const comps = value .getComponents('hsl') .map((comp, index) => formatters[index](comp)); return `hsla(${comps.join(', ')})`; } const NOTATION_TO_STRINGIFIER_MAP = { 'func.hsl': colorToFunctionalHslString, 'func.hsla': colorToFunctionalHslaString, 'func.rgb': colorToFunctionalRgbString, 'func.rgba': colorToFunctionalRgbaString, 'hex.rgb': colorToHexRgbString, 'hex.rgba': colorToHexRgbaString, }; function getColorStringifier(notation) { return NOTATION_TO_STRINGIFIER_MAP[notation]; } const className$a = ClassName('apl'); class APaletteView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); this.value = config.value; this.value.emitter.on('change', this.onValueChange_); this.element = doc.createElement('div'); this.element.classList.add(className$a()); config.viewProps.bindTabIndex(this.element); const barElem = doc.createElement('div'); barElem.classList.add(className$a('b')); this.element.appendChild(barElem); const colorElem = doc.createElement('div'); colorElem.classList.add(className$a('c')); barElem.appendChild(colorElem); this.colorElem_ = colorElem; const markerElem = doc.createElement('div'); markerElem.classList.add(className$a('m')); this.element.appendChild(markerElem); this.markerElem_ = markerElem; const previewElem = doc.createElement('div'); previewElem.classList.add(className$a('p')); this.markerElem_.appendChild(previewElem); this.previewElem_ = previewElem; this.update_(); } update_() { const c = this.value.rawValue; const rgbaComps = c.getComponents('rgb'); const leftColor = new Color([rgbaComps[0], rgbaComps[1], rgbaComps[2], 0], 'rgb'); const rightColor = new Color([rgbaComps[0], rgbaComps[1], rgbaComps[2], 255], 'rgb'); const gradientComps = [ 'to right', colorToFunctionalRgbaString(leftColor), colorToFunctionalRgbaString(rightColor), ]; this.colorElem_.style.background = `linear-gradient(${gradientComps.join(',')})`; this.previewElem_.style.backgroundColor = colorToFunctionalRgbaString(c); const left = mapRange(rgbaComps[3], 0, 1, 0, 100); this.markerElem_.style.left = `${left}%`; } onValueChange_() { this.update_(); } } class APaletteController { constructor(doc, config) { this.onKeyDown_ = this.onKeyDown_.bind(this); this.onKeyUp_ = this.onKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.view = new APaletteView(doc, { value: this.value, viewProps: this.viewProps, }); this.ptHandler_ = new PointerHandler(this.view.element); this.ptHandler_.emitter.on('down', this.onPointerDown_); this.ptHandler_.emitter.on('move', this.onPointerMove_); this.ptHandler_.emitter.on('up', this.onPointerUp_); this.view.element.addEventListener('keydown', this.onKeyDown_); this.view.element.addEventListener('keyup', this.onKeyUp_); } handlePointerEvent_(d, opts) { if (!d.point) { return; } const alpha = d.point.x / d.bounds.width; const c = this.value.rawValue; const [h, s, v] = c.getComponents('hsv'); this.value.setRawValue(new Color([h, s, v, alpha], 'hsv'), opts); } onPointerDown_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerMove_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: true, last: true, }); } onKeyDown_(ev) { const step = getStepForKey(getBaseStepForColor(true), getHorizontalStepKeys(ev)); if (step === 0) { return; } const c = this.value.rawValue; const [h, s, v, a] = c.getComponents('hsv'); this.value.setRawValue(new Color([h, s, v, a + step], 'hsv'), { forceEmit: false, last: false, }); } onKeyUp_(ev) { const step = getStepForKey(getBaseStepForColor(true), getHorizontalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } const className$9 = ClassName('coltxt'); function createModeSelectElement(doc) { const selectElem = doc.createElement('select'); const items = [ { text: 'RGB', value: 'rgb' }, { text: 'HSL', value: 'hsl' }, { text: 'HSV', value: 'hsv' }, ]; selectElem.appendChild(items.reduce((frag, item) => { const optElem = doc.createElement('option'); optElem.textContent = item.text; optElem.value = item.value; frag.appendChild(optElem); return frag; }, doc.createDocumentFragment())); return selectElem; } class ColorTextView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$9()); const modeElem = doc.createElement('div'); modeElem.classList.add(className$9('m')); this.modeElem_ = createModeSelectElement(doc); this.modeElem_.classList.add(className$9('ms')); modeElem.appendChild(this.modeSelectElement); const modeMarkerElem = doc.createElement('div'); modeMarkerElem.classList.add(className$9('mm')); modeMarkerElem.appendChild(createSvgIconElement(doc, 'dropdown')); modeElem.appendChild(modeMarkerElem); this.element.appendChild(modeElem); const textsElem = doc.createElement('div'); textsElem.classList.add(className$9('w')); this.element.appendChild(textsElem); this.textsElem_ = textsElem; this.textViews_ = config.textViews; this.applyTextViews_(); bindValue(config.colorMode, (mode) => { this.modeElem_.value = mode; }); } get modeSelectElement() { return this.modeElem_; } get textViews() { return this.textViews_; } set textViews(textViews) { this.textViews_ = textViews; this.applyTextViews_(); } applyTextViews_() { removeChildElements(this.textsElem_); const doc = this.element.ownerDocument; this.textViews_.forEach((v) => { const compElem = doc.createElement('div'); compElem.classList.add(className$9('c')); compElem.appendChild(v.element); this.textsElem_.appendChild(compElem); }); } } const FORMATTER = createNumberFormatter(0); const MODE_TO_CONSTRAINT_MAP = { rgb: () => { return new RangeConstraint({ min: 0, max: 255 }); }, hsl: (index) => { return index === 0 ? new RangeConstraint({ min: 0, max: 360 }) : new RangeConstraint({ min: 0, max: 100 }); }, hsv: (index) => { return index === 0 ? new RangeConstraint({ min: 0, max: 360 }) : new RangeConstraint({ min: 0, max: 100 }); }, }; function createComponentController(doc, config, index) { return new NumberTextController(doc, { arrayPosition: index === 0 ? 'fst' : index === 3 - 1 ? 'lst' : 'mid', baseStep: getBaseStepForColor(false), parser: config.parser, props: ValueMap.fromObject({ draggingScale: 1, formatter: FORMATTER, }), value: createValue(0, { constraint: MODE_TO_CONSTRAINT_MAP[config.colorMode](index), }), viewProps: config.viewProps, }); } class ColorTextController { constructor(doc, config) { this.onModeSelectChange_ = this.onModeSelectChange_.bind(this); this.parser_ = config.parser; this.value = config.value; this.viewProps = config.viewProps; this.colorMode = createValue(this.value.rawValue.mode); this.ccs_ = this.createComponentControllers_(doc); this.view = new ColorTextView(doc, { colorMode: this.colorMode, textViews: [this.ccs_[0].view, this.ccs_[1].view, this.ccs_[2].view], }); this.view.modeSelectElement.addEventListener('change', this.onModeSelectChange_); } createComponentControllers_(doc) { const cc = { colorMode: this.colorMode.rawValue, parser: this.parser_, viewProps: this.viewProps, }; const ccs = [ createComponentController(doc, cc, 0), createComponentController(doc, cc, 1), createComponentController(doc, cc, 2), ]; ccs.forEach((cs, index) => { connectValues({ primary: this.value, secondary: cs.value, forward: (p) => { return p.rawValue.getComponents(this.colorMode.rawValue)[index]; }, backward: (p, s) => { const pickedMode = this.colorMode.rawValue; const comps = p.rawValue.getComponents(pickedMode); comps[index] = s.rawValue; return new Color(appendAlphaComponent(removeAlphaComponent(comps), comps[3]), pickedMode); }, }); }); return ccs; } onModeSelectChange_(ev) { const selectElem = ev.currentTarget; this.colorMode.rawValue = selectElem.value; this.ccs_ = this.createComponentControllers_(this.view.element.ownerDocument); this.view.textViews = [ this.ccs_[0].view, this.ccs_[1].view, this.ccs_[2].view, ]; } } const className$8 = ClassName('hpl'); class HPaletteView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); this.value = config.value; this.value.emitter.on('change', this.onValueChange_); this.element = doc.createElement('div'); this.element.classList.add(className$8()); config.viewProps.bindTabIndex(this.element); const colorElem = doc.createElement('div'); colorElem.classList.add(className$8('c')); this.element.appendChild(colorElem); const markerElem = doc.createElement('div'); markerElem.classList.add(className$8('m')); this.element.appendChild(markerElem); this.markerElem_ = markerElem; this.update_(); } update_() { const c = this.value.rawValue; const [h] = c.getComponents('hsv'); this.markerElem_.style.backgroundColor = colorToFunctionalRgbString(new Color([h, 100, 100], 'hsv')); const left = mapRange(h, 0, 360, 0, 100); this.markerElem_.style.left = `${left}%`; } onValueChange_() { this.update_(); } } class HPaletteController { constructor(doc, config) { this.onKeyDown_ = this.onKeyDown_.bind(this); this.onKeyUp_ = this.onKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.view = new HPaletteView(doc, { value: this.value, viewProps: this.viewProps, }); this.ptHandler_ = new PointerHandler(this.view.element); this.ptHandler_.emitter.on('down', this.onPointerDown_); this.ptHandler_.emitter.on('move', this.onPointerMove_); this.ptHandler_.emitter.on('up', this.onPointerUp_); this.view.element.addEventListener('keydown', this.onKeyDown_); this.view.element.addEventListener('keyup', this.onKeyUp_); } handlePointerEvent_(d, opts) { if (!d.point) { return; } const hue = mapRange(d.point.x, 0, d.bounds.width, 0, 360); const c = this.value.rawValue; const [, s, v, a] = c.getComponents('hsv'); this.value.setRawValue(new Color([hue, s, v, a], 'hsv'), opts); } onPointerDown_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerMove_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: true, last: true, }); } onKeyDown_(ev) { const step = getStepForKey(getBaseStepForColor(false), getHorizontalStepKeys(ev)); if (step === 0) { return; } const c = this.value.rawValue; const [h, s, v, a] = c.getComponents('hsv'); this.value.setRawValue(new Color([h + step, s, v, a], 'hsv'), { forceEmit: false, last: false, }); } onKeyUp_(ev) { const step = getStepForKey(getBaseStepForColor(false), getHorizontalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } const className$7 = ClassName('svp'); const CANVAS_RESOL = 64; class SvPaletteView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); this.value = config.value; this.value.emitter.on('change', this.onValueChange_); this.element = doc.createElement('div'); this.element.classList.add(className$7()); config.viewProps.bindTabIndex(this.element); const canvasElem = doc.createElement('canvas'); canvasElem.height = CANVAS_RESOL; canvasElem.width = CANVAS_RESOL; canvasElem.classList.add(className$7('c')); this.element.appendChild(canvasElem); this.canvasElement = canvasElem; const markerElem = doc.createElement('div'); markerElem.classList.add(className$7('m')); this.element.appendChild(markerElem); this.markerElem_ = markerElem; this.update_(); } update_() { const ctx = getCanvasContext(this.canvasElement); if (!ctx) { return; } const c = this.value.rawValue; const hsvComps = c.getComponents('hsv'); const width = this.canvasElement.width; const height = this.canvasElement.height; const imgData = ctx.getImageData(0, 0, width, height); const data = imgData.data; for (let iy = 0; iy < height; iy++) { for (let ix = 0; ix < width; ix++) { const s = mapRange(ix, 0, width, 0, 100); const v = mapRange(iy, 0, height, 100, 0); const rgbComps = hsvToRgb(hsvComps[0], s, v); const i = (iy * width + ix) * 4; data[i] = rgbComps[0]; data[i + 1] = rgbComps[1]; data[i + 2] = rgbComps[2]; data[i + 3] = 255; } } ctx.putImageData(imgData, 0, 0); const left = mapRange(hsvComps[1], 0, 100, 0, 100); this.markerElem_.style.left = `${left}%`; const top = mapRange(hsvComps[2], 0, 100, 100, 0); this.markerElem_.style.top = `${top}%`; } onValueChange_() { this.update_(); } } class SvPaletteController { constructor(doc, config) { this.onKeyDown_ = this.onKeyDown_.bind(this); this.onKeyUp_ = this.onKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.view = new SvPaletteView(doc, { value: this.value, viewProps: this.viewProps, }); this.ptHandler_ = new PointerHandler(this.view.element); this.ptHandler_.emitter.on('down', this.onPointerDown_); this.ptHandler_.emitter.on('move', this.onPointerMove_); this.ptHandler_.emitter.on('up', this.onPointerUp_); this.view.element.addEventListener('keydown', this.onKeyDown_); this.view.element.addEventListener('keyup', this.onKeyUp_); } handlePointerEvent_(d, opts) { if (!d.point) { return; } const saturation = mapRange(d.point.x, 0, d.bounds.width, 0, 100); const value = mapRange(d.point.y, 0, d.bounds.height, 100, 0); const [h, , , a] = this.value.rawValue.getComponents('hsv'); this.value.setRawValue(new Color([h, saturation, value, a], 'hsv'), opts); } onPointerDown_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerMove_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: true, last: true, }); } onKeyDown_(ev) { if (isArrowKey(ev.key)) { ev.preventDefault(); } const [h, s, v, a] = this.value.rawValue.getComponents('hsv'); const baseStep = getBaseStepForColor(false); const ds = getStepForKey(baseStep, getHorizontalStepKeys(ev)); const dv = getStepForKey(baseStep, getVerticalStepKeys(ev)); if (ds === 0 && dv === 0) { return; } this.value.setRawValue(new Color([h, s + ds, v + dv, a], 'hsv'), { forceEmit: false, last: false, }); } onKeyUp_(ev) { const baseStep = getBaseStepForColor(false); const ds = getStepForKey(baseStep, getHorizontalStepKeys(ev)); const dv = getStepForKey(baseStep, getVerticalStepKeys(ev)); if (ds === 0 && dv === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } class ColorPickerController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.hPaletteC_ = new HPaletteController(doc, { value: this.value, viewProps: this.viewProps, }); this.svPaletteC_ = new SvPaletteController(doc, { value: this.value, viewProps: this.viewProps, }); this.alphaIcs_ = config.supportsAlpha ? { palette: new APaletteController(doc, { value: this.value, viewProps: this.viewProps, }), text: new NumberTextController(doc, { parser: parseNumber, baseStep: 0.1, props: ValueMap.fromObject({ draggingScale: 0.01, formatter: createNumberFormatter(2), }), value: createValue(0, { constraint: new RangeConstraint({ min: 0, max: 1 }), }), viewProps: this.viewProps, }), } : null; if (this.alphaIcs_) { connectValues({ primary: this.value, secondary: this.alphaIcs_.text.value, forward: (p) => { return p.rawValue.getComponents()[3]; }, backward: (p, s) => { const comps = p.rawValue.getComponents(); comps[3] = s.rawValue; return new Color(comps, p.rawValue.mode); }, }); } this.textC_ = new ColorTextController(doc, { parser: parseNumber, value: this.value, viewProps: this.viewProps, }); this.view = new ColorPickerView(doc, { alphaViews: this.alphaIcs_ ? { palette: this.alphaIcs_.palette.view, text: this.alphaIcs_.text.view, } : null, hPaletteView: this.hPaletteC_.view, supportsAlpha: config.supportsAlpha, svPaletteView: this.svPaletteC_.view, textView: this.textC_.view, }); } get textController() { return this.textC_; } } const className$6 = ClassName('colsw'); class ColorSwatchView { constructor(doc, config) { this.onValueChange_ = this.onValueChange_.bind(this); config.value.emitter.on('change', this.onValueChange_); this.value = config.value; this.element = doc.createElement('div'); this.element.classList.add(className$6()); config.viewProps.bindClassModifiers(this.element); const swatchElem = doc.createElement('div'); swatchElem.classList.add(className$6('sw')); this.element.appendChild(swatchElem); this.swatchElem_ = swatchElem; const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$6('b')); config.viewProps.bindDisabled(buttonElem); this.element.appendChild(buttonElem); this.buttonElement = buttonElem; this.update_(); } update_() { const value = this.value.rawValue; this.swatchElem_.style.backgroundColor = colorToHexRgbaString(value); } onValueChange_() { this.update_(); } } class ColorSwatchController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.view = new ColorSwatchView(doc, { value: this.value, viewProps: this.viewProps, }); } } class ColorController { constructor(doc, config) { this.onButtonBlur_ = this.onButtonBlur_.bind(this); this.onButtonClick_ = this.onButtonClick_.bind(this); this.onPopupChildBlur_ = this.onPopupChildBlur_.bind(this); this.onPopupChildKeydown_ = this.onPopupChildKeydown_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.foldable_ = Foldable.create(config.expanded); this.swatchC_ = new ColorSwatchController(doc, { value: this.value, viewProps: this.viewProps, }); const buttonElem = this.swatchC_.view.buttonElement; buttonElem.addEventListener('blur', this.onButtonBlur_); buttonElem.addEventListener('click', this.onButtonClick_); this.textC_ = new TextController(doc, { parser: config.parser, props: ValueMap.fromObject({ formatter: config.formatter, }), value: this.value, viewProps: this.viewProps, }); this.view = new ColorView(doc, { foldable: this.foldable_, pickerLayout: config.pickerLayout, }); this.view.swatchElement.appendChild(this.swatchC_.view.element); this.view.textElement.appendChild(this.textC_.view.element); this.popC_ = config.pickerLayout === 'popup' ? new PopupController(doc, { viewProps: this.viewProps, }) : null; const pickerC = new ColorPickerController(doc, { supportsAlpha: config.supportsAlpha, value: this.value, viewProps: this.viewProps, }); pickerC.view.allFocusableElements.forEach((elem) => { elem.addEventListener('blur', this.onPopupChildBlur_); elem.addEventListener('keydown', this.onPopupChildKeydown_); }); this.pickerC_ = pickerC; if (this.popC_) { this.view.element.appendChild(this.popC_.view.element); this.popC_.view.element.appendChild(pickerC.view.element); connectValues({ primary: this.foldable_.value('expanded'), secondary: this.popC_.shows, forward: (p) => p.rawValue, backward: (_, s) => s.rawValue, }); } else if (this.view.pickerElement) { this.view.pickerElement.appendChild(this.pickerC_.view.element); bindFoldable(this.foldable_, this.view.pickerElement); } } get textController() { return this.textC_; } onButtonBlur_(e) { if (!this.popC_) { return; } const elem = this.view.element; const nextTarget = forceCast(e.relatedTarget); if (!nextTarget || !elem.contains(nextTarget)) { this.popC_.shows.rawValue = false; } } onButtonClick_() { this.foldable_.set('expanded', !this.foldable_.get('expanded')); if (this.foldable_.get('expanded')) { this.pickerC_.view.allFocusableElements[0].focus(); } } onPopupChildBlur_(ev) { if (!this.popC_) { return; } const elem = this.popC_.view.element; const nextTarget = findNextTarget(ev); if (nextTarget && elem.contains(nextTarget)) { return; } if (nextTarget && nextTarget === this.swatchC_.view.buttonElement && !supportsTouch(elem.ownerDocument)) { return; } this.popC_.shows.rawValue = false; } onPopupChildKeydown_(ev) { if (this.popC_) { if (ev.key === 'Escape') { this.popC_.shows.rawValue = false; } } else if (this.view.pickerElement) { if (ev.key === 'Escape') { this.swatchC_.view.buttonElement.focus(); } } } } function colorFromObject(value) { if (Color.isColorObject(value)) { return Color.fromObject(value); } return Color.black(); } function colorToRgbNumber(value) { return removeAlphaComponent(value.getComponents('rgb')).reduce((result, comp) => { return (result << 8) | (Math.floor(comp) & 0xff); }, 0); } function colorToRgbaNumber(value) { return (value.getComponents('rgb').reduce((result, comp, index) => { const hex = Math.floor(index === 3 ? comp * 255 : comp) & 0xff; return (result << 8) | hex; }, 0) >>> 0); } function numberToRgbColor(num) { return new Color([(num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff], 'rgb'); } function numberToRgbaColor(num) { return new Color([ (num >> 24) & 0xff, (num >> 16) & 0xff, (num >> 8) & 0xff, mapRange(num & 0xff, 0, 255, 0, 1), ], 'rgb'); } function colorFromRgbNumber(value) { if (typeof value !== 'number') { return Color.black(); } return numberToRgbColor(value); } function colorFromRgbaNumber(value) { if (typeof value !== 'number') { return Color.black(); } return numberToRgbaColor(value); } function createColorStringWriter(notation) { const stringify = getColorStringifier(notation); return (target, value) => { writePrimitive(target, stringify(value)); }; } function createColorNumberWriter(supportsAlpha) { const colorToNumber = supportsAlpha ? colorToRgbaNumber : colorToRgbNumber; return (target, value) => { writePrimitive(target, colorToNumber(value)); }; } function writeRgbaColorObject(target, value) { const obj = value.toRgbaObject(); target.writeProperty('r', obj.r); target.writeProperty('g', obj.g); target.writeProperty('b', obj.b); target.writeProperty('a', obj.a); } function writeRgbColorObject(target, value) { const obj = value.toRgbaObject(); target.writeProperty('r', obj.r); target.writeProperty('g', obj.g); target.writeProperty('b', obj.b); } function createColorObjectWriter(supportsAlpha) { return supportsAlpha ? writeRgbaColorObject : writeRgbColorObject; } function shouldSupportAlpha$1(inputParams) { return 'alpha' in inputParams && inputParams.alpha === true; } function createFormatter$1(supportsAlpha) { return supportsAlpha ? (v) => colorToHexRgbaString(v, '0x') : (v) => colorToHexRgbString(v, '0x'); } const NumberColorInputPlugin = { id: 'input-color-number', type: 'input', accept: (value, params) => { if (typeof value !== 'number') { return null; } if (!('view' in params)) { return null; } if (params.view !== 'color') { return null; } const result = parseColorInputParams(params); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (args) => { return shouldSupportAlpha$1(args.params) ? colorFromRgbaNumber : colorFromRgbNumber; }, equals: Color.equals, writer: (args) => { return createColorNumberWriter(shouldSupportAlpha$1(args.params)); }, }, controller: (args) => { const supportsAlpha = shouldSupportAlpha$1(args.params); const expanded = 'expanded' in args.params ? args.params.expanded : undefined; const picker = 'picker' in args.params ? args.params.picker : undefined; return new ColorController(args.document, { expanded: expanded !== null && expanded !== void 0 ? expanded : false, formatter: createFormatter$1(supportsAlpha), parser: CompositeColorParser, pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup', supportsAlpha: supportsAlpha, value: args.value, viewProps: args.viewProps, }); }, }; function shouldSupportAlpha(initialValue) { return Color.isRgbaColorObject(initialValue); } const ObjectColorInputPlugin = { id: 'input-color-object', type: 'input', accept: (value, params) => { if (!Color.isColorObject(value)) { return null; } const result = parseColorInputParams(params); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => colorFromObject, equals: Color.equals, writer: (args) => createColorObjectWriter(shouldSupportAlpha(args.initialValue)), }, controller: (args) => { const supportsAlpha = Color.isRgbaColorObject(args.initialValue); const expanded = 'expanded' in args.params ? args.params.expanded : undefined; const picker = 'picker' in args.params ? args.params.picker : undefined; const formatter = supportsAlpha ? colorToHexRgbaString : colorToHexRgbString; return new ColorController(args.document, { expanded: expanded !== null && expanded !== void 0 ? expanded : false, formatter: formatter, parser: CompositeColorParser, pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup', supportsAlpha: supportsAlpha, value: args.value, viewProps: args.viewProps, }); }, }; const StringColorInputPlugin = { id: 'input-color-string', type: 'input', accept: (value, params) => { if (typeof value !== 'string') { return null; } if ('view' in params && params.view === 'text') { return null; } const notation = getColorNotation(value); if (!notation) { return null; } const result = parseColorInputParams(params); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => colorFromString, equals: Color.equals, writer: (args) => { const notation = getColorNotation(args.initialValue); if (!notation) { throw TpError.shouldNeverHappen(); } return createColorStringWriter(notation); }, }, controller: (args) => { const notation = getColorNotation(args.initialValue); if (!notation) { throw TpError.shouldNeverHappen(); } const stringifier = getColorStringifier(notation); const expanded = 'expanded' in args.params ? args.params.expanded : undefined; const picker = 'picker' in args.params ? args.params.picker : undefined; return new ColorController(args.document, { expanded: expanded !== null && expanded !== void 0 ? expanded : false, formatter: stringifier, parser: CompositeColorParser, pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup', supportsAlpha: hasAlphaComponent(notation), value: args.value, viewProps: args.viewProps, }); }, }; class PointNdConstraint { constructor(config) { this.components = config.components; this.asm_ = config.assembly; } constrain(value) { const comps = this.asm_ .toComponents(value) .map((comp, index) => { var _a, _b; return (_b = (_a = this.components[index]) === null || _a === void 0 ? void 0 : _a.constrain(comp)) !== null && _b !== void 0 ? _b : comp; }); return this.asm_.fromComponents(comps); } } const className$5 = ClassName('pndtxt'); class PointNdTextView { constructor(doc, config) { this.textViews = config.textViews; this.element = doc.createElement('div'); this.element.classList.add(className$5()); this.textViews.forEach((v) => { const axisElem = doc.createElement('div'); axisElem.classList.add(className$5('a')); axisElem.appendChild(v.element); this.element.appendChild(axisElem); }); } } function createAxisController(doc, config, index) { return new NumberTextController(doc, { arrayPosition: index === 0 ? 'fst' : index === config.axes.length - 1 ? 'lst' : 'mid', baseStep: config.axes[index].baseStep, parser: config.parser, props: config.axes[index].textProps, value: createValue(0, { constraint: config.axes[index].constraint, }), viewProps: config.viewProps, }); } class PointNdTextController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.acs_ = config.axes.map((_, index) => createAxisController(doc, config, index)); this.acs_.forEach((c, index) => { connectValues({ primary: this.value, secondary: c.value, forward: (p) => { return config.assembly.toComponents(p.rawValue)[index]; }, backward: (p, s) => { const comps = config.assembly.toComponents(p.rawValue); comps[index] = s.rawValue; return config.assembly.fromComponents(comps); }, }); }); this.view = new PointNdTextView(doc, { textViews: this.acs_.map((ac) => ac.view), }); } } function createStepConstraint(params) { if ('step' in params && !isEmpty(params.step)) { return new StepConstraint(params.step); } return null; } function createRangeConstraint(params) { if (('max' in params && !isEmpty(params.max)) || ('min' in params && !isEmpty(params.min))) { return new RangeConstraint({ max: params.max, min: params.min, }); } return null; } function createConstraint$4(params) { const constraints = []; const sc = createStepConstraint(params); if (sc) { constraints.push(sc); } const rc = createRangeConstraint(params); if (rc) { constraints.push(rc); } const lc = createListConstraint(params.options); if (lc) { constraints.push(lc); } return new CompositeConstraint(constraints); } function findRange(constraint) { const c = constraint ? findConstraint(constraint, RangeConstraint) : null; if (!c) { return [undefined, undefined]; } return [c.minValue, c.maxValue]; } function estimateSuitableRange(constraint) { const [min, max] = findRange(constraint); return [min !== null && min !== void 0 ? min : 0, max !== null && max !== void 0 ? max : 100]; } const NumberInputPlugin = { id: 'input-number', type: 'input', accept: (value, params) => { if (typeof value !== 'number') { return null; } const p = ParamsParsers; const result = parseParams(params, { format: p.optional.function, max: p.optional.number, min: p.optional.number, options: p.optional.custom(parseListOptions), step: p.optional.number, }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => numberFromUnknown, constraint: (args) => createConstraint$4(args.params), writer: (_args) => writePrimitive, }, controller: (args) => { var _a, _b; const value = args.value; const c = args.constraint; if (c && findConstraint(c, ListConstraint)) { return new ListController(args.document, { props: ValueMap.fromObject({ options: (_a = findListItems(c)) !== null && _a !== void 0 ? _a : [], }), value: value, viewProps: args.viewProps, }); } const formatter = (_b = ('format' in args.params ? args.params.format : undefined)) !== null && _b !== void 0 ? _b : createNumberFormatter(getSuitableDecimalDigits(c, value.rawValue)); if (c && findConstraint(c, RangeConstraint)) { const [min, max] = estimateSuitableRange(c); return new SliderTextController(args.document, { baseStep: getBaseStep(c), parser: parseNumber, sliderProps: ValueMap.fromObject({ maxValue: max, minValue: min, }), textProps: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(c, value.rawValue), formatter: formatter, }), value: value, viewProps: args.viewProps, }); } return new NumberTextController(args.document, { baseStep: getBaseStep(c), parser: parseNumber, props: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(c, value.rawValue), formatter: formatter, }), value: value, viewProps: args.viewProps, }); }, }; class Point2d { constructor(x = 0, y = 0) { this.x = x; this.y = y; } getComponents() { return [this.x, this.y]; } static isObject(obj) { if (isEmpty(obj)) { return false; } const x = obj.x; const y = obj.y; if (typeof x !== 'number' || typeof y !== 'number') { return false; } return true; } static equals(v1, v2) { return v1.x === v2.x && v1.y === v2.y; } toObject() { return { x: this.x, y: this.y, }; } } const Point2dAssembly = { toComponents: (p) => p.getComponents(), fromComponents: (comps) => new Point2d(...comps), }; const className$4 = ClassName('p2d'); class Point2dView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$4()); config.viewProps.bindClassModifiers(this.element); bindValue(config.expanded, valueToClassName(this.element, className$4(undefined, 'expanded'))); const headElem = doc.createElement('div'); headElem.classList.add(className$4('h')); this.element.appendChild(headElem); const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$4('b')); buttonElem.appendChild(createSvgIconElement(doc, 'p2dpad')); config.viewProps.bindDisabled(buttonElem); headElem.appendChild(buttonElem); this.buttonElement = buttonElem; const textElem = doc.createElement('div'); textElem.classList.add(className$4('t')); headElem.appendChild(textElem); this.textElement = textElem; if (config.pickerLayout === 'inline') { const pickerElem = doc.createElement('div'); pickerElem.classList.add(className$4('p')); this.element.appendChild(pickerElem); this.pickerElement = pickerElem; } else { this.pickerElement = null; } } } const className$3 = ClassName('p2dp'); class Point2dPickerView { constructor(doc, config) { this.onFoldableChange_ = this.onFoldableChange_.bind(this); this.onValueChange_ = this.onValueChange_.bind(this); this.invertsY_ = config.invertsY; this.maxValue_ = config.maxValue; this.element = doc.createElement('div'); this.element.classList.add(className$3()); if (config.layout === 'popup') { this.element.classList.add(className$3(undefined, 'p')); } const padElem = doc.createElement('div'); padElem.classList.add(className$3('p')); config.viewProps.bindTabIndex(padElem); this.element.appendChild(padElem); this.padElement = padElem; const svgElem = doc.createElementNS(SVG_NS, 'svg'); svgElem.classList.add(className$3('g')); this.padElement.appendChild(svgElem); this.svgElem_ = svgElem; const xAxisElem = doc.createElementNS(SVG_NS, 'line'); xAxisElem.classList.add(className$3('ax')); xAxisElem.setAttributeNS(null, 'x1', '0'); xAxisElem.setAttributeNS(null, 'y1', '50%'); xAxisElem.setAttributeNS(null, 'x2', '100%'); xAxisElem.setAttributeNS(null, 'y2', '50%'); this.svgElem_.appendChild(xAxisElem); const yAxisElem = doc.createElementNS(SVG_NS, 'line'); yAxisElem.classList.add(className$3('ax')); yAxisElem.setAttributeNS(null, 'x1', '50%'); yAxisElem.setAttributeNS(null, 'y1', '0'); yAxisElem.setAttributeNS(null, 'x2', '50%'); yAxisElem.setAttributeNS(null, 'y2', '100%'); this.svgElem_.appendChild(yAxisElem); const lineElem = doc.createElementNS(SVG_NS, 'line'); lineElem.classList.add(className$3('l')); lineElem.setAttributeNS(null, 'x1', '50%'); lineElem.setAttributeNS(null, 'y1', '50%'); this.svgElem_.appendChild(lineElem); this.lineElem_ = lineElem; const markerElem = doc.createElement('div'); markerElem.classList.add(className$3('m')); this.padElement.appendChild(markerElem); this.markerElem_ = markerElem; config.value.emitter.on('change', this.onValueChange_); this.value = config.value; this.update_(); } get allFocusableElements() { return [this.padElement]; } update_() { const [x, y] = this.value.rawValue.getComponents(); const max = this.maxValue_; const px = mapRange(x, -max, +max, 0, 100); const py = mapRange(y, -max, +max, 0, 100); const ipy = this.invertsY_ ? 100 - py : py; this.lineElem_.setAttributeNS(null, 'x2', `${px}%`); this.lineElem_.setAttributeNS(null, 'y2', `${ipy}%`); this.markerElem_.style.left = `${px}%`; this.markerElem_.style.top = `${ipy}%`; } onValueChange_() { this.update_(); } onFoldableChange_() { this.update_(); } } function computeOffset(ev, baseSteps, invertsY) { return [ getStepForKey(baseSteps[0], getHorizontalStepKeys(ev)), getStepForKey(baseSteps[1], getVerticalStepKeys(ev)) * (invertsY ? 1 : -1), ]; } class Point2dPickerController { constructor(doc, config) { this.onPadKeyDown_ = this.onPadKeyDown_.bind(this); this.onPadKeyUp_ = this.onPadKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.baseSteps_ = config.baseSteps; this.maxValue_ = config.maxValue; this.invertsY_ = config.invertsY; this.view = new Point2dPickerView(doc, { invertsY: this.invertsY_, layout: config.layout, maxValue: this.maxValue_, value: this.value, viewProps: this.viewProps, }); this.ptHandler_ = new PointerHandler(this.view.padElement); this.ptHandler_.emitter.on('down', this.onPointerDown_); this.ptHandler_.emitter.on('move', this.onPointerMove_); this.ptHandler_.emitter.on('up', this.onPointerUp_); this.view.padElement.addEventListener('keydown', this.onPadKeyDown_); this.view.padElement.addEventListener('keyup', this.onPadKeyUp_); } handlePointerEvent_(d, opts) { if (!d.point) { return; } const max = this.maxValue_; const px = mapRange(d.point.x, 0, d.bounds.width, -max, +max); const py = mapRange(this.invertsY_ ? d.bounds.height - d.point.y : d.point.y, 0, d.bounds.height, -max, +max); this.value.setRawValue(new Point2d(px, py), opts); } onPointerDown_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerMove_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.handlePointerEvent_(ev.data, { forceEmit: true, last: true, }); } onPadKeyDown_(ev) { if (isArrowKey(ev.key)) { ev.preventDefault(); } const [dx, dy] = computeOffset(ev, this.baseSteps_, this.invertsY_); if (dx === 0 && dy === 0) { return; } this.value.setRawValue(new Point2d(this.value.rawValue.x + dx, this.value.rawValue.y + dy), { forceEmit: false, last: false, }); } onPadKeyUp_(ev) { const [dx, dy] = computeOffset(ev, this.baseSteps_, this.invertsY_); if (dx === 0 && dy === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } class Point2dController { constructor(doc, config) { var _a, _b; this.onPopupChildBlur_ = this.onPopupChildBlur_.bind(this); this.onPopupChildKeydown_ = this.onPopupChildKeydown_.bind(this); this.onPadButtonBlur_ = this.onPadButtonBlur_.bind(this); this.onPadButtonClick_ = this.onPadButtonClick_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.foldable_ = Foldable.create(config.expanded); this.popC_ = config.pickerLayout === 'popup' ? new PopupController(doc, { viewProps: this.viewProps, }) : null; const padC = new Point2dPickerController(doc, { baseSteps: [config.axes[0].baseStep, config.axes[1].baseStep], invertsY: config.invertsY, layout: config.pickerLayout, maxValue: config.maxValue, value: this.value, viewProps: this.viewProps, }); padC.view.allFocusableElements.forEach((elem) => { elem.addEventListener('blur', this.onPopupChildBlur_); elem.addEventListener('keydown', this.onPopupChildKeydown_); }); this.pickerC_ = padC; this.textC_ = new PointNdTextController(doc, { assembly: Point2dAssembly, axes: config.axes, parser: config.parser, value: this.value, viewProps: this.viewProps, }); this.view = new Point2dView(doc, { expanded: this.foldable_.value('expanded'), pickerLayout: config.pickerLayout, viewProps: this.viewProps, }); this.view.textElement.appendChild(this.textC_.view.element); (_a = this.view.buttonElement) === null || _a === void 0 ? void 0 : _a.addEventListener('blur', this.onPadButtonBlur_); (_b = this.view.buttonElement) === null || _b === void 0 ? void 0 : _b.addEventListener('click', this.onPadButtonClick_); if (this.popC_) { this.view.element.appendChild(this.popC_.view.element); this.popC_.view.element.appendChild(this.pickerC_.view.element); connectValues({ primary: this.foldable_.value('expanded'), secondary: this.popC_.shows, forward: (p) => p.rawValue, backward: (_, s) => s.rawValue, }); } else if (this.view.pickerElement) { this.view.pickerElement.appendChild(this.pickerC_.view.element); bindFoldable(this.foldable_, this.view.pickerElement); } } onPadButtonBlur_(e) { if (!this.popC_) { return; } const elem = this.view.element; const nextTarget = forceCast(e.relatedTarget); if (!nextTarget || !elem.contains(nextTarget)) { this.popC_.shows.rawValue = false; } } onPadButtonClick_() { this.foldable_.set('expanded', !this.foldable_.get('expanded')); if (this.foldable_.get('expanded')) { this.pickerC_.view.allFocusableElements[0].focus(); } } onPopupChildBlur_(ev) { if (!this.popC_) { return; } const elem = this.popC_.view.element; const nextTarget = findNextTarget(ev); if (nextTarget && elem.contains(nextTarget)) { return; } if (nextTarget && nextTarget === this.view.buttonElement && !supportsTouch(elem.ownerDocument)) { return; } this.popC_.shows.rawValue = false; } onPopupChildKeydown_(ev) { if (this.popC_) { if (ev.key === 'Escape') { this.popC_.shows.rawValue = false; } } else if (this.view.pickerElement) { if (ev.key === 'Escape') { this.view.buttonElement.focus(); } } } } function point2dFromUnknown(value) { return Point2d.isObject(value) ? new Point2d(value.x, value.y) : new Point2d(); } function writePoint2d(target, value) { target.writeProperty('x', value.x); target.writeProperty('y', value.y); } function createDimensionConstraint$2(params) { if (!params) { return undefined; } const constraints = []; if (!isEmpty(params.step)) { constraints.push(new StepConstraint(params.step)); } if (!isEmpty(params.max) || !isEmpty(params.min)) { constraints.push(new RangeConstraint({ max: params.max, min: params.min, })); } return new CompositeConstraint(constraints); } function createConstraint$3(params) { return new PointNdConstraint({ assembly: Point2dAssembly, components: [ createDimensionConstraint$2('x' in params ? params.x : undefined), createDimensionConstraint$2('y' in params ? params.y : undefined), ], }); } function getSuitableMaxDimensionValue(constraint, rawValue) { const rc = constraint && findConstraint(constraint, RangeConstraint); if (rc) { return Math.max(Math.abs(rc.minValue || 0), Math.abs(rc.maxValue || 0)); } const step = getBaseStep(constraint); return Math.max(Math.abs(step) * 10, Math.abs(rawValue) * 10); } function getSuitableMaxValue(initialValue, constraint) { const xc = constraint instanceof PointNdConstraint ? constraint.components[0] : undefined; const yc = constraint instanceof PointNdConstraint ? constraint.components[1] : undefined; const xr = getSuitableMaxDimensionValue(xc, initialValue.x); const yr = getSuitableMaxDimensionValue(yc, initialValue.y); return Math.max(xr, yr); } function createAxis$2(initialValue, constraint) { return { baseStep: getBaseStep(constraint), constraint: constraint, textProps: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(constraint, initialValue), formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue)), }), }; } function shouldInvertY(params) { if (!('y' in params)) { return false; } const yParams = params.y; if (!yParams) { return false; } return 'inverted' in yParams ? !!yParams.inverted : false; } const Point2dInputPlugin = { id: 'input-point2d', type: 'input', accept: (value, params) => { if (!Point2d.isObject(value)) { return null; } const p = ParamsParsers; const result = parseParams(params, { expanded: p.optional.boolean, picker: p.optional.custom(parsePickerLayout), x: p.optional.custom(parsePointDimensionParams), y: p.optional.object({ inverted: p.optional.boolean, max: p.optional.number, min: p.optional.number, step: p.optional.number, }), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => point2dFromUnknown, constraint: (args) => createConstraint$3(args.params), equals: Point2d.equals, writer: (_args) => writePoint2d, }, controller: (args) => { const doc = args.document; const value = args.value; const c = args.constraint; if (!(c instanceof PointNdConstraint)) { throw TpError.shouldNeverHappen(); } const expanded = 'expanded' in args.params ? args.params.expanded : undefined; const picker = 'picker' in args.params ? args.params.picker : undefined; return new Point2dController(doc, { axes: [ createAxis$2(value.rawValue.x, c.components[0]), createAxis$2(value.rawValue.y, c.components[1]), ], expanded: expanded !== null && expanded !== void 0 ? expanded : false, invertsY: shouldInvertY(args.params), maxValue: getSuitableMaxValue(value.rawValue, c), parser: parseNumber, pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup', value: value, viewProps: args.viewProps, }); }, }; class Point3d { constructor(x = 0, y = 0, z = 0) { this.x = x; this.y = y; this.z = z; } getComponents() { return [this.x, this.y, this.z]; } static isObject(obj) { if (isEmpty(obj)) { return false; } const x = obj.x; const y = obj.y; const z = obj.z; if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number') { return false; } return true; } static equals(v1, v2) { return v1.x === v2.x && v1.y === v2.y && v1.z === v2.z; } toObject() { return { x: this.x, y: this.y, z: this.z, }; } } const Point3dAssembly = { toComponents: (p) => p.getComponents(), fromComponents: (comps) => new Point3d(...comps), }; function point3dFromUnknown(value) { return Point3d.isObject(value) ? new Point3d(value.x, value.y, value.z) : new Point3d(); } function writePoint3d(target, value) { target.writeProperty('x', value.x); target.writeProperty('y', value.y); target.writeProperty('z', value.z); } function createDimensionConstraint$1(params) { if (!params) { return undefined; } const constraints = []; if (!isEmpty(params.step)) { constraints.push(new StepConstraint(params.step)); } if (!isEmpty(params.max) || !isEmpty(params.min)) { constraints.push(new RangeConstraint({ max: params.max, min: params.min, })); } return new CompositeConstraint(constraints); } function createConstraint$2(params) { return new PointNdConstraint({ assembly: Point3dAssembly, components: [ createDimensionConstraint$1('x' in params ? params.x : undefined), createDimensionConstraint$1('y' in params ? params.y : undefined), createDimensionConstraint$1('z' in params ? params.z : undefined), ], }); } function createAxis$1(initialValue, constraint) { return { baseStep: getBaseStep(constraint), constraint: constraint, textProps: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(constraint, initialValue), formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue)), }), }; } const Point3dInputPlugin = { id: 'input-point3d', type: 'input', accept: (value, params) => { if (!Point3d.isObject(value)) { return null; } const p = ParamsParsers; const result = parseParams(params, { x: p.optional.custom(parsePointDimensionParams), y: p.optional.custom(parsePointDimensionParams), z: p.optional.custom(parsePointDimensionParams), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => point3dFromUnknown, constraint: (args) => createConstraint$2(args.params), equals: Point3d.equals, writer: (_args) => writePoint3d, }, controller: (args) => { const value = args.value; const c = args.constraint; if (!(c instanceof PointNdConstraint)) { throw TpError.shouldNeverHappen(); } return new PointNdTextController(args.document, { assembly: Point3dAssembly, axes: [ createAxis$1(value.rawValue.x, c.components[0]), createAxis$1(value.rawValue.y, c.components[1]), createAxis$1(value.rawValue.z, c.components[2]), ], parser: parseNumber, value: value, viewProps: args.viewProps, }); }, }; class Point4d { constructor(x = 0, y = 0, z = 0, w = 0) { this.x = x; this.y = y; this.z = z; this.w = w; } getComponents() { return [this.x, this.y, this.z, this.w]; } static isObject(obj) { if (isEmpty(obj)) { return false; } const x = obj.x; const y = obj.y; const z = obj.z; const w = obj.w; if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number' || typeof w !== 'number') { return false; } return true; } static equals(v1, v2) { return v1.x === v2.x && v1.y === v2.y && v1.z === v2.z && v1.w === v2.w; } toObject() { return { x: this.x, y: this.y, z: this.z, w: this.w, }; } } const Point4dAssembly = { toComponents: (p) => p.getComponents(), fromComponents: (comps) => new Point4d(...comps), }; function point4dFromUnknown(value) { return Point4d.isObject(value) ? new Point4d(value.x, value.y, value.z, value.w) : new Point4d(); } function writePoint4d(target, value) { target.writeProperty('x', value.x); target.writeProperty('y', value.y); target.writeProperty('z', value.z); target.writeProperty('w', value.w); } function createDimensionConstraint(params) { if (!params) { return undefined; } const constraints = []; if (!isEmpty(params.step)) { constraints.push(new StepConstraint(params.step)); } if (!isEmpty(params.max) || !isEmpty(params.min)) { constraints.push(new RangeConstraint({ max: params.max, min: params.min, })); } return new CompositeConstraint(constraints); } function createConstraint$1(params) { return new PointNdConstraint({ assembly: Point4dAssembly, components: [ createDimensionConstraint('x' in params ? params.x : undefined), createDimensionConstraint('y' in params ? params.y : undefined), createDimensionConstraint('z' in params ? params.z : undefined), createDimensionConstraint('w' in params ? params.w : undefined), ], }); } function createAxis(initialValue, constraint) { return { baseStep: getBaseStep(constraint), constraint: constraint, textProps: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(constraint, initialValue), formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue)), }), }; } const Point4dInputPlugin = { id: 'input-point4d', type: 'input', accept: (value, params) => { if (!Point4d.isObject(value)) { return null; } const p = ParamsParsers; const result = parseParams(params, { x: p.optional.custom(parsePointDimensionParams), y: p.optional.custom(parsePointDimensionParams), z: p.optional.custom(parsePointDimensionParams), w: p.optional.custom(parsePointDimensionParams), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => point4dFromUnknown, constraint: (args) => createConstraint$1(args.params), equals: Point4d.equals, writer: (_args) => writePoint4d, }, controller: (args) => { const value = args.value; const c = args.constraint; if (!(c instanceof PointNdConstraint)) { throw TpError.shouldNeverHappen(); } return new PointNdTextController(args.document, { assembly: Point4dAssembly, axes: value.rawValue .getComponents() .map((comp, index) => createAxis(comp, c.components[index])), parser: parseNumber, value: value, viewProps: args.viewProps, }); }, }; function createConstraint(params) { const constraints = []; const lc = createListConstraint(params.options); if (lc) { constraints.push(lc); } return new CompositeConstraint(constraints); } const StringInputPlugin = { id: 'input-string', type: 'input', accept: (value, params) => { if (typeof value !== 'string') { return null; } const p = ParamsParsers; const result = parseParams(params, { options: p.optional.custom(parseListOptions), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => stringFromUnknown, constraint: (args) => createConstraint(args.params), writer: (_args) => writePrimitive, }, controller: (args) => { var _a; const doc = args.document; const value = args.value; const c = args.constraint; if (c && findConstraint(c, ListConstraint)) { return new ListController(doc, { props: ValueMap.fromObject({ options: (_a = findListItems(c)) !== null && _a !== void 0 ? _a : [], }), value: value, viewProps: args.viewProps, }); } return new TextController(doc, { parser: (v) => v, props: ValueMap.fromObject({ formatter: formatString, }), value: value, viewProps: args.viewProps, }); }, }; const Constants = { monitor: { defaultInterval: 200, defaultLineCount: 3, }, }; const className$2 = ClassName('mll'); class MultiLogView { constructor(doc, config) { this.onValueUpdate_ = this.onValueUpdate_.bind(this); this.formatter_ = config.formatter; this.element = doc.createElement('div'); this.element.classList.add(className$2()); config.viewProps.bindClassModifiers(this.element); const textareaElem = doc.createElement('textarea'); textareaElem.classList.add(className$2('i')); textareaElem.style.height = `calc(var(--bld-us) * ${config.lineCount})`; textareaElem.readOnly = true; config.viewProps.bindDisabled(textareaElem); this.element.appendChild(textareaElem); this.textareaElem_ = textareaElem; config.value.emitter.on('change', this.onValueUpdate_); this.value = config.value; this.update_(); } update_() { const elem = this.textareaElem_; const shouldScroll = elem.scrollTop === elem.scrollHeight - elem.clientHeight; const lines = []; this.value.rawValue.forEach((value) => { if (value !== undefined) { lines.push(this.formatter_(value)); } }); elem.textContent = lines.join('\n'); if (shouldScroll) { elem.scrollTop = elem.scrollHeight; } } onValueUpdate_() { this.update_(); } } class MultiLogController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.view = new MultiLogView(doc, { formatter: config.formatter, lineCount: config.lineCount, value: this.value, viewProps: this.viewProps, }); } } const className$1 = ClassName('sgl'); class SingleLogView { constructor(doc, config) { this.onValueUpdate_ = this.onValueUpdate_.bind(this); this.formatter_ = config.formatter; this.element = doc.createElement('div'); this.element.classList.add(className$1()); config.viewProps.bindClassModifiers(this.element); const inputElem = doc.createElement('input'); inputElem.classList.add(className$1('i')); inputElem.readOnly = true; inputElem.type = 'text'; config.viewProps.bindDisabled(inputElem); this.element.appendChild(inputElem); this.inputElement = inputElem; config.value.emitter.on('change', this.onValueUpdate_); this.value = config.value; this.update_(); } update_() { const values = this.value.rawValue; const lastValue = values[values.length - 1]; this.inputElement.value = lastValue !== undefined ? this.formatter_(lastValue) : ''; } onValueUpdate_() { this.update_(); } } class SingleLogController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.view = new SingleLogView(doc, { formatter: config.formatter, value: this.value, viewProps: this.viewProps, }); } } const BooleanMonitorPlugin = { id: 'monitor-bool', type: 'monitor', accept: (value, params) => { if (typeof value !== 'boolean') { return null; } const p = ParamsParsers; const result = parseParams(params, { lineCount: p.optional.number, }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => boolFromUnknown, }, controller: (args) => { var _a; if (args.value.rawValue.length === 1) { return new SingleLogController(args.document, { formatter: BooleanFormatter, value: args.value, viewProps: args.viewProps, }); } return new MultiLogController(args.document, { formatter: BooleanFormatter, lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount, value: args.value, viewProps: args.viewProps, }); }, }; class GraphCursor { constructor() { this.emitter = new Emitter(); this.index_ = -1; } get index() { return this.index_; } set index(index) { const changed = this.index_ !== index; if (changed) { this.index_ = index; this.emitter.emit('change', { index: index, sender: this, }); } } } const className = ClassName('grl'); class GraphLogView { constructor(doc, config) { this.onCursorChange_ = this.onCursorChange_.bind(this); this.onValueUpdate_ = this.onValueUpdate_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className()); config.viewProps.bindClassModifiers(this.element); this.formatter_ = config.formatter; this.minValue_ = config.minValue; this.maxValue_ = config.maxValue; this.cursor_ = config.cursor; this.cursor_.emitter.on('change', this.onCursorChange_); const svgElem = doc.createElementNS(SVG_NS, 'svg'); svgElem.classList.add(className('g')); svgElem.style.height = `calc(var(--bld-us) * ${config.lineCount})`; this.element.appendChild(svgElem); this.svgElem_ = svgElem; const lineElem = doc.createElementNS(SVG_NS, 'polyline'); this.svgElem_.appendChild(lineElem); this.lineElem_ = lineElem; const tooltipElem = doc.createElement('div'); tooltipElem.classList.add(className('t'), ClassName('tt')()); this.element.appendChild(tooltipElem); this.tooltipElem_ = tooltipElem; config.value.emitter.on('change', this.onValueUpdate_); this.value = config.value; this.update_(); } get graphElement() { return this.svgElem_; } update_() { const bounds = this.svgElem_.getBoundingClientRect(); const maxIndex = this.value.rawValue.length - 1; const min = this.minValue_; const max = this.maxValue_; const points = []; this.value.rawValue.forEach((v, index) => { if (v === undefined) { return; } const x = mapRange(index, 0, maxIndex, 0, bounds.width); const y = mapRange(v, min, max, bounds.height, 0); points.push([x, y].join(',')); }); this.lineElem_.setAttributeNS(null, 'points', points.join(' ')); const tooltipElem = this.tooltipElem_; const value = this.value.rawValue[this.cursor_.index]; if (value === undefined) { tooltipElem.classList.remove(className('t', 'a')); return; } const tx = mapRange(this.cursor_.index, 0, maxIndex, 0, bounds.width); const ty = mapRange(value, min, max, bounds.height, 0); tooltipElem.style.left = `${tx}px`; tooltipElem.style.top = `${ty}px`; tooltipElem.textContent = `${this.formatter_(value)}`; if (!tooltipElem.classList.contains(className('t', 'a'))) { tooltipElem.classList.add(className('t', 'a'), className('t', 'in')); forceReflow(tooltipElem); tooltipElem.classList.remove(className('t', 'in')); } } onValueUpdate_() { this.update_(); } onCursorChange_() { this.update_(); } } class GraphLogController { constructor(doc, config) { this.onGraphMouseMove_ = this.onGraphMouseMove_.bind(this); this.onGraphMouseLeave_ = this.onGraphMouseLeave_.bind(this); this.onGraphPointerDown_ = this.onGraphPointerDown_.bind(this); this.onGraphPointerMove_ = this.onGraphPointerMove_.bind(this); this.onGraphPointerUp_ = this.onGraphPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.cursor_ = new GraphCursor(); this.view = new GraphLogView(doc, { cursor: this.cursor_, formatter: config.formatter, lineCount: config.lineCount, maxValue: config.maxValue, minValue: config.minValue, value: this.value, viewProps: this.viewProps, }); if (!supportsTouch(doc)) { this.view.element.addEventListener('mousemove', this.onGraphMouseMove_); this.view.element.addEventListener('mouseleave', this.onGraphMouseLeave_); } else { const ph = new PointerHandler(this.view.element); ph.emitter.on('down', this.onGraphPointerDown_); ph.emitter.on('move', this.onGraphPointerMove_); ph.emitter.on('up', this.onGraphPointerUp_); } } onGraphMouseLeave_() { this.cursor_.index = -1; } onGraphMouseMove_(ev) { const bounds = this.view.element.getBoundingClientRect(); this.cursor_.index = Math.floor(mapRange(ev.offsetX, 0, bounds.width, 0, this.value.rawValue.length)); } onGraphPointerDown_(ev) { this.onGraphPointerMove_(ev); } onGraphPointerMove_(ev) { if (!ev.data.point) { this.cursor_.index = -1; return; } this.cursor_.index = Math.floor(mapRange(ev.data.point.x, 0, ev.data.bounds.width, 0, this.value.rawValue.length)); } onGraphPointerUp_() { this.cursor_.index = -1; } } function createFormatter(params) { return 'format' in params && !isEmpty(params.format) ? params.format : createNumberFormatter(2); } function createTextMonitor(args) { var _a; if (args.value.rawValue.length === 1) { return new SingleLogController(args.document, { formatter: createFormatter(args.params), value: args.value, viewProps: args.viewProps, }); } return new MultiLogController(args.document, { formatter: createFormatter(args.params), lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount, value: args.value, viewProps: args.viewProps, }); } function createGraphMonitor(args) { var _a, _b, _c; return new GraphLogController(args.document, { formatter: createFormatter(args.params), lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount, maxValue: (_b = ('max' in args.params ? args.params.max : null)) !== null && _b !== void 0 ? _b : 100, minValue: (_c = ('min' in args.params ? args.params.min : null)) !== null && _c !== void 0 ? _c : 0, value: args.value, viewProps: args.viewProps, }); } function shouldShowGraph(params) { return 'view' in params && params.view === 'graph'; } const NumberMonitorPlugin = { id: 'monitor-number', type: 'monitor', accept: (value, params) => { if (typeof value !== 'number') { return null; } const p = ParamsParsers; const result = parseParams(params, { format: p.optional.function, lineCount: p.optional.number, max: p.optional.number, min: p.optional.number, view: p.optional.string, }); return result ? { initialValue: value, params: result, } : null; }, binding: { defaultBufferSize: (params) => (shouldShowGraph(params) ? 64 : 1), reader: (_args) => numberFromUnknown, }, controller: (args) => { if (shouldShowGraph(args.params)) { return createGraphMonitor(args); } return createTextMonitor(args); }, }; const StringMonitorPlugin = { id: 'monitor-string', type: 'monitor', accept: (value, params) => { if (typeof value !== 'string') { return null; } const p = ParamsParsers; const result = parseParams(params, { lineCount: p.optional.number, multiline: p.optional.boolean, }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => stringFromUnknown, }, controller: (args) => { var _a; const value = args.value; const multiline = value.rawValue.length > 1 || ('multiline' in args.params && args.params.multiline); if (multiline) { return new MultiLogController(args.document, { formatter: formatString, lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount, value: value, viewProps: args.viewProps, }); } return new SingleLogController(args.document, { formatter: formatString, value: value, viewProps: args.viewProps, }); }, }; class InputBinding { constructor(config) { this.onValueChange_ = this.onValueChange_.bind(this); this.reader = config.reader; this.writer = config.writer; this.emitter = new Emitter(); this.value = config.value; this.value.emitter.on('change', this.onValueChange_); this.target = config.target; this.read(); } read() { const targetValue = this.target.read(); if (targetValue !== undefined) { this.value.rawValue = this.reader(targetValue); } } write_(rawValue) { this.writer(this.target, rawValue); } onValueChange_(ev) { this.write_(ev.rawValue); this.emitter.emit('change', { options: ev.options, rawValue: ev.rawValue, sender: this, }); } } function createInputBindingController(plugin, args) { const result = plugin.accept(args.target.read(), args.params); if (isEmpty(result)) { return null; } const p = ParamsParsers; const valueArgs = { target: args.target, initialValue: result.initialValue, params: result.params, }; const reader = plugin.binding.reader(valueArgs); const constraint = plugin.binding.constraint ? plugin.binding.constraint(valueArgs) : undefined; const value = createValue(reader(result.initialValue), { constraint: constraint, equals: plugin.binding.equals, }); const binding = new InputBinding({ reader: reader, target: args.target, value: value, writer: plugin.binding.writer(valueArgs), }); const disabled = p.optional.boolean(args.params.disabled).value; const hidden = p.optional.boolean(args.params.hidden).value; const controller = plugin.controller({ constraint: constraint, document: args.document, initialValue: result.initialValue, params: result.params, value: binding.value, viewProps: ViewProps.create({ disabled: disabled, hidden: hidden, }), }); const label = p.optional.string(args.params.label).value; return new InputBindingController(args.document, { binding: binding, blade: createBlade(), props: ValueMap.fromObject({ label: label || args.target.key, }), valueController: controller, }); } class MonitorBinding { constructor(config) { this.onTick_ = this.onTick_.bind(this); this.reader_ = config.reader; this.target = config.target; this.emitter = new Emitter(); this.value = config.value; this.ticker = config.ticker; this.ticker.emitter.on('tick', this.onTick_); this.read(); } dispose() { this.ticker.dispose(); } read() { const targetValue = this.target.read(); if (targetValue === undefined) { return; } const buffer = this.value.rawValue; const newValue = this.reader_(targetValue); this.value.rawValue = createPushedBuffer(buffer, newValue); this.emitter.emit('update', { rawValue: newValue, sender: this, }); } onTick_(_) { this.read(); } } function createTicker(document, interval) { return interval === 0 ? new ManualTicker() : new IntervalTicker(document, interval !== null && interval !== void 0 ? interval : Constants.monitor.defaultInterval); } function createMonitorBindingController(plugin, args) { var _a, _b, _c; const P = ParamsParsers; const result = plugin.accept(args.target.read(), args.params); if (isEmpty(result)) { return null; } const bindingArgs = { target: args.target, initialValue: result.initialValue, params: result.params, }; const reader = plugin.binding.reader(bindingArgs); const bufferSize = (_b = (_a = P.optional.number(args.params.bufferSize).value) !== null && _a !== void 0 ? _a : (plugin.binding.defaultBufferSize && plugin.binding.defaultBufferSize(result.params))) !== null && _b !== void 0 ? _b : 1; const interval = P.optional.number(args.params.interval).value; const binding = new MonitorBinding({ reader: reader, target: args.target, ticker: createTicker(args.document, interval), value: initializeBuffer(bufferSize), }); const disabled = P.optional.boolean(args.params.disabled).value; const hidden = P.optional.boolean(args.params.hidden).value; const controller = plugin.controller({ document: args.document, params: result.params, value: binding.value, viewProps: ViewProps.create({ disabled: disabled, hidden: hidden, }), }); const label = (_c = P.optional.string(args.params.label).value) !== null && _c !== void 0 ? _c : args.target.key; return new MonitorBindingController(args.document, { binding: binding, blade: createBlade(), props: ValueMap.fromObject({ label: label, }), valueController: controller, }); } class PluginPool { constructor() { this.pluginsMap_ = { blades: [], inputs: [], monitors: [], }; } getAll() { return [ ...this.pluginsMap_.blades, ...this.pluginsMap_.inputs, ...this.pluginsMap_.monitors, ]; } register(r) { if (r.type === 'blade') { this.pluginsMap_.blades.unshift(r); } else if (r.type === 'input') { this.pluginsMap_.inputs.unshift(r); } else if (r.type === 'monitor') { this.pluginsMap_.monitors.unshift(r); } } createInput(document, target, params) { const initialValue = target.read(); if (isEmpty(initialValue)) { throw new TpError({ context: { key: target.key, }, type: 'nomatchingcontroller', }); } const bc = this.pluginsMap_.inputs.reduce((result, plugin) => result || createInputBindingController(plugin, { document: document, target: target, params: params, }), null); if (bc) { return bc; } throw new TpError({ context: { key: target.key, }, type: 'nomatchingcontroller', }); } createMonitor(document, target, params) { const bc = this.pluginsMap_.monitors.reduce((result, plugin) => result || createMonitorBindingController(plugin, { document: document, params: params, target: target, }), null); if (bc) { return bc; } throw new TpError({ context: { key: target.key, }, type: 'nomatchingcontroller', }); } createBlade(document, params) { const bc = this.pluginsMap_.blades.reduce((result, plugin) => result || createBladeController(plugin, { document: document, params: params, }), null); if (!bc) { throw new TpError({ type: 'nomatchingview', context: { params: params, }, }); } return bc; } createBladeApi(bc) { if (bc instanceof InputBindingController) { return new InputBindingApi(bc); } if (bc instanceof MonitorBindingController) { return new MonitorBindingApi(bc); } if (bc instanceof RackController) { return new RackApi(bc, this); } const api = this.pluginsMap_.blades.reduce((result, plugin) => result || plugin.api({ controller: bc, pool: this, }), null); if (!api) { throw TpError.shouldNeverHappen(); } return api; } } function createDefaultPluginPool() { const pool = new PluginPool(); [ Point2dInputPlugin, Point3dInputPlugin, Point4dInputPlugin, StringInputPlugin, NumberInputPlugin, StringColorInputPlugin, ObjectColorInputPlugin, NumberColorInputPlugin, BooleanInputPlugin, BooleanMonitorPlugin, StringMonitorPlugin, NumberMonitorPlugin, ButtonBladePlugin, FolderBladePlugin, SeparatorBladePlugin, TabBladePlugin, ].forEach((p) => { pool.register(p); }); return pool; } class ListApi extends BladeApi { constructor(controller) { super(controller); this.emitter_ = new Emitter(); this.controller_.valueController.value.emitter.on('change', (ev) => { this.emitter_.emit('change', { event: new TpChangeEvent(this, ev.rawValue), }); }); } get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } get options() { return this.controller_.valueController.props.get('options'); } set options(options) { this.controller_.valueController.props.set('options', options); } get value() { return this.controller_.valueController.value.rawValue; } set value(value) { this.controller_.valueController.value.rawValue = value; } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } } class SliderApi extends BladeApi { constructor(controller) { super(controller); this.emitter_ = new Emitter(); this.controller_.valueController.value.emitter.on('change', (ev) => { this.emitter_.emit('change', { event: new TpChangeEvent(this, ev.rawValue), }); }); } get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } get maxValue() { return this.controller_.valueController.sliderController.props.get('maxValue'); } set maxValue(maxValue) { this.controller_.valueController.sliderController.props.set('maxValue', maxValue); } get minValue() { return this.controller_.valueController.sliderController.props.get('minValue'); } set minValue(minValue) { this.controller_.valueController.sliderController.props.set('minValue', minValue); } get value() { return this.controller_.valueController.value.rawValue; } set value(value) { this.controller_.valueController.value.rawValue = value; } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } } class TextApi extends BladeApi { constructor(controller) { super(controller); this.emitter_ = new Emitter(); this.controller_.valueController.value.emitter.on('change', (ev) => { this.emitter_.emit('change', { event: new TpChangeEvent(this, ev.rawValue), }); }); } get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } get formatter() { return this.controller_.valueController.props.get('formatter'); } set formatter(formatter) { this.controller_.valueController.props.set('formatter', formatter); } get value() { return this.controller_.valueController.value.rawValue; } set value(value) { this.controller_.valueController.value.rawValue = value; } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } } const ListBladePlugin = (function () { return { id: 'list', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { options: p.required.custom(parseListOptions), value: p.required.raw, view: p.required.constant('list'), label: p.optional.string, }); return result ? { params: result } : null; }, controller(args) { const ic = new ListController(args.document, { props: ValueMap.fromObject({ options: normalizeListOptions(args.params.options), }), value: createValue(args.params.value), viewProps: args.viewProps, }); return new LabeledValueController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: ic, }); }, api(args) { if (!(args.controller instanceof LabeledValueController)) { return null; } if (!(args.controller.valueController instanceof ListController)) { return null; } return new ListApi(args.controller); }, }; })(); /** * @hidden */ function exportPresetJson(targets) { return targets.reduce((result, target) => { return Object.assign(result, { [target.presetKey]: target.read(), }); }, {}); } /** * @hidden */ function importPresetJson(targets, preset) { targets.forEach((target) => { const value = preset[target.presetKey]; if (value !== undefined) { target.write(value); } }); } class RootApi extends FolderApi { /** * @hidden */ constructor(controller, pool) { super(controller, pool); } get element() { return this.controller_.view.element; } /** * Imports a preset of all inputs. * @param preset The preset object to import. */ importPreset(preset) { const targets = this.controller_.rackController.rack .find(InputBindingController) .map((ibc) => { return ibc.binding.target; }); importPresetJson(targets, preset); this.refresh(); } /** * Exports a preset of all inputs. * @return An exported preset object. */ exportPreset() { const targets = this.controller_.rackController.rack .find(InputBindingController) .map((ibc) => { return ibc.binding.target; }); return exportPresetJson(targets); } /** * Refreshes all bindings of the pane. */ refresh() { // Force-read all input bindings this.controller_.rackController.rack .find(InputBindingController) .forEach((ibc) => { ibc.binding.read(); }); // Force-read all monitor bindings this.controller_.rackController.rack .find(MonitorBindingController) .forEach((mbc) => { mbc.binding.read(); }); } } class RootController extends FolderController { constructor(doc, config) { super(doc, { expanded: config.expanded, blade: config.blade, props: config.props, root: true, viewProps: config.viewProps, }); } } const SliderBladePlugin = { id: 'slider', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { max: p.required.number, min: p.required.number, view: p.required.constant('slider'), format: p.optional.function, label: p.optional.string, value: p.optional.number, }); return result ? { params: result } : null; }, controller(args) { var _a, _b; const v = (_a = args.params.value) !== null && _a !== void 0 ? _a : 0; const vc = new SliderTextController(args.document, { baseStep: 1, parser: parseNumber, sliderProps: ValueMap.fromObject({ maxValue: args.params.max, minValue: args.params.min, }), textProps: ValueMap.fromObject({ draggingScale: getSuitableDraggingScale(undefined, v), formatter: (_b = args.params.format) !== null && _b !== void 0 ? _b : numberToString, }), value: createValue(v), viewProps: args.viewProps, }); return new LabeledValueController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: vc, }); }, api(args) { if (!(args.controller instanceof LabeledValueController)) { return null; } if (!(args.controller.valueController instanceof SliderTextController)) { return null; } return new SliderApi(args.controller); }, }; const TextBladePlugin = (function () { return { id: 'text', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { parse: p.required.function, value: p.required.raw, view: p.required.constant('text'), format: p.optional.function, label: p.optional.string, }); return result ? { params: result } : null; }, controller(args) { var _a; const ic = new TextController(args.document, { parser: args.params.parse, props: ValueMap.fromObject({ formatter: (_a = args.params.format) !== null && _a !== void 0 ? _a : ((v) => String(v)), }), value: createValue(args.params.value), viewProps: args.viewProps, }); return new LabeledValueController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: ic, }); }, api(args) { if (!(args.controller instanceof LabeledValueController)) { return null; } if (!(args.controller.valueController instanceof TextController)) { return null; } return new TextApi(args.controller); }, }; })(); function createDefaultWrapperElement(doc) { const elem = doc.createElement('div'); elem.classList.add(ClassName('dfw')()); if (doc.body) { doc.body.appendChild(elem); } return elem; } function embedStyle(doc, id, css) { if (doc.querySelector(`style[data-tp-style=${id}]`)) { return; } const styleElem = doc.createElement('style'); styleElem.dataset.tpStyle = id; styleElem.textContent = css; doc.head.appendChild(styleElem); } /** * The root pane of Tweakpane. */ class Pane extends RootApi { constructor(opt_config) { var _a; const config = opt_config || {}; const doc = (_a = config.document) !== null && _a !== void 0 ? _a : getWindowDocument(); const pool = createDefaultPluginPool(); const rootController = new RootController(doc, { expanded: config.expanded, blade: createBlade(), props: ValueMap.fromObject({ title: config.title, }), viewProps: ViewProps.create(), }); super(rootController, pool); this.pool_ = pool; this.containerElem_ = config.container || createDefaultWrapperElement(doc); this.containerElem_.appendChild(this.element); this.doc_ = doc; this.usesDefaultWrapper_ = !config.container; this.setUpDefaultPlugins_(); } get document() { if (!this.doc_) { throw TpError.alreadyDisposed(); } return this.doc_; } dispose() { const containerElem = this.containerElem_; if (!containerElem) { throw TpError.alreadyDisposed(); } if (this.usesDefaultWrapper_) { const parentElem = containerElem.parentElement; if (parentElem) { parentElem.removeChild(containerElem); } } this.containerElem_ = null; this.doc_ = null; super.dispose(); } registerPlugin(bundle) { const plugins = 'plugin' in bundle ? [bundle.plugin] : 'plugins' in bundle ? bundle.plugins : []; plugins.forEach((p) => { this.pool_.register(p); this.embedPluginStyle_(p); }); } embedPluginStyle_(plugin) { if (plugin.css) { embedStyle(this.document, `plugin-${plugin.id}`, plugin.css); } } setUpDefaultPlugins_() { // NOTE: This string literal will be replaced with the default CSS by Rollup at the compilation time embedStyle(this.document, 'default', '.tp-lstv_s,.tp-btnv_b,.tp-p2dv_b,.tp-colswv_sw,.tp-p2dpv_p,.tp-txtv_i,.tp-grlv_g,.tp-sglv_i,.tp-mllv_i,.tp-fldv_b,.tp-rotv_b,.tp-ckbv_i,.tp-coltxtv_ms,.tp-tbiv_b{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border-width:0;font-family:inherit;font-size:inherit;font-weight:inherit;margin:0;outline:none;padding:0}.tp-lstv_s,.tp-btnv_b,.tp-p2dv_b{background-color:var(--btn-bg);border-radius:var(--elm-br);color:var(--btn-fg);cursor:pointer;display:block;font-weight:bold;height:var(--bld-us);line-height:var(--bld-us);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tp-lstv_s:hover,.tp-btnv_b:hover,.tp-p2dv_b:hover{background-color:var(--btn-bg-h)}.tp-lstv_s:focus,.tp-btnv_b:focus,.tp-p2dv_b:focus{background-color:var(--btn-bg-f)}.tp-lstv_s:active,.tp-btnv_b:active,.tp-p2dv_b:active{background-color:var(--btn-bg-a)}.tp-lstv_s:disabled,.tp-btnv_b:disabled,.tp-p2dv_b:disabled{opacity:0.5}.tp-colswv_sw,.tp-p2dpv_p,.tp-txtv_i{background-color:var(--in-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--in-fg);font-family:inherit;height:var(--bld-us);line-height:var(--bld-us);min-width:0;width:100%}.tp-colswv_sw:hover,.tp-p2dpv_p:hover,.tp-txtv_i:hover{background-color:var(--in-bg-h)}.tp-colswv_sw:focus,.tp-p2dpv_p:focus,.tp-txtv_i:focus{background-color:var(--in-bg-f)}.tp-colswv_sw:active,.tp-p2dpv_p:active,.tp-txtv_i:active{background-color:var(--in-bg-a)}.tp-colswv_sw:disabled,.tp-p2dpv_p:disabled,.tp-txtv_i:disabled{opacity:0.5}.tp-grlv_g,.tp-sglv_i,.tp-mllv_i{background-color:var(--mo-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--mo-fg);height:var(--bld-us);width:100%}.tp-rotv{--font-family: var(--tp-font-family, Roboto Mono,Source Code Pro,Menlo,Courier,monospace);--bs-br: var(--tp-base-border-radius, 6px);--cnt-h-p: var(--tp-container-horizontal-padding, 4px);--cnt-v-p: var(--tp-container-vertical-padding, 4px);--elm-br: var(--tp-element-border-radius, 2px);--bld-s: var(--tp-blade-spacing, 4px);--bld-us: var(--tp-blade-unit-size, 20px);--bs-bg: var(--tp-base-background-color, #2f3137);--bs-sh: var(--tp-base-shadow-color, rgba(0,0,0,0.2));--btn-bg: var(--tp-button-background-color, #adafb8);--btn-bg-a: var(--tp-button-background-color-active, #d6d7db);--btn-bg-f: var(--tp-button-background-color-focus, #c8cad0);--btn-bg-h: var(--tp-button-background-color-hover, #bbbcc4);--btn-fg: var(--tp-button-foreground-color, #2f3137);--cnt-bg: var(--tp-container-background-color, rgba(187,188,196,0.1));--cnt-bg-a: var(--tp-container-background-color-active, rgba(187,188,196,0.25));--cnt-bg-f: var(--tp-container-background-color-focus, rgba(187,188,196,0.2));--cnt-bg-h: var(--tp-container-background-color-hover, rgba(187,188,196,0.15));--cnt-fg: var(--tp-container-foreground-color, #bbbcc4);--in-bg: var(--tp-input-background-color, rgba(0,0,0,0.2));--in-bg-a: var(--tp-input-background-color-active, rgba(0,0,0,0.35));--in-bg-f: var(--tp-input-background-color-focus, rgba(0,0,0,0.3));--in-bg-h: var(--tp-input-background-color-hover, rgba(0,0,0,0.25));--in-fg: var(--tp-input-foreground-color, #bbbcc4);--lbl-fg: var(--tp-label-foreground-color, rgba(187,188,196,0.7));--mo-bg: var(--tp-monitor-background-color, rgba(0,0,0,0.2));--mo-fg: var(--tp-monitor-foreground-color, rgba(187,188,196,0.7));--grv-fg: var(--tp-groove-foreground-color, rgba(0,0,0,0.2))}.tp-fldv_c>.tp-cntv.tp-v-lst,.tp-tabv_c .tp-brkv>.tp-cntv.tp-v-lst,.tp-rotv_c>.tp-cntv.tp-v-lst{margin-bottom:calc(-1 * var(--cnt-v-p))}.tp-fldv_c>.tp-fldv.tp-v-lst .tp-fldv_c,.tp-tabv_c .tp-brkv>.tp-fldv.tp-v-lst .tp-fldv_c,.tp-rotv_c>.tp-fldv.tp-v-lst .tp-fldv_c{border-bottom-left-radius:0}.tp-fldv_c>.tp-fldv.tp-v-lst .tp-fldv_b,.tp-tabv_c .tp-brkv>.tp-fldv.tp-v-lst .tp-fldv_b,.tp-rotv_c>.tp-fldv.tp-v-lst .tp-fldv_b{border-bottom-left-radius:0}.tp-fldv_c>*:not(.tp-v-fst),.tp-tabv_c .tp-brkv>*:not(.tp-v-fst),.tp-rotv_c>*:not(.tp-v-fst){margin-top:var(--bld-s)}.tp-fldv_c>.tp-sprv:not(.tp-v-fst),.tp-tabv_c .tp-brkv>.tp-sprv:not(.tp-v-fst),.tp-rotv_c>.tp-sprv:not(.tp-v-fst),.tp-fldv_c>.tp-cntv:not(.tp-v-fst),.tp-tabv_c .tp-brkv>.tp-cntv:not(.tp-v-fst),.tp-rotv_c>.tp-cntv:not(.tp-v-fst){margin-top:var(--cnt-v-p)}.tp-fldv_c>.tp-sprv+*:not(.tp-v-hidden),.tp-tabv_c .tp-brkv>.tp-sprv+*:not(.tp-v-hidden),.tp-rotv_c>.tp-sprv+*:not(.tp-v-hidden),.tp-fldv_c>.tp-cntv+*:not(.tp-v-hidden),.tp-tabv_c .tp-brkv>.tp-cntv+*:not(.tp-v-hidden),.tp-rotv_c>.tp-cntv+*:not(.tp-v-hidden){margin-top:var(--cnt-v-p)}.tp-fldv_c>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-tabv_c .tp-brkv>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-rotv_c>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-fldv_c>.tp-cntv:not(.tp-v-hidden)+.tp-cntv,.tp-tabv_c .tp-brkv>.tp-cntv:not(.tp-v-hidden)+.tp-cntv,.tp-rotv_c>.tp-cntv:not(.tp-v-hidden)+.tp-cntv{margin-top:0}.tp-fldv_c>.tp-cntv,.tp-tabv_c .tp-brkv>.tp-cntv{margin-left:4px}.tp-fldv_c>.tp-fldv>.tp-fldv_b,.tp-tabv_c .tp-brkv>.tp-fldv>.tp-fldv_b{border-top-left-radius:var(--elm-br);border-bottom-left-radius:var(--elm-br)}.tp-fldv_c>.tp-fldv.tp-fldv-expanded>.tp-fldv_b,.tp-tabv_c .tp-brkv>.tp-fldv.tp-fldv-expanded>.tp-fldv_b{border-bottom-left-radius:0}.tp-fldv_c .tp-fldv>.tp-fldv_c,.tp-tabv_c .tp-brkv .tp-fldv>.tp-fldv_c{border-bottom-left-radius:var(--elm-br)}.tp-fldv_c>.tp-tabv>.tp-tabv_i,.tp-tabv_c .tp-brkv>.tp-tabv>.tp-tabv_i{border-top-left-radius:var(--elm-br)}.tp-fldv_c .tp-tabv>.tp-tabv_c,.tp-tabv_c .tp-brkv .tp-tabv>.tp-tabv_c{border-bottom-left-radius:var(--elm-br)}.tp-fldv_b,.tp-rotv_b{background-color:var(--cnt-bg);color:var(--cnt-fg);cursor:pointer;display:block;height:calc(var(--bld-us) + 4px);line-height:calc(var(--bld-us) + 4px);overflow:hidden;padding-left:calc(var(--cnt-h-p) + 8px);padding-right:calc(2px * 2 + var(--bld-us) + var(--cnt-h-p));position:relative;text-align:left;text-overflow:ellipsis;white-space:nowrap;width:100%;transition:border-radius .2s ease-in-out .2s}.tp-fldv_b:hover,.tp-rotv_b:hover{background-color:var(--cnt-bg-h)}.tp-fldv_b:focus,.tp-rotv_b:focus{background-color:var(--cnt-bg-f)}.tp-fldv_b:active,.tp-rotv_b:active{background-color:var(--cnt-bg-a)}.tp-fldv_b:disabled,.tp-rotv_b:disabled{opacity:0.5}.tp-fldv_m,.tp-rotv_m{background:linear-gradient(to left, var(--cnt-fg), var(--cnt-fg) 2px, transparent 2px, transparent 4px, var(--cnt-fg) 4px);border-radius:2px;bottom:0;content:\'\';display:block;height:6px;right:calc(var(--cnt-h-p) + (var(--bld-us) + 4px - 6px) / 2 - 2px);margin:auto;opacity:0.5;position:absolute;top:0;transform:rotate(90deg);transition:transform .2s ease-in-out;width:6px}.tp-fldv.tp-fldv-expanded>.tp-fldv_b>.tp-fldv_m,.tp-rotv.tp-rotv-expanded .tp-rotv_m{transform:none}.tp-fldv_c,.tp-rotv_c{box-sizing:border-box;height:0;opacity:0;overflow:hidden;padding-bottom:0;padding-top:0;position:relative;transition:height .2s ease-in-out,opacity .2s linear,padding .2s ease-in-out}.tp-fldv.tp-fldv-cpl:not(.tp-fldv-expanded)>.tp-fldv_c,.tp-rotv.tp-rotv-cpl:not(.tp-rotv-expanded) .tp-rotv_c{display:none}.tp-fldv.tp-fldv-expanded>.tp-fldv_c,.tp-rotv.tp-rotv-expanded .tp-rotv_c{opacity:1;padding-bottom:var(--cnt-v-p);padding-top:var(--cnt-v-p);transform:none;overflow:visible;transition:height .2s ease-in-out,opacity .2s linear .2s,padding .2s ease-in-out}.tp-coltxtv_m,.tp-lstv{position:relative}.tp-lstv_s{padding:0 20px 0 4px;width:100%}.tp-coltxtv_mm,.tp-lstv_m{bottom:0;margin:auto;pointer-events:none;position:absolute;right:2px;top:0}.tp-coltxtv_mm svg,.tp-lstv_m svg{bottom:0;height:16px;margin:auto;position:absolute;right:0;top:0;width:16px}.tp-coltxtv_mm svg path,.tp-lstv_m svg path{fill:currentColor}.tp-coltxtv_w,.tp-pndtxtv{display:flex}.tp-coltxtv_c,.tp-pndtxtv_a{width:100%}.tp-coltxtv_c+.tp-coltxtv_c,.tp-pndtxtv_a+.tp-coltxtv_c,.tp-coltxtv_c+.tp-pndtxtv_a,.tp-pndtxtv_a+.tp-pndtxtv_a{margin-left:2px}.tp-btnv_b{width:100%}.tp-btnv_t{text-align:center}.tp-ckbv_l{display:block;position:relative}.tp-ckbv_i{left:0;opacity:0;position:absolute;top:0}.tp-ckbv_w{background-color:var(--in-bg);border-radius:var(--elm-br);cursor:pointer;display:block;height:var(--bld-us);position:relative;width:var(--bld-us)}.tp-ckbv_w svg{bottom:0;display:block;height:16px;left:0;margin:auto;opacity:0;position:absolute;right:0;top:0;width:16px}.tp-ckbv_w svg path{fill:none;stroke:var(--in-fg);stroke-width:2}.tp-ckbv_i:hover+.tp-ckbv_w{background-color:var(--in-bg-h)}.tp-ckbv_i:focus+.tp-ckbv_w{background-color:var(--in-bg-f)}.tp-ckbv_i:active+.tp-ckbv_w{background-color:var(--in-bg-a)}.tp-ckbv_i:checked+.tp-ckbv_w svg{opacity:1}.tp-ckbv.tp-v-disabled .tp-ckbv_w{opacity:0.5}.tp-colv{position:relative}.tp-colv_h{display:flex}.tp-colv_s{flex-grow:0;flex-shrink:0;width:var(--bld-us)}.tp-colv_t{flex:1;margin-left:4px}.tp-colv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-colv.tp-colv-cpl .tp-colv_p{overflow:visible}.tp-colv.tp-colv-expanded .tp-colv_p{margin-top:var(--bld-s);opacity:1}.tp-colv .tp-popv{left:calc(-1 * var(--cnt-h-p));right:calc(-1 * var(--cnt-h-p));top:var(--bld-us)}.tp-colpv_h,.tp-colpv_ap{margin-left:6px;margin-right:6px}.tp-colpv_h{margin-top:var(--bld-s)}.tp-colpv_rgb{display:flex;margin-top:var(--bld-s);width:100%}.tp-colpv_a{display:flex;margin-top:var(--cnt-v-p);padding-top:calc(var(--cnt-v-p) + 2px);position:relative}.tp-colpv_a:before{background-color:var(--grv-fg);content:\'\';height:2px;left:calc(-1 * var(--cnt-h-p));position:absolute;right:calc(-1 * var(--cnt-h-p));top:0}.tp-colpv_ap{align-items:center;display:flex;flex:3}.tp-colpv_at{flex:1;margin-left:4px}.tp-svpv{border-radius:var(--elm-br);outline:none;overflow:hidden;position:relative}.tp-svpv_c{cursor:crosshair;display:block;height:calc(var(--bld-us) * 4);width:100%}.tp-svpv_m{border-radius:100%;border:rgba(255,255,255,0.75) solid 2px;box-sizing:border-box;filter:drop-shadow(0 0 1px rgba(0,0,0,0.3));height:12px;margin-left:-6px;margin-top:-6px;pointer-events:none;position:absolute;width:12px}.tp-svpv:focus .tp-svpv_m{border-color:#fff}.tp-hplv{cursor:pointer;height:var(--bld-us);outline:none;position:relative}.tp-hplv_c{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAABCAYAAABubagXAAAAQ0lEQVQoU2P8z8Dwn0GCgQEDi2OK/RBgYHjBgIpfovFh8j8YBIgzFGQxuqEgPhaDOT5gOhPkdCxOZeBg+IDFZZiGAgCaSSMYtcRHLgAAAABJRU5ErkJggg==);background-position:left top;background-repeat:no-repeat;background-size:100% 100%;border-radius:2px;display:block;height:4px;left:0;margin-top:-2px;position:absolute;top:50%;width:100%}.tp-hplv_m{border-radius:var(--elm-br);border:rgba(255,255,255,0.75) solid 2px;box-shadow:0 0 2px rgba(0,0,0,0.1);box-sizing:border-box;height:12px;left:50%;margin-left:-6px;margin-top:-6px;pointer-events:none;position:absolute;top:50%;width:12px}.tp-hplv:focus .tp-hplv_m{border-color:#fff}.tp-aplv{cursor:pointer;height:var(--bld-us);outline:none;position:relative;width:100%}.tp-aplv_b{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:4px 4px;background-position:0 0,2px 2px;border-radius:2px;display:block;height:4px;left:0;margin-top:-2px;overflow:hidden;position:absolute;top:50%;width:100%}.tp-aplv_c{bottom:0;left:0;position:absolute;right:0;top:0}.tp-aplv_m{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:12px 12px;background-position:0 0,6px 6px;border-radius:var(--elm-br);box-shadow:0 0 2px rgba(0,0,0,0.1);height:12px;left:50%;margin-left:-6px;margin-top:-6px;overflow:hidden;pointer-events:none;position:absolute;top:50%;width:12px}.tp-aplv_p{border-radius:var(--elm-br);border:rgba(255,255,255,0.75) solid 2px;box-sizing:border-box;bottom:0;left:0;position:absolute;right:0;top:0}.tp-aplv:focus .tp-aplv_p{border-color:#fff}.tp-colswv{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:10px 10px;background-position:0 0,5px 5px;border-radius:var(--elm-br)}.tp-colswv.tp-v-disabled{opacity:0.5}.tp-colswv_b{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border-width:0;cursor:pointer;display:block;height:var(--bld-us);left:0;margin:0;outline:none;padding:0;position:absolute;top:0;width:var(--bld-us)}.tp-colswv_b:focus::after{border:rgba(255,255,255,0.75) solid 2px;border-radius:var(--elm-br);bottom:0;content:\'\';display:block;left:0;position:absolute;right:0;top:0}.tp-coltxtv{display:flex;width:100%}.tp-coltxtv_m{margin-right:4px}.tp-coltxtv_ms{border-radius:var(--elm-br);color:var(--lbl-fg);cursor:pointer;height:var(--bld-us);line-height:var(--bld-us);padding:0 18px 0 4px}.tp-coltxtv_ms:hover{background-color:var(--in-bg-h)}.tp-coltxtv_ms:focus{background-color:var(--in-bg-f)}.tp-coltxtv_ms:active{background-color:var(--in-bg-a)}.tp-coltxtv_mm{color:var(--lbl-fg)}.tp-coltxtv_w{flex:1}.tp-dfwv{position:absolute;top:8px;right:8px;width:256px}.tp-fldv.tp-fldv-not .tp-fldv_b{display:none}.tp-fldv_c{border-left:var(--cnt-bg) solid 4px}.tp-fldv_b:hover+.tp-fldv_c{border-left-color:var(--cnt-bg-h)}.tp-fldv_b:focus+.tp-fldv_c{border-left-color:var(--cnt-bg-f)}.tp-fldv_b:active+.tp-fldv_c{border-left-color:var(--cnt-bg-a)}.tp-grlv{position:relative}.tp-grlv_g{display:block;height:calc(var(--bld-us) * 3)}.tp-grlv_g polyline{fill:none;stroke:var(--mo-fg);stroke-linejoin:round}.tp-grlv_t{margin-top:-4px;transition:left 0.05s, top 0.05s;visibility:hidden}.tp-grlv_t.tp-grlv_t-a{visibility:visible}.tp-grlv_t.tp-grlv_t-in{transition:none}.tp-grlv.tp-v-disabled .tp-grlv_g{opacity:0.5}.tp-grlv .tp-ttv{background-color:var(--mo-fg)}.tp-grlv .tp-ttv::before{border-top-color:var(--mo-fg)}.tp-lblv{align-items:center;display:flex;line-height:1.3;padding-left:var(--cnt-h-p);padding-right:var(--cnt-h-p)}.tp-lblv.tp-lblv-nol{display:block}.tp-lblv_l{color:var(--lbl-fg);flex:1;-webkit-hyphens:auto;-ms-hyphens:auto;hyphens:auto;overflow:hidden;padding-left:4px;padding-right:16px}.tp-lblv.tp-v-disabled .tp-lblv_l{opacity:0.5}.tp-lblv.tp-lblv-nol .tp-lblv_l{display:none}.tp-lblv_v{align-self:flex-start;flex-grow:0;flex-shrink:0;width:160px}.tp-lblv.tp-lblv-nol .tp-lblv_v{width:100%}.tp-lstv_s{padding:0 20px 0 4px;width:100%}.tp-lstv_m{color:var(--btn-fg)}.tp-sglv_i{padding:0 4px}.tp-sglv.tp-v-disabled .tp-sglv_i{opacity:0.5}.tp-mllv_i{display:block;height:calc(var(--bld-us) * 3);line-height:var(--bld-us);padding:0 4px;resize:none;white-space:pre}.tp-mllv.tp-v-disabled .tp-mllv_i{opacity:0.5}.tp-p2dv{position:relative}.tp-p2dv_h{display:flex}.tp-p2dv_b{height:var(--bld-us);margin-right:4px;position:relative;width:var(--bld-us)}.tp-p2dv_b svg{display:block;height:16px;left:50%;margin-left:-8px;margin-top:-8px;position:absolute;top:50%;width:16px}.tp-p2dv_b svg path{stroke:currentColor;stroke-width:2}.tp-p2dv_b svg circle{fill:currentColor}.tp-p2dv_t{flex:1}.tp-p2dv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-p2dv.tp-p2dv-expanded .tp-p2dv_p{margin-top:var(--bld-s);opacity:1}.tp-p2dv .tp-popv{left:calc(-1 * var(--cnt-h-p));right:calc(-1 * var(--cnt-h-p));top:var(--bld-us)}.tp-p2dpv{padding-left:calc(var(--bld-us) + 4px)}.tp-p2dpv_p{cursor:crosshair;height:0;overflow:hidden;padding-bottom:100%;position:relative}.tp-p2dpv_g{display:block;height:100%;left:0;pointer-events:none;position:absolute;top:0;width:100%}.tp-p2dpv_ax{opacity:0.1;stroke:var(--in-fg);stroke-dasharray:1}.tp-p2dpv_l{opacity:0.5;stroke:var(--in-fg);stroke-dasharray:1}.tp-p2dpv_m{border:var(--in-fg) solid 1px;border-radius:50%;box-sizing:border-box;height:4px;margin-left:-2px;margin-top:-2px;position:absolute;width:4px}.tp-p2dpv_p:focus .tp-p2dpv_m{background-color:var(--in-fg);border-width:0}.tp-popv{background-color:var(--bs-bg);border-radius:6px;box-shadow:0 2px 4px var(--bs-sh);display:none;max-width:168px;padding:var(--cnt-v-p) var(--cnt-h-p);position:absolute;visibility:hidden;z-index:1000}.tp-popv.tp-popv-v{display:block;visibility:visible}.tp-sprv_r{background-color:var(--grv-fg);border-width:0;display:block;height:2px;margin:0;width:100%}.tp-sldv.tp-v-disabled{opacity:0.5}.tp-sldv_t{box-sizing:border-box;cursor:pointer;height:var(--bld-us);margin:0 6px;outline:none;position:relative}.tp-sldv_t::before{background-color:var(--in-bg);border-radius:1px;bottom:0;content:\'\';display:block;height:2px;left:0;margin:auto;position:absolute;right:0;top:0}.tp-sldv_k{height:100%;left:0;position:absolute;top:0}.tp-sldv_k::before{background-color:var(--in-fg);border-radius:1px;bottom:0;content:\'\';display:block;height:2px;left:0;margin-bottom:auto;margin-top:auto;position:absolute;right:0;top:0}.tp-sldv_k::after{background-color:var(--btn-bg);border-radius:var(--elm-br);bottom:0;content:\'\';display:block;height:12px;margin-bottom:auto;margin-top:auto;position:absolute;right:-6px;top:0;width:12px}.tp-sldv_t:hover .tp-sldv_k::after{background-color:var(--btn-bg-h)}.tp-sldv_t:focus .tp-sldv_k::after{background-color:var(--btn-bg-f)}.tp-sldv_t:active .tp-sldv_k::after{background-color:var(--btn-bg-a)}.tp-sldtxtv{display:flex}.tp-sldtxtv_s{flex:2}.tp-sldtxtv_t{flex:1;margin-left:4px}.tp-tabv.tp-v-disabled{opacity:0.5}.tp-tabv_i{align-items:flex-end;display:flex;overflow:hidden}.tp-tabv.tp-tabv-nop .tp-tabv_i{height:calc(var(--bld-us) + 4px);position:relative}.tp-tabv.tp-tabv-nop .tp-tabv_i::before{background-color:var(--cnt-bg);bottom:0;content:\'\';height:2px;left:0;position:absolute;right:0}.tp-tabv_c{border-left:var(--cnt-bg) solid 4px;padding-bottom:var(--cnt-v-p);padding-top:var(--cnt-v-p)}.tp-tbiv{flex:1;min-width:0;position:relative}.tp-tbiv+.tp-tbiv{margin-left:2px}.tp-tbiv+.tp-tbiv::before{background-color:var(--cnt-bg);bottom:0;content:\'\';height:2px;left:-2px;position:absolute;width:2px}.tp-tbiv_b{background-color:var(--cnt-bg);display:block;padding-left:calc(var(--cnt-h-p) + 4px);padding-right:calc(var(--cnt-h-p) + 4px);width:100%}.tp-tbiv_b:hover{background-color:var(--cnt-bg-h)}.tp-tbiv_b:focus{background-color:var(--cnt-bg-f)}.tp-tbiv_b:active{background-color:var(--cnt-bg-a)}.tp-tbiv_b:disabled{opacity:0.5}.tp-tbiv_t{color:var(--cnt-fg);height:calc(var(--bld-us) + 4px);line-height:calc(var(--bld-us) + 4px);opacity:0.5;overflow:hidden;text-overflow:ellipsis}.tp-tbiv.tp-tbiv-sel .tp-tbiv_t{opacity:1}.tp-txtv{position:relative}.tp-txtv_i{padding:0 4px}.tp-txtv.tp-txtv-fst .tp-txtv_i{border-bottom-right-radius:0;border-top-right-radius:0}.tp-txtv.tp-txtv-mid .tp-txtv_i{border-radius:0}.tp-txtv.tp-txtv-lst .tp-txtv_i{border-bottom-left-radius:0;border-top-left-radius:0}.tp-txtv.tp-txtv-num .tp-txtv_i{text-align:right}.tp-txtv.tp-txtv-drg .tp-txtv_i{opacity:0.3}.tp-txtv_k{cursor:pointer;height:100%;left:-3px;position:absolute;top:0;width:12px}.tp-txtv_k::before{background-color:var(--in-fg);border-radius:1px;bottom:0;content:\'\';height:calc(var(--bld-us) - 4px);left:50%;margin-bottom:auto;margin-left:-1px;margin-top:auto;opacity:0.1;position:absolute;top:0;transition:border-radius 0.1s, height 0.1s, transform 0.1s, width 0.1s;width:2px}.tp-txtv_k:hover::before,.tp-txtv.tp-txtv-drg .tp-txtv_k::before{opacity:1}.tp-txtv.tp-txtv-drg .tp-txtv_k::before{border-radius:50%;height:4px;transform:translateX(-1px);width:4px}.tp-txtv_g{bottom:0;display:block;height:8px;left:50%;margin:auto;overflow:visible;pointer-events:none;position:absolute;top:0;visibility:hidden;width:100%}.tp-txtv.tp-txtv-drg .tp-txtv_g{visibility:visible}.tp-txtv_gb{fill:none;stroke:var(--in-fg);stroke-dasharray:1}.tp-txtv_gh{fill:none;stroke:var(--in-fg)}.tp-txtv .tp-ttv{margin-left:6px;visibility:hidden}.tp-txtv.tp-txtv-drg .tp-ttv{visibility:visible}.tp-ttv{background-color:var(--in-fg);border-radius:var(--elm-br);color:var(--bs-bg);padding:2px 4px;pointer-events:none;position:absolute;transform:translate(-50%, -100%)}.tp-ttv::before{border-color:var(--in-fg) transparent transparent transparent;border-style:solid;border-width:2px;box-sizing:border-box;content:\'\';font-size:0.9em;height:4px;left:50%;margin-left:-2px;position:absolute;top:100%;width:4px}.tp-rotv{background-color:var(--bs-bg);border-radius:var(--bs-br);box-shadow:0 2px 4px var(--bs-sh);font-family:var(--font-family);font-size:11px;font-weight:500;line-height:1;text-align:left}.tp-rotv_b{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br);border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br);padding-left:calc(2px * 2 + var(--bld-us) + var(--cnt-h-p));text-align:center}.tp-rotv.tp-rotv-expanded .tp-rotv_b{border-bottom-left-radius:0;border-bottom-right-radius:0}.tp-rotv.tp-rotv-not .tp-rotv_b{display:none}.tp-rotv_c>.tp-fldv.tp-v-lst>.tp-fldv_c,.tp-rotv_c>.tp-tabv.tp-v-lst>.tp-tabv_c{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br)}.tp-rotv_c>.tp-fldv.tp-v-lst:not(.tp-fldv-expanded)>.tp-fldv_b{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br)}.tp-rotv_c .tp-fldv.tp-v-vlst:not(.tp-fldv-expanded)>.tp-fldv_b{border-bottom-right-radius:var(--bs-br)}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-fldv.tp-v-fst{margin-top:calc(-1 * var(--cnt-v-p))}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-fldv.tp-v-fst>.tp-fldv_b{border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br)}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-tabv.tp-v-fst{margin-top:calc(-1 * var(--cnt-v-p))}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-tabv.tp-v-fst>.tp-tabv_i{border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br)}.tp-rotv.tp-v-disabled,.tp-rotv .tp-v-disabled{pointer-events:none}.tp-rotv.tp-v-hidden,.tp-rotv .tp-v-hidden{display:none}'); this.pool_.getAll().forEach((plugin) => { this.embedPluginStyle_(plugin); }); this.registerPlugin({ plugins: [ SliderBladePlugin, ListBladePlugin, TabBladePlugin, TextBladePlugin, ], }); } } const VERSION = new Semver('3.0.5'); exports.BladeApi = BladeApi; exports.ButtonApi = ButtonApi; exports.FolderApi = FolderApi; exports.InputBindingApi = InputBindingApi; exports.ListApi = ListApi; exports.MonitorBindingApi = MonitorBindingApi; exports.Pane = Pane; exports.SeparatorApi = SeparatorApi; exports.SliderApi = SliderApi; exports.TabApi = TabApi; exports.TabPageApi = TabPageApi; exports.TextApi = TextApi; exports.TpChangeEvent = TpChangeEvent; exports.VERSION = VERSION; Object.defineProperty(exports, '__esModule', { value: true }); }))); (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TweakpaneEssentialsPlugin = {})); }(window, (function (exports) { class BladeApi { constructor(controller) { this.controller_ = controller; } get disabled() { return this.controller_.viewProps.get('disabled'); } set disabled(disabled) { this.controller_.viewProps.set('disabled', disabled); } get hidden() { return this.controller_.viewProps.get('hidden'); } set hidden(hidden) { this.controller_.viewProps.set('hidden', hidden); } dispose() { this.controller_.viewProps.set('disposed', true); } } class TpEvent { constructor(target) { this.target = target; } } class TpChangeEvent extends TpEvent { constructor(target, value, presetKey, last) { super(target); this.value = value; this.presetKey = presetKey; this.last = last !== null && last !== void 0 ? last : true; } } function forceCast(v) { return v; } function isEmpty(value) { return value === null || value === undefined; } const CREATE_MESSAGE_MAP = { alreadydisposed: () => 'View has been already disposed', invalidparams: (context) => `Invalid parameters for '${context.name}'`, nomatchingcontroller: (context) => `No matching controller for '${context.key}'`, nomatchingview: (context) => `No matching view for '${JSON.stringify(context.params)}'`, notbindable: () => `Value is not bindable`, propertynotfound: (context) => `Property '${context.name}' not found`, shouldneverhappen: () => 'This error should never happen', }; class TpError { constructor(config) { var _a; this.message = (_a = CREATE_MESSAGE_MAP[config.type](forceCast(config.context))) !== null && _a !== void 0 ? _a : 'Unexpected error'; this.name = this.constructor.name; this.stack = new Error(this.message).stack; this.type = config.type; } static alreadyDisposed() { return new TpError({ type: 'alreadydisposed' }); } static notBindable() { return new TpError({ type: 'notbindable', }); } static propertyNotFound(name) { return new TpError({ type: 'propertynotfound', context: { name: name, }, }); } static shouldNeverHappen() { return new TpError({ type: 'shouldneverhappen' }); } } class Emitter { constructor() { this.observers_ = {}; } on(eventName, handler) { let observers = this.observers_[eventName]; if (!observers) { observers = this.observers_[eventName] = []; } observers.push({ handler: handler, }); return this; } off(eventName, handler) { const observers = this.observers_[eventName]; if (observers) { this.observers_[eventName] = observers.filter((observer) => { return observer.handler !== handler; }); } return this; } emit(eventName, event) { const observers = this.observers_[eventName]; if (!observers) { return; } observers.forEach((observer) => { observer.handler(event); }); } } const PREFIX = 'tp'; function ClassName(viewName) { const fn = (opt_elementName, opt_modifier) => { return [ PREFIX, '-', viewName, 'v', opt_elementName ? `_${opt_elementName}` : '', opt_modifier ? `-${opt_modifier}` : '', ].join(''); }; return fn; } function compose$1(h1, h2) { return (input) => h2(h1(input)); } function extractValue(ev) { return ev.rawValue; } function bindValue(value, applyValue) { value.emitter.on('change', compose$1(extractValue, applyValue)); applyValue(value.rawValue); } function bindValueMap(valueMap, key, applyValue) { bindValue(valueMap.value(key), applyValue); } function applyClass(elem, className, active) { if (active) { elem.classList.add(className); } else { elem.classList.remove(className); } } function valueToClassName(elem, className) { return (value) => { applyClass(elem, className, value); }; } function bindValueToTextContent(value, elem) { bindValue(value, (text) => { elem.textContent = text !== null && text !== void 0 ? text : ''; }); } const className$g = ClassName('btn'); class ButtonView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$g()); config.viewProps.bindClassModifiers(this.element); const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$g('b')); config.viewProps.bindDisabled(buttonElem); this.element.appendChild(buttonElem); this.buttonElement = buttonElem; const titleElem = doc.createElement('div'); titleElem.classList.add(className$g('t')); bindValueToTextContent(config.props.value('title'), titleElem); this.buttonElement.appendChild(titleElem); } } class ButtonController { constructor(doc, config) { this.emitter = new Emitter(); this.onClick_ = this.onClick_.bind(this); this.props = config.props; this.viewProps = config.viewProps; this.view = new ButtonView(doc, { props: this.props, viewProps: this.viewProps, }); this.view.buttonElement.addEventListener('click', this.onClick_); } onClick_() { this.emitter.emit('click', { sender: this, }); } } class BoundValue { constructor(initialValue, config) { var _a; this.constraint_ = config === null || config === void 0 ? void 0 : config.constraint; this.equals_ = (_a = config === null || config === void 0 ? void 0 : config.equals) !== null && _a !== void 0 ? _a : ((v1, v2) => v1 === v2); this.emitter = new Emitter(); this.rawValue_ = initialValue; } get constraint() { return this.constraint_; } get rawValue() { return this.rawValue_; } set rawValue(rawValue) { this.setRawValue(rawValue, { forceEmit: false, last: true, }); } setRawValue(rawValue, options) { const opts = options !== null && options !== void 0 ? options : { forceEmit: false, last: true, }; const constrainedValue = this.constraint_ ? this.constraint_.constrain(rawValue) : rawValue; const changed = !this.equals_(this.rawValue_, constrainedValue); if (!changed && !opts.forceEmit) { return; } this.emitter.emit('beforechange', { sender: this, }); this.rawValue_ = constrainedValue; this.emitter.emit('change', { options: opts, rawValue: constrainedValue, sender: this, }); } } class PrimitiveValue { constructor(initialValue) { this.emitter = new Emitter(); this.value_ = initialValue; } get rawValue() { return this.value_; } set rawValue(value) { this.setRawValue(value, { forceEmit: false, last: true, }); } setRawValue(value, options) { const opts = options !== null && options !== void 0 ? options : { forceEmit: false, last: true, }; if (this.value_ === value && !opts.forceEmit) { return; } this.emitter.emit('beforechange', { sender: this, }); this.value_ = value; this.emitter.emit('change', { options: opts, rawValue: this.value_, sender: this, }); } } function createValue(initialValue, config) { const constraint = config === null || config === void 0 ? void 0 : config.constraint; const equals = config === null || config === void 0 ? void 0 : config.equals; if (!constraint && !equals) { return new PrimitiveValue(initialValue); } return new BoundValue(initialValue, config); } class ValueMap { constructor(valueMap) { this.emitter = new Emitter(); this.valMap_ = valueMap; for (const key in this.valMap_) { const v = this.valMap_[key]; v.emitter.on('change', () => { this.emitter.emit('change', { key: key, sender: this, }); }); } } static createCore(initialValue) { const keys = Object.keys(initialValue); return keys.reduce((o, key) => { return Object.assign(o, { [key]: createValue(initialValue[key]), }); }, {}); } static fromObject(initialValue) { const core = this.createCore(initialValue); return new ValueMap(core); } get(key) { return this.valMap_[key].rawValue; } set(key, value) { this.valMap_[key].rawValue = value; } value(key) { return this.valMap_[key]; } } function parseObject(value, keyToParserMap) { const keys = Object.keys(keyToParserMap); const result = keys.reduce((tmp, key) => { if (tmp === undefined) { return undefined; } const parser = keyToParserMap[key]; const result = parser(value[key]); return result.succeeded ? Object.assign(Object.assign({}, tmp), { [key]: result.value }) : undefined; }, {}); return forceCast(result); } function parseArray(value, parseItem) { return value.reduce((tmp, item) => { if (tmp === undefined) { return undefined; } const result = parseItem(item); if (!result.succeeded || result.value === undefined) { return undefined; } return [...tmp, result.value]; }, []); } function isObject(value) { if (value === null) { return false; } return typeof value === 'object'; } function createParamsParserBuilder(parse) { return (optional) => (v) => { if (!optional && v === undefined) { return { succeeded: false, value: undefined, }; } if (optional && v === undefined) { return { succeeded: true, value: undefined, }; } const result = parse(v); return result !== undefined ? { succeeded: true, value: result, } : { succeeded: false, value: undefined, }; }; } function createParamsParserBuilders(optional) { return { custom: (parse) => createParamsParserBuilder(parse)(optional), boolean: createParamsParserBuilder((v) => typeof v === 'boolean' ? v : undefined)(optional), number: createParamsParserBuilder((v) => typeof v === 'number' ? v : undefined)(optional), string: createParamsParserBuilder((v) => typeof v === 'string' ? v : undefined)(optional), function: createParamsParserBuilder((v) => typeof v === 'function' ? v : undefined)(optional), constant: (value) => createParamsParserBuilder((v) => (v === value ? value : undefined))(optional), raw: createParamsParserBuilder((v) => v)(optional), object: (keyToParserMap) => createParamsParserBuilder((v) => { if (!isObject(v)) { return undefined; } return parseObject(v, keyToParserMap); })(optional), array: (itemParser) => createParamsParserBuilder((v) => { if (!Array.isArray(v)) { return undefined; } return parseArray(v, itemParser); })(optional), }; } const ParamsParsers = { optional: createParamsParserBuilders(true), required: createParamsParserBuilders(false), }; function parseParams(value, keyToParserMap) { const result = ParamsParsers.required.object(keyToParserMap)(value); return result.succeeded ? result.value : undefined; } function disposeElement(elem) { if (elem && elem.parentElement) { elem.parentElement.removeChild(elem); } return null; } function getAllBladePositions() { return ['veryfirst', 'first', 'last', 'verylast']; } const className$f = ClassName(''); const POS_TO_CLASS_NAME_MAP = { veryfirst: 'vfst', first: 'fst', last: 'lst', verylast: 'vlst', }; class BladeController { constructor(config) { this.parent_ = null; this.blade = config.blade; this.view = config.view; this.viewProps = config.viewProps; const elem = this.view.element; this.blade.value('positions').emitter.on('change', () => { getAllBladePositions().forEach((pos) => { elem.classList.remove(className$f(undefined, POS_TO_CLASS_NAME_MAP[pos])); }); this.blade.get('positions').forEach((pos) => { elem.classList.add(className$f(undefined, POS_TO_CLASS_NAME_MAP[pos])); }); }); this.viewProps.handleDispose(() => { disposeElement(elem); }); } get parent() { return this.parent_; } } const SVG_NS = 'http://www.w3.org/2000/svg'; function forceReflow(element) { element.offsetHeight; } function disableTransitionTemporarily(element, callback) { const t = element.style.transition; element.style.transition = 'none'; callback(); element.style.transition = t; } function supportsTouch(doc) { return doc.ontouchstart !== undefined; } function removeChildNodes(element) { while (element.childNodes.length > 0) { element.removeChild(element.childNodes[0]); } } function findNextTarget(ev) { if (ev.relatedTarget) { return forceCast(ev.relatedTarget); } if ('explicitOriginalTarget' in ev) { return ev.explicitOriginalTarget; } return null; } const className$e = ClassName('lbl'); function createLabelNode(doc, label) { const frag = doc.createDocumentFragment(); const lineNodes = label.split('\n').map((line) => { return doc.createTextNode(line); }); lineNodes.forEach((lineNode, index) => { if (index > 0) { frag.appendChild(doc.createElement('br')); } frag.appendChild(lineNode); }); return frag; } class LabelView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$e()); config.viewProps.bindClassModifiers(this.element); const labelElem = doc.createElement('div'); labelElem.classList.add(className$e('l')); bindValueMap(config.props, 'label', (value) => { if (isEmpty(value)) { this.element.classList.add(className$e(undefined, 'nol')); } else { this.element.classList.remove(className$e(undefined, 'nol')); removeChildNodes(labelElem); labelElem.appendChild(createLabelNode(doc, value)); } }); this.element.appendChild(labelElem); this.labelElement = labelElem; const valueElem = doc.createElement('div'); valueElem.classList.add(className$e('v')); this.element.appendChild(valueElem); this.valueElement = valueElem; } } class LabelController extends BladeController { constructor(doc, config) { const viewProps = config.valueController.viewProps; super(Object.assign(Object.assign({}, config), { view: new LabelView(doc, { props: config.props, viewProps: viewProps, }), viewProps: viewProps })); this.props = config.props; this.valueController = config.valueController; this.view.valueElement.appendChild(this.valueController.view.element); } } class ValueBladeController extends BladeController { constructor(config) { super(config); this.value = config.value; } } class Foldable extends ValueMap { constructor(valueMap) { super(valueMap); } static create(expanded) { const coreObj = { completed: true, expanded: expanded, expandedHeight: null, shouldFixHeight: false, temporaryExpanded: null, }; const core = ValueMap.createCore(coreObj); return new Foldable(core); } get styleExpanded() { var _a; return (_a = this.get('temporaryExpanded')) !== null && _a !== void 0 ? _a : this.get('expanded'); } get styleHeight() { if (!this.styleExpanded) { return '0'; } const exHeight = this.get('expandedHeight'); if (this.get('shouldFixHeight') && !isEmpty(exHeight)) { return `${exHeight}px`; } return 'auto'; } bindExpandedClass(elem, expandedClassName) { bindValueMap(this, 'expanded', () => { const expanded = this.styleExpanded; if (expanded) { elem.classList.add(expandedClassName); } else { elem.classList.remove(expandedClassName); } }); } } function createFoldable(expanded) { return Foldable.create(expanded); } function computeExpandedFolderHeight(folder, containerElement) { let height = 0; disableTransitionTemporarily(containerElement, () => { folder.set('expandedHeight', null); folder.set('temporaryExpanded', true); forceReflow(containerElement); height = containerElement.clientHeight; folder.set('temporaryExpanded', null); forceReflow(containerElement); }); return height; } function applyHeight(foldable, elem) { elem.style.height = foldable.styleHeight; } function bindFoldable(foldable, elem) { foldable.value('expanded').emitter.on('beforechange', () => { foldable.set('completed', false); if (isEmpty(foldable.get('expandedHeight'))) { foldable.set('expandedHeight', computeExpandedFolderHeight(foldable, elem)); } foldable.set('shouldFixHeight', true); forceReflow(elem); }); foldable.emitter.on('change', () => { applyHeight(foldable, elem); }); applyHeight(foldable, elem); elem.addEventListener('transitionend', (ev) => { if (ev.propertyName !== 'height') { return; } foldable.set('shouldFixHeight', false); foldable.set('expandedHeight', null); foldable.set('completed', true); }); } class PlainView { constructor(doc, config) { const className = ClassName(config.viewName); this.element = doc.createElement('div'); this.element.classList.add(className()); config.viewProps.bindClassModifiers(this.element); } } class LabeledValueController extends ValueBladeController { constructor(doc, config) { const viewProps = config.valueController.viewProps; super(Object.assign(Object.assign({}, config), { value: config.valueController.value, view: new LabelView(doc, { props: config.props, viewProps: viewProps, }), viewProps: viewProps })); this.props = config.props; this.valueController = config.valueController; this.view.valueElement.appendChild(this.valueController.view.element); } } const className$d = ClassName(''); function valueToModifier(elem, modifier) { return valueToClassName(elem, className$d(undefined, modifier)); } class ViewProps extends ValueMap { constructor(valueMap) { super(valueMap); } static create(opt_initialValue) { var _a, _b; const initialValue = opt_initialValue !== null && opt_initialValue !== void 0 ? opt_initialValue : {}; const coreObj = { disabled: (_a = initialValue.disabled) !== null && _a !== void 0 ? _a : false, disposed: false, hidden: (_b = initialValue.hidden) !== null && _b !== void 0 ? _b : false, }; const core = ValueMap.createCore(coreObj); return new ViewProps(core); } bindClassModifiers(elem) { bindValueMap(this, 'disabled', valueToModifier(elem, 'disabled')); bindValueMap(this, 'hidden', valueToModifier(elem, 'hidden')); } bindDisabled(target) { bindValueMap(this, 'disabled', (disabled) => { target.disabled = disabled; }); } bindTabIndex(elem) { bindValueMap(this, 'disabled', (disabled) => { elem.tabIndex = disabled ? -1 : 0; }); } handleDispose(callback) { this.value('disposed').emitter.on('change', (disposed) => { if (disposed) { callback(); } }); } } class ManualTicker { constructor() { this.disabled = false; this.emitter = new Emitter(); } dispose() { } tick() { if (this.disabled) { return; } this.emitter.emit('tick', { sender: this, }); } } class IntervalTicker { constructor(doc, interval) { this.disabled_ = false; this.timerId_ = null; this.onTick_ = this.onTick_.bind(this); this.doc_ = doc; this.emitter = new Emitter(); this.interval_ = interval; this.setTimer_(); } get disabled() { return this.disabled_; } set disabled(inactive) { this.disabled_ = inactive; if (this.disabled_) { this.clearTimer_(); } else { this.setTimer_(); } } dispose() { this.clearTimer_(); } clearTimer_() { if (this.timerId_ === null) { return; } const win = this.doc_.defaultView; if (win) { win.clearInterval(this.timerId_); } this.timerId_ = null; } setTimer_() { this.clearTimer_(); if (this.interval_ <= 0) { return; } const win = this.doc_.defaultView; if (win) { this.timerId_ = win.setInterval(this.onTick_, this.interval_); } } onTick_() { if (this.disabled_) { return; } this.emitter.emit('tick', { sender: this, }); } } class CompositeConstraint { constructor(constraints) { this.constraints = constraints; } constrain(value) { return this.constraints.reduce((result, c) => { return c.constrain(result); }, value); } } function findConstraint(c, constraintClass) { if (c instanceof constraintClass) { return c; } if (c instanceof CompositeConstraint) { const result = c.constraints.reduce((tmpResult, sc) => { if (tmpResult) { return tmpResult; } return sc instanceof constraintClass ? sc : null; }, null); if (result) { return result; } } return null; } class RangeConstraint { constructor(config) { this.maxValue = config.max; this.minValue = config.min; } constrain(value) { let result = value; if (!isEmpty(this.minValue)) { result = Math.max(result, this.minValue); } if (!isEmpty(this.maxValue)) { result = Math.min(result, this.maxValue); } return result; } } class StepConstraint { constructor(step) { this.step = step; } constrain(value) { const r = value < 0 ? -Math.round(-value / this.step) : Math.round(value / this.step); return r * this.step; } } const className$c = ClassName('pop'); class PopupView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$c()); config.viewProps.bindClassModifiers(this.element); bindValue(config.shows, valueToClassName(this.element, className$c(undefined, 'v'))); } } class PopupController { constructor(doc, config) { this.shows = createValue(false); this.viewProps = config.viewProps; this.view = new PopupView(doc, { shows: this.shows, viewProps: this.viewProps, }); } } const className$b = ClassName('txt'); class TextView { constructor(doc, config) { this.onChange_ = this.onChange_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className$b()); config.viewProps.bindClassModifiers(this.element); this.props_ = config.props; this.props_.emitter.on('change', this.onChange_); const inputElem = doc.createElement('input'); inputElem.classList.add(className$b('i')); inputElem.type = 'text'; config.viewProps.bindDisabled(inputElem); this.element.appendChild(inputElem); this.inputElement = inputElem; config.value.emitter.on('change', this.onChange_); this.value_ = config.value; this.refresh(); } refresh() { const formatter = this.props_.get('formatter'); this.inputElement.value = formatter(this.value_.rawValue); } onChange_() { this.refresh(); } } class TextController { constructor(doc, config) { this.onInputChange_ = this.onInputChange_.bind(this); this.parser_ = config.parser; this.props = config.props; this.value = config.value; this.viewProps = config.viewProps; this.view = new TextView(doc, { props: config.props, value: this.value, viewProps: this.viewProps, }); this.view.inputElement.addEventListener('change', this.onInputChange_); } onInputChange_(e) { const inputElem = forceCast(e.currentTarget); const value = inputElem.value; const parsedValue = this.parser_(value); if (!isEmpty(parsedValue)) { this.value.rawValue = parsedValue; } this.view.refresh(); } } class NumberLiteralNode { constructor(text) { this.text = text; } evaluate() { return Number(this.text); } toString() { return this.text; } } const BINARY_OPERATION_MAP = { '**': (v1, v2) => Math.pow(v1, v2), '*': (v1, v2) => v1 * v2, '/': (v1, v2) => v1 / v2, '%': (v1, v2) => v1 % v2, '+': (v1, v2) => v1 + v2, '-': (v1, v2) => v1 - v2, '<<': (v1, v2) => v1 << v2, '>>': (v1, v2) => v1 >> v2, '>>>': (v1, v2) => v1 >>> v2, '&': (v1, v2) => v1 & v2, '^': (v1, v2) => v1 ^ v2, '|': (v1, v2) => v1 | v2, }; class BinaryOperationNode { constructor(operator, left, right) { this.left = left; this.operator = operator; this.right = right; } evaluate() { const op = BINARY_OPERATION_MAP[this.operator]; if (!op) { throw new Error(`unexpected binary operator: '${this.operator}`); } return op(this.left.evaluate(), this.right.evaluate()); } toString() { return [ 'b(', this.left.toString(), this.operator, this.right.toString(), ')', ].join(' '); } } const UNARY_OPERATION_MAP = { '+': (v) => v, '-': (v) => -v, '~': (v) => ~v, }; class UnaryOperationNode { constructor(operator, expr) { this.operator = operator; this.expression = expr; } evaluate() { const op = UNARY_OPERATION_MAP[this.operator]; if (!op) { throw new Error(`unexpected unary operator: '${this.operator}`); } return op(this.expression.evaluate()); } toString() { return ['u(', this.operator, this.expression.toString(), ')'].join(' '); } } function combineReader(parsers) { return (text, cursor) => { for (let i = 0; i < parsers.length; i++) { const result = parsers[i](text, cursor); if (result !== '') { return result; } } return ''; }; } function readWhitespace(text, cursor) { var _a; const m = text.substr(cursor).match(/^\s+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readNonZeroDigit(text, cursor) { const ch = text.substr(cursor, 1); return ch.match(/^[1-9]$/) ? ch : ''; } function readDecimalDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-9]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readSignedInteger(text, cursor) { const ds = readDecimalDigits(text, cursor); if (ds !== '') { return ds; } const sign = text.substr(cursor, 1); cursor += 1; if (sign !== '-' && sign !== '+') { return ''; } const sds = readDecimalDigits(text, cursor); if (sds === '') { return ''; } return sign + sds; } function readExponentPart(text, cursor) { const e = text.substr(cursor, 1); cursor += 1; if (e.toLowerCase() !== 'e') { return ''; } const si = readSignedInteger(text, cursor); if (si === '') { return ''; } return e + si; } function readDecimalIntegerLiteral(text, cursor) { const ch = text.substr(cursor, 1); if (ch === '0') { return ch; } const nzd = readNonZeroDigit(text, cursor); cursor += nzd.length; if (nzd === '') { return ''; } return nzd + readDecimalDigits(text, cursor); } function readDecimalLiteral1(text, cursor) { const dil = readDecimalIntegerLiteral(text, cursor); cursor += dil.length; if (dil === '') { return ''; } const dot = text.substr(cursor, 1); cursor += dot.length; if (dot !== '.') { return ''; } const dds = readDecimalDigits(text, cursor); cursor += dds.length; return dil + dot + dds + readExponentPart(text, cursor); } function readDecimalLiteral2(text, cursor) { const dot = text.substr(cursor, 1); cursor += dot.length; if (dot !== '.') { return ''; } const dds = readDecimalDigits(text, cursor); cursor += dds.length; if (dds === '') { return ''; } return dot + dds + readExponentPart(text, cursor); } function readDecimalLiteral3(text, cursor) { const dil = readDecimalIntegerLiteral(text, cursor); cursor += dil.length; if (dil === '') { return ''; } return dil + readExponentPart(text, cursor); } const readDecimalLiteral = combineReader([ readDecimalLiteral1, readDecimalLiteral2, readDecimalLiteral3, ]); function parseBinaryDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[01]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readBinaryIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0b') { return ''; } const bds = parseBinaryDigits(text, cursor); if (bds === '') { return ''; } return prefix + bds; } function readOctalDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-7]+/); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readOctalIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0o') { return ''; } const ods = readOctalDigits(text, cursor); if (ods === '') { return ''; } return prefix + ods; } function readHexDigits(text, cursor) { var _a; const m = text.substr(cursor).match(/^[0-9a-f]+/i); return (_a = (m && m[0])) !== null && _a !== void 0 ? _a : ''; } function readHexIntegerLiteral(text, cursor) { const prefix = text.substr(cursor, 2); cursor += prefix.length; if (prefix.toLowerCase() !== '0x') { return ''; } const hds = readHexDigits(text, cursor); if (hds === '') { return ''; } return prefix + hds; } const readNonDecimalIntegerLiteral = combineReader([ readBinaryIntegerLiteral, readOctalIntegerLiteral, readHexIntegerLiteral, ]); const readNumericLiteral = combineReader([ readNonDecimalIntegerLiteral, readDecimalLiteral, ]); function parseLiteral(text, cursor) { const num = readNumericLiteral(text, cursor); cursor += num.length; if (num === '') { return null; } return { evaluable: new NumberLiteralNode(num), cursor: cursor, }; } function parseParenthesizedExpression(text, cursor) { const op = text.substr(cursor, 1); cursor += op.length; if (op !== '(') { return null; } const expr = parseExpression(text, cursor); if (!expr) { return null; } cursor = expr.cursor; cursor += readWhitespace(text, cursor).length; const cl = text.substr(cursor, 1); cursor += cl.length; if (cl !== ')') { return null; } return { evaluable: expr.evaluable, cursor: cursor, }; } function parsePrimaryExpression(text, cursor) { return (parseLiteral(text, cursor) || parseParenthesizedExpression(text, cursor)); } function parseUnaryExpression(text, cursor) { const expr = parsePrimaryExpression(text, cursor); if (expr) { return expr; } const op = text.substr(cursor, 1); cursor += op.length; if (op !== '+' && op !== '-' && op !== '~') { return null; } const num = parseUnaryExpression(text, cursor); if (!num) { return null; } cursor = num.cursor; return { cursor: cursor, evaluable: new UnaryOperationNode(op, num.evaluable), }; } function readBinaryOperator(ops, text, cursor) { cursor += readWhitespace(text, cursor).length; const op = ops.filter((op) => text.startsWith(op, cursor))[0]; if (!op) { return null; } cursor += op.length; cursor += readWhitespace(text, cursor).length; return { cursor: cursor, operator: op, }; } function createBinaryOperationExpressionParser(exprParser, ops) { return (text, cursor) => { const firstExpr = exprParser(text, cursor); if (!firstExpr) { return null; } cursor = firstExpr.cursor; let expr = firstExpr.evaluable; for (;;) { const op = readBinaryOperator(ops, text, cursor); if (!op) { break; } cursor = op.cursor; const nextExpr = exprParser(text, cursor); if (!nextExpr) { return null; } cursor = nextExpr.cursor; expr = new BinaryOperationNode(op.operator, expr, nextExpr.evaluable); } return expr ? { cursor: cursor, evaluable: expr, } : null; }; } const parseBinaryOperationExpression = [ ['**'], ['*', '/', '%'], ['+', '-'], ['<<', '>>>', '>>'], ['&'], ['^'], ['|'], ].reduce((parser, ops) => { return createBinaryOperationExpressionParser(parser, ops); }, parseUnaryExpression); function parseExpression(text, cursor) { cursor += readWhitespace(text, cursor).length; return parseBinaryOperationExpression(text, cursor); } function parseEcmaNumberExpression(text) { const expr = parseExpression(text, 0); if (!expr) { return null; } const cursor = expr.cursor + readWhitespace(text, expr.cursor).length; if (cursor !== text.length) { return null; } return expr.evaluable; } function parseNumber(text) { var _a; const r = parseEcmaNumberExpression(text); return (_a = r === null || r === void 0 ? void 0 : r.evaluate()) !== null && _a !== void 0 ? _a : null; } function numberFromUnknown(value) { if (typeof value === 'number') { return value; } if (typeof value === 'string') { const pv = parseNumber(value); if (!isEmpty(pv)) { return pv; } } return 0; } function createNumberFormatter(digits) { return (value) => { return value.toFixed(Math.max(Math.min(digits, 20), 0)); }; } function fillBuffer(buffer, bufferSize) { while (buffer.length < bufferSize) { buffer.push(undefined); } } function initializeBuffer(bufferSize) { const buffer = []; fillBuffer(buffer, bufferSize); return createValue(buffer); } function createTrimmedBuffer(buffer) { const index = buffer.indexOf(undefined); return forceCast(index < 0 ? buffer : buffer.slice(0, index)); } function createPushedBuffer(buffer, newValue) { const newBuffer = [...createTrimmedBuffer(buffer), newValue]; if (newBuffer.length > buffer.length) { newBuffer.splice(0, newBuffer.length - buffer.length); } else { fillBuffer(newBuffer, buffer.length); } return newBuffer; } function connectValues({ primary, secondary, forward, backward, }) { let changing = false; function preventFeedback(callback) { if (changing) { return; } changing = true; callback(); changing = false; } primary.emitter.on('change', (ev) => { preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), ev.options); }); }); secondary.emitter.on('change', (ev) => { preventFeedback(() => { primary.setRawValue(backward(primary, secondary), ev.options); }); preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), ev.options); }); }); preventFeedback(() => { secondary.setRawValue(forward(primary, secondary), { forceEmit: false, last: true, }); }); } function getStepForKey(baseStep, keys) { const step = baseStep * (keys.altKey ? 0.1 : 1) * (keys.shiftKey ? 10 : 1); if (keys.upKey) { return +step; } else if (keys.downKey) { return -step; } return 0; } function getVerticalStepKeys(ev) { return { altKey: ev.altKey, downKey: ev.key === 'ArrowDown', shiftKey: ev.shiftKey, upKey: ev.key === 'ArrowUp', }; } function getHorizontalStepKeys(ev) { return { altKey: ev.altKey, downKey: ev.key === 'ArrowLeft', shiftKey: ev.shiftKey, upKey: ev.key === 'ArrowRight', }; } function isVerticalArrowKey(key) { return key === 'ArrowUp' || key === 'ArrowDown'; } function isArrowKey(key) { return isVerticalArrowKey(key) || key === 'ArrowLeft' || key === 'ArrowRight'; } function computeOffset(ev, elem) { const win = elem.ownerDocument.defaultView; const rect = elem.getBoundingClientRect(); return { x: ev.pageX - (((win && win.scrollX) || 0) + rect.left), y: ev.pageY - (((win && win.scrollY) || 0) + rect.top), }; } class PointerHandler { constructor(element) { this.lastTouch_ = null; this.onDocumentMouseMove_ = this.onDocumentMouseMove_.bind(this); this.onDocumentMouseUp_ = this.onDocumentMouseUp_.bind(this); this.onMouseDown_ = this.onMouseDown_.bind(this); this.onTouchEnd_ = this.onTouchEnd_.bind(this); this.onTouchMove_ = this.onTouchMove_.bind(this); this.onTouchStart_ = this.onTouchStart_.bind(this); this.elem_ = element; this.emitter = new Emitter(); element.addEventListener('touchstart', this.onTouchStart_); element.addEventListener('touchmove', this.onTouchMove_); element.addEventListener('touchend', this.onTouchEnd_); element.addEventListener('mousedown', this.onMouseDown_); } computePosition_(offset) { const rect = this.elem_.getBoundingClientRect(); return { bounds: { width: rect.width, height: rect.height, }, point: offset ? { x: offset.x, y: offset.y, } : null, }; } onMouseDown_(ev) { var _a; ev.preventDefault(); (_a = ev.currentTarget) === null || _a === void 0 ? void 0 : _a.focus(); const doc = this.elem_.ownerDocument; doc.addEventListener('mousemove', this.onDocumentMouseMove_); doc.addEventListener('mouseup', this.onDocumentMouseUp_); this.emitter.emit('down', { altKey: ev.altKey, data: this.computePosition_(computeOffset(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onDocumentMouseMove_(ev) { this.emitter.emit('move', { altKey: ev.altKey, data: this.computePosition_(computeOffset(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onDocumentMouseUp_(ev) { const doc = this.elem_.ownerDocument; doc.removeEventListener('mousemove', this.onDocumentMouseMove_); doc.removeEventListener('mouseup', this.onDocumentMouseUp_); this.emitter.emit('up', { altKey: ev.altKey, data: this.computePosition_(computeOffset(ev, this.elem_)), sender: this, shiftKey: ev.shiftKey, }); } onTouchStart_(ev) { ev.preventDefault(); const touch = ev.targetTouches.item(0); const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('down', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); this.lastTouch_ = touch; } onTouchMove_(ev) { const touch = ev.targetTouches.item(0); const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('move', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); this.lastTouch_ = touch; } onTouchEnd_(ev) { var _a; const touch = (_a = ev.targetTouches.item(0)) !== null && _a !== void 0 ? _a : this.lastTouch_; const rect = this.elem_.getBoundingClientRect(); this.emitter.emit('up', { altKey: ev.altKey, data: this.computePosition_(touch ? { x: touch.clientX - rect.left, y: touch.clientY - rect.top, } : undefined), sender: this, shiftKey: ev.shiftKey, }); } } function mapRange(value, start1, end1, start2, end2) { const p = (value - start1) / (end1 - start1); return start2 + p * (end2 - start2); } function getDecimalDigits(value) { const text = String(value.toFixed(10)); const frac = text.split('.')[1]; return frac.replace(/0+$/, '').length; } function constrainRange(value, min, max) { return Math.min(Math.max(value, min), max); } const className$a = ClassName('txt'); class NumberTextView { constructor(doc, config) { this.onChange_ = this.onChange_.bind(this); this.props_ = config.props; this.props_.emitter.on('change', this.onChange_); this.element = doc.createElement('div'); this.element.classList.add(className$a(), className$a(undefined, 'num')); if (config.arrayPosition) { this.element.classList.add(className$a(undefined, config.arrayPosition)); } config.viewProps.bindClassModifiers(this.element); const inputElem = doc.createElement('input'); inputElem.classList.add(className$a('i')); inputElem.type = 'text'; config.viewProps.bindDisabled(inputElem); this.element.appendChild(inputElem); this.inputElement = inputElem; this.onDraggingChange_ = this.onDraggingChange_.bind(this); this.dragging_ = config.dragging; this.dragging_.emitter.on('change', this.onDraggingChange_); this.element.classList.add(className$a()); this.inputElement.classList.add(className$a('i')); const knobElem = doc.createElement('div'); knobElem.classList.add(className$a('k')); this.element.appendChild(knobElem); this.knobElement = knobElem; const guideElem = doc.createElementNS(SVG_NS, 'svg'); guideElem.classList.add(className$a('g')); this.knobElement.appendChild(guideElem); const bodyElem = doc.createElementNS(SVG_NS, 'path'); bodyElem.classList.add(className$a('gb')); guideElem.appendChild(bodyElem); this.guideBodyElem_ = bodyElem; const headElem = doc.createElementNS(SVG_NS, 'path'); headElem.classList.add(className$a('gh')); guideElem.appendChild(headElem); this.guideHeadElem_ = headElem; const tooltipElem = doc.createElement('div'); tooltipElem.classList.add(ClassName('tt')()); this.knobElement.appendChild(tooltipElem); this.tooltipElem_ = tooltipElem; config.value.emitter.on('change', this.onChange_); this.value = config.value; this.refresh(); } onDraggingChange_(ev) { if (ev.rawValue === null) { this.element.classList.remove(className$a(undefined, 'drg')); return; } this.element.classList.add(className$a(undefined, 'drg')); const x = ev.rawValue / this.props_.get('draggingScale'); const aox = x + (x > 0 ? -1 : x < 0 ? +1 : 0); const adx = constrainRange(-aox, -4, +4); this.guideHeadElem_.setAttributeNS(null, 'd', [`M ${aox + adx},0 L${aox},4 L${aox + adx},8`, `M ${x},-1 L${x},9`].join(' ')); this.guideBodyElem_.setAttributeNS(null, 'd', `M 0,4 L${x},4`); const formatter = this.props_.get('formatter'); this.tooltipElem_.textContent = formatter(this.value.rawValue); this.tooltipElem_.style.left = `${x}px`; } refresh() { const formatter = this.props_.get('formatter'); this.inputElement.value = formatter(this.value.rawValue); } onChange_() { this.refresh(); } } class NumberTextController { constructor(doc, config) { this.originRawValue_ = 0; this.onInputChange_ = this.onInputChange_.bind(this); this.onInputKeyDown_ = this.onInputKeyDown_.bind(this); this.onInputKeyUp_ = this.onInputKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.baseStep_ = config.baseStep; this.parser_ = config.parser; this.props = config.props; this.value = config.value; this.viewProps = config.viewProps; this.dragging_ = createValue(null); this.view = new NumberTextView(doc, { arrayPosition: config.arrayPosition, dragging: this.dragging_, props: this.props, value: this.value, viewProps: this.viewProps, }); this.view.inputElement.addEventListener('change', this.onInputChange_); this.view.inputElement.addEventListener('keydown', this.onInputKeyDown_); this.view.inputElement.addEventListener('keyup', this.onInputKeyUp_); const ph = new PointerHandler(this.view.knobElement); ph.emitter.on('down', this.onPointerDown_); ph.emitter.on('move', this.onPointerMove_); ph.emitter.on('up', this.onPointerUp_); } onInputChange_(e) { const inputElem = forceCast(e.currentTarget); const value = inputElem.value; const parsedValue = this.parser_(value); if (!isEmpty(parsedValue)) { this.value.rawValue = parsedValue; } this.view.refresh(); } onInputKeyDown_(ev) { const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue + step, { forceEmit: false, last: false, }); } onInputKeyUp_(ev) { const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); if (step === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } onPointerDown_() { this.originRawValue_ = this.value.rawValue; this.dragging_.rawValue = 0; } computeDraggingValue_(data) { if (!data.point) { return null; } const dx = data.point.x - data.bounds.width / 2; return this.originRawValue_ + dx * this.props.get('draggingScale'); } onPointerMove_(ev) { const v = this.computeDraggingValue_(ev.data); if (v === null) { return; } this.value.setRawValue(v, { forceEmit: false, last: false, }); this.dragging_.rawValue = this.value.rawValue - this.originRawValue_; } onPointerUp_(ev) { const v = this.computeDraggingValue_(ev.data); if (v === null) { return; } this.value.setRawValue(v, { forceEmit: true, last: true, }); this.dragging_.rawValue = null; } } function writePrimitive(target, value) { target.write(value); } function findStep(constraint) { const c = constraint ? findConstraint(constraint, StepConstraint) : null; if (!c) { return null; } return c.step; } function getSuitableDecimalDigits(constraint, rawValue) { const sc = constraint && findConstraint(constraint, StepConstraint); if (sc) { return getDecimalDigits(sc.step); } return Math.max(getDecimalDigits(rawValue), 2); } function getBaseStep(constraint) { const step = findStep(constraint); return step !== null && step !== void 0 ? step : 1; } function getSuitableDraggingScale(constraint, rawValue) { var _a; const sc = constraint && findConstraint(constraint, StepConstraint); const base = Math.abs((_a = sc === null || sc === void 0 ? void 0 : sc.step) !== null && _a !== void 0 ? _a : rawValue); return base === 0 ? 0.1 : Math.pow(10, Math.floor(Math.log10(base)) - 1); } class PointNdConstraint { constructor(config) { this.components = config.components; this.asm_ = config.assembly; } constrain(value) { const comps = this.asm_ .toComponents(value) .map((comp, index) => { var _a, _b; return (_b = (_a = this.components[index]) === null || _a === void 0 ? void 0 : _a.constrain(comp)) !== null && _b !== void 0 ? _b : comp; }); return this.asm_.fromComponents(comps); } } const className$9 = ClassName('pndtxt'); class PointNdTextView { constructor(doc, config) { this.textViews = config.textViews; this.element = doc.createElement('div'); this.element.classList.add(className$9()); this.textViews.forEach((v) => { const axisElem = doc.createElement('div'); axisElem.classList.add(className$9('a')); axisElem.appendChild(v.element); this.element.appendChild(axisElem); }); } } function createAxisController(doc, config, index) { return new NumberTextController(doc, { arrayPosition: index === 0 ? 'fst' : index === config.axes.length - 1 ? 'lst' : 'mid', baseStep: config.axes[index].baseStep, parser: config.parser, props: config.axes[index].textProps, value: createValue(0, { constraint: config.axes[index].constraint, }), viewProps: config.viewProps, }); } class PointNdTextController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.acs_ = config.axes.map((_, index) => createAxisController(doc, config, index)); this.acs_.forEach((c, index) => { connectValues({ primary: this.value, secondary: c.value, forward: (p) => { return config.assembly.toComponents(p.rawValue)[index]; }, backward: (p, s) => { const comps = config.assembly.toComponents(p.rawValue); comps[index] = s.rawValue; return config.assembly.fromComponents(comps); }, }); }); this.view = new PointNdTextView(doc, { textViews: this.acs_.map((ac) => ac.view), }); } } function createStepConstraint(params) { if ('step' in params && !isEmpty(params.step)) { return new StepConstraint(params.step); } return null; } function createRangeConstraint(params) { if (('max' in params && !isEmpty(params.max)) || ('min' in params && !isEmpty(params.min))) { return new RangeConstraint({ max: params.max, min: params.min, }); } return null; } const Constants = { monitor: { defaultInterval: 200, defaultLineCount: 3, }, }; class GraphCursor { constructor() { this.emitter = new Emitter(); this.index_ = -1; } get index() { return this.index_; } set index(index) { const changed = this.index_ !== index; if (changed) { this.index_ = index; this.emitter.emit('change', { index: index, sender: this, }); } } } const className$8 = ClassName('grl'); class GraphLogView { constructor(doc, config) { this.onCursorChange_ = this.onCursorChange_.bind(this); this.onValueUpdate_ = this.onValueUpdate_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className$8()); config.viewProps.bindClassModifiers(this.element); this.formatter_ = config.formatter; this.minValue_ = config.minValue; this.maxValue_ = config.maxValue; this.cursor_ = config.cursor; this.cursor_.emitter.on('change', this.onCursorChange_); const svgElem = doc.createElementNS(SVG_NS, 'svg'); svgElem.classList.add(className$8('g')); svgElem.style.height = `calc(var(--bld-us) * ${config.lineCount})`; this.element.appendChild(svgElem); this.svgElem_ = svgElem; const lineElem = doc.createElementNS(SVG_NS, 'polyline'); this.svgElem_.appendChild(lineElem); this.lineElem_ = lineElem; const tooltipElem = doc.createElement('div'); tooltipElem.classList.add(className$8('t'), ClassName('tt')()); this.element.appendChild(tooltipElem); this.tooltipElem_ = tooltipElem; config.value.emitter.on('change', this.onValueUpdate_); this.value = config.value; this.update_(); } get graphElement() { return this.svgElem_; } update_() { const bounds = this.svgElem_.getBoundingClientRect(); const maxIndex = this.value.rawValue.length - 1; const min = this.minValue_; const max = this.maxValue_; const points = []; this.value.rawValue.forEach((v, index) => { if (v === undefined) { return; } const x = mapRange(index, 0, maxIndex, 0, bounds.width); const y = mapRange(v, min, max, bounds.height, 0); points.push([x, y].join(',')); }); this.lineElem_.setAttributeNS(null, 'points', points.join(' ')); const tooltipElem = this.tooltipElem_; const value = this.value.rawValue[this.cursor_.index]; if (value === undefined) { tooltipElem.classList.remove(className$8('t', 'a')); return; } const tx = mapRange(this.cursor_.index, 0, maxIndex, 0, bounds.width); const ty = mapRange(value, min, max, bounds.height, 0); tooltipElem.style.left = `${tx}px`; tooltipElem.style.top = `${ty}px`; tooltipElem.textContent = `${this.formatter_(value)}`; if (!tooltipElem.classList.contains(className$8('t', 'a'))) { tooltipElem.classList.add(className$8('t', 'a'), className$8('t', 'in')); forceReflow(tooltipElem); tooltipElem.classList.remove(className$8('t', 'in')); } } onValueUpdate_() { this.update_(); } onCursorChange_() { this.update_(); } } class GraphLogController { constructor(doc, config) { this.onGraphMouseMove_ = this.onGraphMouseMove_.bind(this); this.onGraphMouseLeave_ = this.onGraphMouseLeave_.bind(this); this.onGraphPointerDown_ = this.onGraphPointerDown_.bind(this); this.onGraphPointerMove_ = this.onGraphPointerMove_.bind(this); this.onGraphPointerUp_ = this.onGraphPointerUp_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.cursor_ = new GraphCursor(); this.view = new GraphLogView(doc, { cursor: this.cursor_, formatter: config.formatter, lineCount: config.lineCount, maxValue: config.maxValue, minValue: config.minValue, value: this.value, viewProps: this.viewProps, }); if (!supportsTouch(doc)) { this.view.element.addEventListener('mousemove', this.onGraphMouseMove_); this.view.element.addEventListener('mouseleave', this.onGraphMouseLeave_); } else { const ph = new PointerHandler(this.view.element); ph.emitter.on('down', this.onGraphPointerDown_); ph.emitter.on('move', this.onGraphPointerMove_); ph.emitter.on('up', this.onGraphPointerUp_); } } onGraphMouseLeave_() { this.cursor_.index = -1; } onGraphMouseMove_(ev) { const bounds = this.view.element.getBoundingClientRect(); this.cursor_.index = Math.floor(mapRange(ev.offsetX, 0, bounds.width, 0, this.value.rawValue.length)); } onGraphPointerDown_(ev) { this.onGraphPointerMove_(ev); } onGraphPointerMove_(ev) { if (!ev.data.point) { this.cursor_.index = -1; return; } this.cursor_.index = Math.floor(mapRange(ev.data.point.x, 0, ev.data.bounds.width, 0, this.value.rawValue.length)); } onGraphPointerUp_() { this.cursor_.index = -1; } } class ButtonCellApi { constructor(controller) { this.controller_ = controller; } get disabled() { return this.controller_.viewProps.get('disabled'); } set disabled(disabled) { this.controller_.viewProps.set('disabled', disabled); } get title() { var _a; return (_a = this.controller_.props.get('title')) !== null && _a !== void 0 ? _a : ''; } set title(title) { this.controller_.props.set('title', title); } on(eventName, handler) { const bh = handler.bind(this); const emitter = this.controller_.emitter; emitter.on(eventName, () => { bh(new TpEvent(this)); }); return this; } } class TpButtonGridEvent extends TpEvent { constructor(target, cell, index) { super(target); this.cell = cell; this.index = index; } } class ButtonGridApi extends BladeApi { constructor(controller) { super(controller); this.cellToApiMap_ = new Map(); this.emitter_ = new Emitter(); const gc = this.controller_.valueController; gc.cellControllers.forEach((cc, i) => { const api = new ButtonCellApi(cc); this.cellToApiMap_.set(cc, api); cc.emitter.on('click', () => { const x = i % gc.size[0]; const y = Math.floor(i / gc.size[0]); this.emitter_.emit('click', { event: new TpButtonGridEvent(this, api, [x, y]), }); }); }); } cell(x, y) { const gc = this.controller_.valueController; const cc = gc.cellControllers[y * gc.size[0] + x]; return this.cellToApiMap_.get(cc); } on(eventName, handler) { const bh = handler.bind(this); this.emitter_.on(eventName, (ev) => { bh(ev.event); }); return this; } } class ButtonGridController { constructor(doc, config) { this.size = config.size; const [w, h] = this.size; const bcs = []; for (let y = 0; y < h; y++) { for (let x = 0; x < w; x++) { const bc = new ButtonController(doc, { props: ValueMap.fromObject(Object.assign({}, config.cellConfig(x, y))), viewProps: ViewProps.create(), }); bcs.push(bc); } } this.cellCs_ = bcs; this.viewProps = ViewProps.create(); this.viewProps.handleDispose(() => { this.cellCs_.forEach((c) => { c.viewProps.set('disposed', true); }); }); this.view = new PlainView(doc, { viewProps: this.viewProps, viewName: 'btngrid', }); this.view.element.style.gridTemplateColumns = `repeat(${w}, 1fr)`; this.cellCs_.forEach((bc) => { this.view.element.appendChild(bc.view.element); }); } get cellControllers() { return this.cellCs_; } } const ButtonGridBladePlugin = { id: 'buttongrid', type: 'blade', // TODO: css: '.tp-cbzv_b,.tp-rslv_k,.tp-radv_b,.tp-cbzgv{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border-width:0;font-family:inherit;font-size:inherit;font-weight:inherit;margin:0;outline:none;padding:0}.tp-cbzv_b,.tp-rslv_k,.tp-radv_b{background-color:var(--btn-bg);border-radius:var(--elm-br);color:var(--btn-fg);cursor:pointer;display:block;font-weight:bold;height:var(--bld-us);line-height:var(--bld-us);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tp-cbzv_b:hover,.tp-rslv_k:hover,.tp-radv_b:hover{background-color:var(--btn-bg-h)}.tp-cbzv_b:focus,.tp-rslv_k:focus,.tp-radv_b:focus{background-color:var(--btn-bg-f)}.tp-cbzv_b:active,.tp-rslv_k:active,.tp-radv_b:active{background-color:var(--btn-bg-a)}.tp-cbzv_b:disabled,.tp-rslv_k:disabled,.tp-radv_b:disabled{opacity:0.5}.tp-cbzgv{background-color:var(--in-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--in-fg);font-family:inherit;height:var(--bld-us);line-height:var(--bld-us);min-width:0;width:100%}.tp-cbzgv:hover{background-color:var(--in-bg-h)}.tp-cbzgv:focus{background-color:var(--in-bg-f)}.tp-cbzgv:active{background-color:var(--in-bg-a)}.tp-cbzgv:disabled{opacity:0.5}.tp-btngridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-btngridv.tp-v-disabled{opacity:0.5}.tp-btngridv .tp-btnv_b:disabled{opacity:1}.tp-btngridv .tp-btnv_b:disabled .tp-btnv_t{opacity:0.5}.tp-btngridv .tp-btnv_b{border-radius:0}.tp-cbzv{position:relative}.tp-cbzv_h{display:flex}.tp-cbzv_b{margin-right:4px;position:relative;width:var(--bld-us)}.tp-cbzv_b svg{display:block;height:16px;left:50%;margin-left:-8px;margin-top:-8px;position:absolute;top:50%;width:16px}.tp-cbzv_b svg path{stroke:var(--bs-bg);stroke-width:2}.tp-cbzv_t{flex:1}.tp-cbzv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-cbzv.tp-cbzv-expanded .tp-cbzv_p{margin-top:var(--bld-s);opacity:1}.tp-cbzv.tp-cbzv-cpl .tp-cbzv_p{overflow:visible}.tp-cbzv .tp-popv{left:calc(-1 * var(--cnt-h-p));position:absolute;right:calc(-1 * var(--cnt-h-p));top:var(--bld-us)}.tp-cbzpv_t{margin-top:var(--bld-s)}.tp-cbzgv{height:auto;overflow:hidden;position:relative}.tp-cbzgv.tp-v-disabled{opacity:0.5}.tp-cbzgv_p{left:16px;position:absolute;right:16px;top:0}.tp-cbzgv_g{cursor:pointer;display:block;height:calc(var(--bld-us) * 5);width:100%}.tp-cbzgv_u{opacity:0.1;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_l{fill:transparent;stroke:var(--in-fg)}.tp-cbzgv_v{opacity:0.5;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_h{border:var(--in-fg) solid 1px;border-radius:50%;box-sizing:border-box;height:4px;margin-left:-2px;margin-top:-2px;pointer-events:none;position:absolute;width:4px}.tp-cbzgv:focus .tp-cbzgv_h-sel{background-color:var(--in-fg);border-width:0}.tp-cbzprvv{cursor:pointer;height:4px;padding:4px 0;position:relative}.tp-cbzprvv_g{display:block;height:100%;overflow:visible;width:100%}.tp-cbzprvv_t{opacity:0.5;stroke:var(--mo-fg)}.tp-cbzprvv_m{background-color:var(--mo-fg);border-radius:50%;height:4px;margin-left:-2px;margin-top:-2px;opacity:0;position:absolute;top:50%;transition:opacity 0.2s ease-out;width:4px}.tp-cbzprvv_m.tp-cbzprvv_m-a{opacity:1}.tp-fpsv{position:relative}.tp-fpsv_l{bottom:4px;color:var(--mo-fg);line-height:1;right:4px;pointer-events:none;position:absolute}.tp-fpsv_u{margin-left:0.2em;opacity:0.7}.tp-rslv{cursor:pointer;padding-left:8px;padding-right:8px}.tp-rslv.tp-v-disabled{opacity:0.5}.tp-rslv_t{height:calc(var(--bld-us));position:relative}.tp-rslv_t::before{background-color:var(--in-bg);border-radius:1px;content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:-4px;right:-4px}.tp-rslv_b{bottom:0;top:0;position:absolute}.tp-rslv_b::before{background-color:var(--in-fg);content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:0;right:0}.tp-rslv_k{height:calc(var(--bld-us) - 8px);margin-top:calc((var(--bld-us) - 8px) / -2);position:absolute;top:50%;width:8px}.tp-rslv_k.tp-rslv_k-min{margin-left:-8px}.tp-rslv_k.tp-rslv_k-max{margin-left:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-min{border-bottom-right-radius:0;border-top-right-radius:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-max{border-bottom-left-radius:0;border-top-left-radius:0}.tp-rsltxtv{display:flex}.tp-rsltxtv_s{flex:1}.tp-rsltxtv_t{flex:1;margin-left:4px}.tp-radv_l{display:block;position:relative}.tp-radv_i{left:0;opacity:0;position:absolute;top:0}.tp-radv_b{opacity:0.5}.tp-radv_i:hover+.tp-radv_b{background-color:var(--btn-bg-h)}.tp-radv_i:focus+.tp-radv_b{background-color:var(--btn-bg-f)}.tp-radv_i:active+.tp-radv_b{background-color:var(--btn-bg-a)}.tp-radv_i:checked+.tp-radv_b{opacity:1}.tp-radv_t{bottom:0;color:inherit;left:0;overflow:hidden;position:absolute;right:0;text-align:center;text-overflow:ellipsis;top:0}.tp-radv_i:disabled+.tp-radv_b>.tp-radv_t{opacity:0.5}.tp-radgridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-radgridv.tp-v-disabled{opacity:0.5}.tp-radgridv .tp-radv_b{border-radius:0}', accept(params) { const p = ParamsParsers; const result = parseParams(params, { cells: p.required.function, size: p.required.array(p.required.number), view: p.required.constant('buttongrid'), label: p.optional.string, }); return result ? { params: result } : null; }, controller(args) { return new LabelController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: new ButtonGridController(args.document, { cellConfig: args.params.cells, size: args.params.size, }), }); }, api(args) { if (!(args.controller instanceof LabelController)) { return null; } if (!(args.controller.valueController instanceof ButtonGridController)) { return null; } return new ButtonGridApi(args.controller); }, }; class CubicBezierApi extends BladeApi { get label() { return this.controller_.props.get('label'); } set label(label) { this.controller_.props.set('label', label); } get value() { return this.controller_.valueController.value.rawValue; } set value(value) { this.controller_.valueController.value.rawValue = value; } on(eventName, handler) { const bh = handler.bind(this); this.controller_.valueController.value.emitter.on(eventName, (ev) => { bh(new TpChangeEvent(this, ev.rawValue, undefined, ev.options.last)); }); return this; } } function interpolate(x1, x2, t) { return x1 * (1 - t) + x2 * t; } const MAX_ITERATION = 20; const X_DELTA = 0.001; const CACHE_RESOLUTION = 100; function y(cb, x) { let dt = 0.25; let t = 0.5; let y = -1; for (let i = 0; i < MAX_ITERATION; i++) { const [tx, ty] = cb.curve(t); t += dt * (tx < x ? +1 : -1); y = ty; dt *= 0.5; if (Math.abs(x - tx) < X_DELTA) { break; } } return y; } class CubicBezier { constructor(x1 = 0, y1 = 0, x2 = 1, y2 = 1) { this.cache_ = []; this.comps_ = [x1, y1, x2, y2]; } get x1() { return this.comps_[0]; } get y1() { return this.comps_[1]; } get x2() { return this.comps_[2]; } get y2() { return this.comps_[3]; } static isObject(obj) { if (isEmpty(obj)) { return false; } if (!Array.isArray(obj)) { return false; } return (typeof obj[0] === 'number' && typeof obj[1] === 'number' && typeof obj[2] === 'number' && typeof obj[3] === 'number'); } static equals(v1, v2) { return (v1.x1 === v2.x1 && v1.y1 === v2.y1 && v1.x2 === v2.x2 && v1.y2 === v2.y2); } curve(t) { const x01 = interpolate(0, this.x1, t); const y01 = interpolate(0, this.y1, t); const x12 = interpolate(this.x1, this.x2, t); const y12 = interpolate(this.y1, this.y2, t); const x23 = interpolate(this.x2, 1, t); const y23 = interpolate(this.y2, 1, t); const xr0 = interpolate(x01, x12, t); const yr0 = interpolate(y01, y12, t); const xr1 = interpolate(x12, x23, t); const yr1 = interpolate(y12, y23, t); return [interpolate(xr0, xr1, t), interpolate(yr0, yr1, t)]; } y(x) { if (this.cache_.length === 0) { const cache = []; for (let i = 0; i < CACHE_RESOLUTION; i++) { cache.push(y(this, mapRange(i, 0, CACHE_RESOLUTION - 1, 0, 1))); } this.cache_ = cache; } return this.cache_[Math.round(mapRange(constrainRange(x, 0, 1), 0, 1, 0, CACHE_RESOLUTION - 1))]; } toObject() { return [this.comps_[0], this.comps_[1], this.comps_[2], this.comps_[3]]; } } const CubicBezierAssembly = { toComponents: (p) => p.toObject(), fromComponents: (comps) => new CubicBezier(...comps), }; function cubicBezierToString(cb) { const formatter = createNumberFormatter(2); const comps = cb.toObject().map((c) => formatter(c)); return `cubic-bezier(${comps.join(', ')})`; } const COMPS_EMPTY = [0, 0.5, 0.5, 1]; function cubicBezierFromString(text) { const m = text.match(/^cubic-bezier\s*$\s*([0-9.]+)\s*,\s*([0-9.]+)\s*,\s*([0-9.]+)\s*,\s*([0-9.]+)\s*$$/); if (!m) { return new CubicBezier(...COMPS_EMPTY); } const comps = [m[1], m[2], m[3], m[4]].reduce((comps, comp) => { if (!comps) { return null; } const n = Number(comp); if (isNaN(n)) { return null; } return [...comps, n]; }, []); return new CubicBezier(...(comps !== null && comps !== void 0 ? comps : COMPS_EMPTY)); } const className$7 = ClassName('cbz'); class CubicBezierView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$7()); config.viewProps.bindClassModifiers(this.element); config.foldable.bindExpandedClass(this.element, className$7(undefined, 'expanded')); bindValueMap(config.foldable, 'completed', valueToClassName(this.element, className$7(undefined, 'cpl'))); const headElem = doc.createElement('div'); headElem.classList.add(className$7('h')); this.element.appendChild(headElem); const buttonElem = doc.createElement('button'); buttonElem.classList.add(className$7('b')); config.viewProps.bindDisabled(buttonElem); const iconElem = doc.createElementNS(SVG_NS, 'svg'); iconElem.innerHTML = ''; buttonElem.appendChild(iconElem); headElem.appendChild(buttonElem); this.buttonElement = buttonElem; const textElem = doc.createElement('div'); textElem.classList.add(className$7('t')); headElem.appendChild(textElem); this.textElement = textElem; if (config.pickerLayout === 'inline') { const pickerElem = doc.createElement('div'); pickerElem.classList.add(className$7('p')); this.element.appendChild(pickerElem); this.pickerElement = pickerElem; } else { this.pickerElement = null; } } } const className$6 = ClassName('cbzp'); class CubicBezierPickerView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$6()); config.viewProps.bindClassModifiers(this.element); const graphElem = doc.createElement('div'); graphElem.classList.add(className$6('g')); this.element.appendChild(graphElem); this.graphElement = graphElem; const textElem = doc.createElement('div'); textElem.classList.add(className$6('t')); this.element.appendChild(textElem); this.textElement = textElem; } } function waitToBeAddedToDom(elem, callback) { const ob = new MutationObserver((ml) => { for (const m of ml) { if (m.type !== 'childList') { continue; } m.addedNodes.forEach((elem) => { if (!elem.contains(elem)) { return; } callback(); ob.disconnect(); }); } }); const doc = elem.ownerDocument; ob.observe(doc.body, { attributes: true, childList: true, subtree: true, }); } const className$5 = ClassName('cbzg'); // TODO: Apply to core function compose(h1, h2) { return (input) => h2(h1(input)); } class CubicBezierGraphView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$5()); config.viewProps.bindClassModifiers(this.element); config.viewProps.bindTabIndex(this.element); const previewElem = doc.createElement('div'); previewElem.classList.add(className$5('p')); this.element.appendChild(previewElem); this.previewElement = previewElem; const svgElem = doc.createElementNS(SVG_NS, 'svg'); svgElem.classList.add(className$5('g')); this.element.appendChild(svgElem); this.svgElem_ = svgElem; const guideElem = doc.createElementNS(SVG_NS, 'path'); guideElem.classList.add(className$5('u')); this.svgElem_.appendChild(guideElem); this.guideElem_ = guideElem; const lineElem = doc.createElementNS(SVG_NS, 'polyline'); lineElem.classList.add(className$5('l')); this.svgElem_.appendChild(lineElem); this.lineElem_ = lineElem; this.handleElems_ = [doc.createElement('div'), doc.createElement('div')]; this.handleElems_.forEach((elem) => { elem.classList.add(className$5('h')); this.element.appendChild(elem); }); this.vectorElems_ = [ doc.createElementNS(SVG_NS, 'line'), doc.createElementNS(SVG_NS, 'line'), ]; this.vectorElems_.forEach((elem) => { elem.classList.add(className$5('v')); this.svgElem_.appendChild(elem); }); this.value_ = config.value; this.value_.emitter.on('change', this.onValueChange_.bind(this)); this.sel_ = config.selection; this.handleElems_.forEach((elem, index) => { bindValue(this.sel_, compose((selection) => selection === index, valueToClassName(elem, className$5('h', 'sel')))); }); waitToBeAddedToDom(this.element, () => { this.refresh(); }); } getVertMargin_(h) { return h * 0.25; } valueToPosition(x, y) { const bounds = this.element.getBoundingClientRect(); const w = bounds.width; const h = bounds.height; const vm = this.getVertMargin_(h); return { x: mapRange(x, 0, 1, 0, w), y: mapRange(y, 0, 1, h - vm, vm), }; } positionToValue(x, y) { const bounds = this.element.getBoundingClientRect(); const w = bounds.width; const h = bounds.height; const vm = this.getVertMargin_(h); return { x: constrainRange(mapRange(x, 0, w, 0, 1), 0, 1), y: mapRange(y, h - vm, vm, 0, 1), }; } refresh() { this.guideElem_.setAttributeNS(null, 'd', [0, 1] .map((index) => { const p1 = this.valueToPosition(0, index); const p2 = this.valueToPosition(1, index); return [`M ${p1.x},${p1.y}`, `L ${p2.x},${p2.y}`].join(' '); }) .join(' ')); const bezier = this.value_.rawValue; const points = []; let t = 0; for (;;) { const p = this.valueToPosition(...bezier.curve(t)); points.push([p.x, p.y].join(',')); if (t >= 1) { break; } t = Math.min(t + 0.05, 1); } this.lineElem_.setAttributeNS(null, 'points', points.join(' ')); const obj = bezier.toObject(); [0, 1].forEach((index) => { const p1 = this.valueToPosition(index, index); const p2 = this.valueToPosition(obj[index * 2], obj[index * 2 + 1]); const vElem = this.vectorElems_[index]; vElem.setAttributeNS(null, 'x1', String(p1.x)); vElem.setAttributeNS(null, 'y1', String(p1.y)); vElem.setAttributeNS(null, 'x2', String(p2.x)); vElem.setAttributeNS(null, 'y2', String(p2.y)); const hElem = this.handleElems_[index]; hElem.style.left = `${p2.x}px`; hElem.style.top = `${p2.y}px`; }); } onValueChange_() { this.refresh(); } } const TICK_COUNT = 24; const PREVIEW_DELAY = 400; const PREVIEW_DURATION = 1000; const className$4 = ClassName('cbzprv'); class CubicBezierPreviewView { constructor(doc, config) { this.stopped_ = true; this.startTime_ = -1; this.onDispose_ = this.onDispose_.bind(this); this.onTimer_ = this.onTimer_.bind(this); this.onValueChange_ = this.onValueChange_.bind(this); this.element = doc.createElement('div'); this.element.classList.add(className$4()); config.viewProps.bindClassModifiers(this.element); const svgElem = doc.createElementNS(SVG_NS, 'svg'); svgElem.classList.add(className$4('g')); this.element.appendChild(svgElem); this.svgElem_ = svgElem; const ticksElem = doc.createElementNS(SVG_NS, 'path'); ticksElem.classList.add(className$4('t')); this.svgElem_.appendChild(ticksElem); this.ticksElem_ = ticksElem; const markerElem = doc.createElement('div'); markerElem.classList.add(className$4('m')); this.element.appendChild(markerElem); this.markerElem_ = markerElem; this.value_ = config.value; this.value_.emitter.on('change', this.onValueChange_); config.viewProps.handleDispose(this.onDispose_); waitToBeAddedToDom(this.element, () => { this.refresh(); }); } play() { this.stop(); this.updateMarker_(0); this.markerElem_.classList.add(className$4('m', 'a')); this.startTime_ = new Date().getTime() + PREVIEW_DELAY; this.stopped_ = false; requestAnimationFrame(this.onTimer_); } stop() { this.stopped_ = true; this.markerElem_.classList.remove(className$4('m', 'a')); } onDispose_() { this.stop(); } updateMarker_(progress) { const p = this.value_.rawValue.y(constrainRange(progress, 0, 1)); this.markerElem_.style.left = `${p * 100}%`; } refresh() { const bounds = this.svgElem_.getBoundingClientRect(); const w = bounds.width; const h = bounds.height; const ds = []; const bezier = this.value_.rawValue; for (let i = 0; i < TICK_COUNT; i++) { const px = mapRange(i, 0, TICK_COUNT - 1, 0, 1); const x = mapRange(bezier.y(px), 0, 1, 0, w); ds.push(`M ${x},0 v${h}`); } this.ticksElem_.setAttributeNS(null, 'd', ds.join(' ')); } onTimer_() { if (this.startTime_ === null) { return; } const dt = new Date().getTime() - this.startTime_; const p = dt / PREVIEW_DURATION; this.updateMarker_(p); if (dt > PREVIEW_DURATION + PREVIEW_DELAY) { this.stop(); } if (!this.stopped_) { requestAnimationFrame(this.onTimer_); } } onValueChange_() { this.refresh(); this.play(); } } function getDistance(x1, y1, x2, y2) { const dx = x2 - x1; const dy = y2 - y1; return Math.sqrt(dx * dx + dy * dy); } function lockAngle(x1, y1, x2, y2) { const d = getDistance(x1, y1, x2, y2); const a = Math.atan2(y2 - y1, x2 - x1); const la = (Math.round(a / (Math.PI / 4)) * Math.PI) / 4; return { x: x1 + Math.cos(la) * d, y: y1 + Math.sin(la) * d, }; } class CubicBezierGraphController { constructor(doc, config) { this.onKeyDown_ = this.onKeyDown_.bind(this); this.onKeyUp_ = this.onKeyUp_.bind(this); this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.baseStep_ = config.baseStep; this.value = config.value; this.sel_ = createValue(0); this.viewProps = config.viewProps; this.view = new CubicBezierGraphView(doc, { selection: this.sel_, value: this.value, viewProps: this.viewProps, }); this.view.element.addEventListener('keydown', this.onKeyDown_); this.view.element.addEventListener('keyup', this.onKeyUp_); this.prevView_ = new CubicBezierPreviewView(doc, { value: this.value, viewProps: this.viewProps, }); this.prevView_.element.addEventListener('mousedown', (ev) => { ev.stopImmediatePropagation(); ev.preventDefault(); this.prevView_.play(); }); this.view.previewElement.appendChild(this.prevView_.element); const ptHandler = new PointerHandler(this.view.element); ptHandler.emitter.on('down', this.onPointerDown_); ptHandler.emitter.on('move', this.onPointerMove_); ptHandler.emitter.on('up', this.onPointerUp_); } refresh() { this.view.refresh(); this.prevView_.refresh(); this.prevView_.play(); } updateValue_(point, locksAngle, opts) { const index = this.sel_.rawValue; const comps = this.value.rawValue.toObject(); const vp = this.view.positionToValue(point.x, point.y); const v = locksAngle ? lockAngle(index, index, vp.x, vp.y) : vp; comps[index * 2] = v.x; comps[index * 2 + 1] = v.y; this.value.setRawValue(new CubicBezier(...comps), opts); } onPointerDown_(ev) { const data = ev.data; if (!data.point) { return; } const bezier = this.value.rawValue; const p1 = this.view.valueToPosition(bezier.x1, bezier.y1); const d1 = getDistance(data.point.x, data.point.y, p1.x, p1.y); const p2 = this.view.valueToPosition(bezier.x2, bezier.y2); const d2 = getDistance(data.point.x, data.point.y, p2.x, p2.y); this.sel_.rawValue = d1 <= d2 ? 0 : 1; this.updateValue_(data.point, ev.shiftKey, { forceEmit: false, last: false, }); } onPointerMove_(ev) { const data = ev.data; if (!data.point) { return; } this.updateValue_(data.point, ev.shiftKey, { forceEmit: false, last: false, }); } onPointerUp_(ev) { const data = ev.data; if (!data.point) { return; } this.updateValue_(data.point, ev.shiftKey, { forceEmit: true, last: true, }); } onKeyDown_(ev) { if (isArrowKey(ev.key)) { ev.preventDefault(); } const index = this.sel_.rawValue; const comps = this.value.rawValue.toObject(); comps[index * 2] += getStepForKey(this.baseStep_, getHorizontalStepKeys(ev)); comps[index * 2 + 1] += getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); this.value.setRawValue(new CubicBezier(...comps), { forceEmit: false, last: false, }); } onKeyUp_(ev) { if (isArrowKey(ev.key)) { ev.preventDefault(); } const xStep = getStepForKey(this.baseStep_, getHorizontalStepKeys(ev)); const yStep = getStepForKey(this.baseStep_, getVerticalStepKeys(ev)); if (xStep === 0 && yStep === 0) { return; } this.value.setRawValue(this.value.rawValue, { forceEmit: true, last: true, }); } } class CubicBezierPickerController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.view = new CubicBezierPickerView(doc, { viewProps: this.viewProps, }); this.gc_ = new CubicBezierGraphController(doc, { baseStep: config.axis.baseStep, value: this.value, viewProps: this.viewProps, }); this.view.graphElement.appendChild(this.gc_.view.element); const xAxis = Object.assign(Object.assign({}, config.axis), { constraint: new RangeConstraint({ max: 1, min: 0 }) }); const yAxis = Object.assign(Object.assign({}, config.axis), { constraint: undefined }); this.tc_ = new PointNdTextController(doc, { assembly: CubicBezierAssembly, axes: [xAxis, yAxis, xAxis, yAxis], parser: parseNumber, value: this.value, viewProps: this.viewProps, }); this.view.textElement.appendChild(this.tc_.view.element); } get allFocusableElements() { return [ this.gc_.view.element, ...this.tc_.view.textViews.map((v) => v.inputElement), ]; } refresh() { this.gc_.refresh(); } } class CubicBezierController { constructor(doc, config) { this.onButtonBlur_ = this.onButtonBlur_.bind(this); this.onButtonClick_ = this.onButtonClick_.bind(this); this.onPopupChildBlur_ = this.onPopupChildBlur_.bind(this); this.onPopupChildKeydown_ = this.onPopupChildKeydown_.bind(this); this.value = config.value; this.viewProps = config.viewProps; this.foldable_ = createFoldable(config.expanded); this.view = new CubicBezierView(doc, { foldable: this.foldable_, pickerLayout: config.pickerLayout, viewProps: this.viewProps, }); this.view.buttonElement.addEventListener('blur', this.onButtonBlur_); this.view.buttonElement.addEventListener('click', this.onButtonClick_); this.tc_ = new TextController(doc, { parser: cubicBezierFromString, props: ValueMap.fromObject({ formatter: cubicBezierToString, }), value: this.value, viewProps: this.viewProps, }); this.view.textElement.appendChild(this.tc_.view.element); this.popC_ = config.pickerLayout === 'popup' ? new PopupController(doc, { viewProps: this.viewProps, }) : null; const pickerC = new CubicBezierPickerController(doc, { axis: config.axis, value: this.value, viewProps: this.viewProps, }); pickerC.allFocusableElements.forEach((elem) => { elem.addEventListener('blur', this.onPopupChildBlur_); elem.addEventListener('keydown', this.onPopupChildKeydown_); }); this.pickerC_ = pickerC; if (this.popC_) { this.view.element.appendChild(this.popC_.view.element); this.popC_.view.element.appendChild(this.pickerC_.view.element); bindValue(this.popC_.shows, (shows) => { if (shows) { pickerC.refresh(); } }); connectValues({ primary: this.foldable_.value('expanded'), secondary: this.popC_.shows, forward: (p) => p.rawValue, backward: (_, s) => s.rawValue, }); } else if (this.view.pickerElement) { this.view.pickerElement.appendChild(this.pickerC_.view.element); bindFoldable(this.foldable_, this.view.pickerElement); } } onButtonBlur_(ev) { if (!this.popC_) { return; } const nextTarget = forceCast(ev.relatedTarget); if (!nextTarget || !this.popC_.view.element.contains(nextTarget)) { this.popC_.shows.rawValue = false; } } onButtonClick_() { this.foldable_.set('expanded', !this.foldable_.get('expanded')); if (this.foldable_.get('expanded')) { this.pickerC_.allFocusableElements[0].focus(); } } onPopupChildBlur_(ev) { if (!this.popC_) { return; } const elem = this.popC_.view.element; const nextTarget = findNextTarget(ev); if (nextTarget && elem.contains(nextTarget)) { // Next target is in the popup return; } if (nextTarget && nextTarget === this.view.buttonElement && !supportsTouch(elem.ownerDocument)) { // Next target is the trigger button return; } this.popC_.shows.rawValue = false; } onPopupChildKeydown_(ev) { if (!this.popC_) { return; } if (ev.key === 'Escape') { this.popC_.shows.rawValue = false; } } } function createConstraint$1() { return new PointNdConstraint({ assembly: CubicBezierAssembly, components: [0, 1, 2, 3].map((index) => index % 2 === 0 ? new RangeConstraint({ min: 0, max: 1, }) : undefined), }); } const CubicBezierBladePlugin = { id: 'cubic-bezier', type: 'blade', css: '.tp-cbzv_b,.tp-rslv_k,.tp-radv_b,.tp-cbzgv{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border-width:0;font-family:inherit;font-size:inherit;font-weight:inherit;margin:0;outline:none;padding:0}.tp-cbzv_b,.tp-rslv_k,.tp-radv_b{background-color:var(--btn-bg);border-radius:var(--elm-br);color:var(--btn-fg);cursor:pointer;display:block;font-weight:bold;height:var(--bld-us);line-height:var(--bld-us);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tp-cbzv_b:hover,.tp-rslv_k:hover,.tp-radv_b:hover{background-color:var(--btn-bg-h)}.tp-cbzv_b:focus,.tp-rslv_k:focus,.tp-radv_b:focus{background-color:var(--btn-bg-f)}.tp-cbzv_b:active,.tp-rslv_k:active,.tp-radv_b:active{background-color:var(--btn-bg-a)}.tp-cbzv_b:disabled,.tp-rslv_k:disabled,.tp-radv_b:disabled{opacity:0.5}.tp-cbzgv{background-color:var(--in-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--in-fg);font-family:inherit;height:var(--bld-us);line-height:var(--bld-us);min-width:0;width:100%}.tp-cbzgv:hover{background-color:var(--in-bg-h)}.tp-cbzgv:focus{background-color:var(--in-bg-f)}.tp-cbzgv:active{background-color:var(--in-bg-a)}.tp-cbzgv:disabled{opacity:0.5}.tp-btngridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-btngridv.tp-v-disabled{opacity:0.5}.tp-btngridv .tp-btnv_b:disabled{opacity:1}.tp-btngridv .tp-btnv_b:disabled .tp-btnv_t{opacity:0.5}.tp-btngridv .tp-btnv_b{border-radius:0}.tp-cbzv{position:relative}.tp-cbzv_h{display:flex}.tp-cbzv_b{margin-right:4px;position:relative;width:var(--bld-us)}.tp-cbzv_b svg{display:block;height:16px;left:50%;margin-left:-8px;margin-top:-8px;position:absolute;top:50%;width:16px}.tp-cbzv_b svg path{stroke:var(--bs-bg);stroke-width:2}.tp-cbzv_t{flex:1}.tp-cbzv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-cbzv.tp-cbzv-expanded .tp-cbzv_p{margin-top:var(--bld-s);opacity:1}.tp-cbzv.tp-cbzv-cpl .tp-cbzv_p{overflow:visible}.tp-cbzv .tp-popv{left:calc(-1 * var(--cnt-h-p));position:absolute;right:calc(-1 * var(--cnt-h-p));top:var(--bld-us)}.tp-cbzpv_t{margin-top:var(--bld-s)}.tp-cbzgv{height:auto;overflow:hidden;position:relative}.tp-cbzgv.tp-v-disabled{opacity:0.5}.tp-cbzgv_p{left:16px;position:absolute;right:16px;top:0}.tp-cbzgv_g{cursor:pointer;display:block;height:calc(var(--bld-us) * 5);width:100%}.tp-cbzgv_u{opacity:0.1;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_l{fill:transparent;stroke:var(--in-fg)}.tp-cbzgv_v{opacity:0.5;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_h{border:var(--in-fg) solid 1px;border-radius:50%;box-sizing:border-box;height:4px;margin-left:-2px;margin-top:-2px;pointer-events:none;position:absolute;width:4px}.tp-cbzgv:focus .tp-cbzgv_h-sel{background-color:var(--in-fg);border-width:0}.tp-cbzprvv{cursor:pointer;height:4px;padding:4px 0;position:relative}.tp-cbzprvv_g{display:block;height:100%;overflow:visible;width:100%}.tp-cbzprvv_t{opacity:0.5;stroke:var(--mo-fg)}.tp-cbzprvv_m{background-color:var(--mo-fg);border-radius:50%;height:4px;margin-left:-2px;margin-top:-2px;opacity:0;position:absolute;top:50%;transition:opacity 0.2s ease-out;width:4px}.tp-cbzprvv_m.tp-cbzprvv_m-a{opacity:1}.tp-fpsv{position:relative}.tp-fpsv_l{bottom:4px;color:var(--mo-fg);line-height:1;right:4px;pointer-events:none;position:absolute}.tp-fpsv_u{margin-left:0.2em;opacity:0.7}.tp-rslv{cursor:pointer;padding-left:8px;padding-right:8px}.tp-rslv.tp-v-disabled{opacity:0.5}.tp-rslv_t{height:calc(var(--bld-us));position:relative}.tp-rslv_t::before{background-color:var(--in-bg);border-radius:1px;content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:-4px;right:-4px}.tp-rslv_b{bottom:0;top:0;position:absolute}.tp-rslv_b::before{background-color:var(--in-fg);content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:0;right:0}.tp-rslv_k{height:calc(var(--bld-us) - 8px);margin-top:calc((var(--bld-us) - 8px) / -2);position:absolute;top:50%;width:8px}.tp-rslv_k.tp-rslv_k-min{margin-left:-8px}.tp-rslv_k.tp-rslv_k-max{margin-left:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-min{border-bottom-right-radius:0;border-top-right-radius:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-max{border-bottom-left-radius:0;border-top-left-radius:0}.tp-rsltxtv{display:flex}.tp-rsltxtv_s{flex:1}.tp-rsltxtv_t{flex:1;margin-left:4px}.tp-radv_l{display:block;position:relative}.tp-radv_i{left:0;opacity:0;position:absolute;top:0}.tp-radv_b{opacity:0.5}.tp-radv_i:hover+.tp-radv_b{background-color:var(--btn-bg-h)}.tp-radv_i:focus+.tp-radv_b{background-color:var(--btn-bg-f)}.tp-radv_i:active+.tp-radv_b{background-color:var(--btn-bg-a)}.tp-radv_i:checked+.tp-radv_b{opacity:1}.tp-radv_t{bottom:0;color:inherit;left:0;overflow:hidden;position:absolute;right:0;text-align:center;text-overflow:ellipsis;top:0}.tp-radv_i:disabled+.tp-radv_b>.tp-radv_t{opacity:0.5}.tp-radgridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-radgridv.tp-v-disabled{opacity:0.5}.tp-radgridv .tp-radv_b{border-radius:0}', accept(params) { const p = ParamsParsers; const result = parseParams(params, { value: p.required.array(p.required.number), view: p.required.constant('cubicbezier'), expanded: p.optional.boolean, label: p.optional.string, picker: p.optional.custom((v) => { return v === 'inline' || v === 'popup' ? v : undefined; }), }); return result ? { params: result } : null; }, controller(args) { var _a, _b; const rv = new CubicBezier(...args.params.value); const v = createValue(rv, { constraint: createConstraint$1(), equals: CubicBezier.equals, }); const vc = new CubicBezierController(args.document, { axis: { baseStep: 0.1, textProps: ValueMap.fromObject({ draggingScale: 0.01, formatter: createNumberFormatter(2), }), }, expanded: (_a = args.params.expanded) !== null && _a !== void 0 ? _a : false, pickerLayout: (_b = args.params.picker) !== null && _b !== void 0 ? _b : 'popup', value: v, viewProps: args.viewProps, }); return new LabeledValueController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: vc, }); }, api(args) { if (!(args.controller instanceof LabeledValueController)) { return null; } if (!(args.controller.valueController instanceof CubicBezierController)) { return null; } return new CubicBezierApi(args.controller); }, }; class FpsGraphBladeApi extends BladeApi { begin() { this.controller_.valueController.begin(); } end() { this.controller_.valueController.end(); } } const MAX_TIMESTAMPS = 20; class Fpswatch { constructor() { this.start_ = null; this.duration_ = 0; this.fps_ = null; this.frameCount_ = 0; this.timestamps_ = []; } get duration() { return this.duration_; } get fps() { return this.fps_; } begin(now) { this.start_ = now.getTime(); } calculateFps_(nowTime) { if (this.timestamps_.length === 0) { return null; } const ts = this.timestamps_[0]; return (1000 * (this.frameCount_ - ts.frameCount)) / (nowTime - ts.time); } compactTimestamps_() { if (this.timestamps_.length <= MAX_TIMESTAMPS) { return; } const len = this.timestamps_.length - MAX_TIMESTAMPS; this.timestamps_.splice(0, len); const df = this.timestamps_[0].frameCount; this.timestamps_.forEach((ts) => { ts.frameCount -= df; }); this.frameCount_ -= df; } end(now) { if (this.start_ === null) { return; } const t = now.getTime(); this.duration_ = t - this.start_; this.start_ = null; this.fps_ = this.calculateFps_(t); this.timestamps_.push({ frameCount: this.frameCount_, time: t, }); ++this.frameCount_; this.compactTimestamps_(); } } const className$3 = ClassName('fps'); class FpsView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className$3()); config.viewProps.bindClassModifiers(this.element); this.graphElement = doc.createElement('div'); this.graphElement.classList.add(className$3('g')); this.element.appendChild(this.graphElement); const labelElement = doc.createElement('div'); labelElement.classList.add(className$3('l')); this.element.appendChild(labelElement); const valueElement = doc.createElement('span'); valueElement.classList.add(className$3('v')); valueElement.textContent = '--'; labelElement.appendChild(valueElement); this.valueElement = valueElement; const unitElement = doc.createElement('span'); unitElement.classList.add(className$3('u')); unitElement.textContent = 'FPS'; labelElement.appendChild(unitElement); } } class FpsGraphController { constructor(doc, config) { this.stopwatch_ = new Fpswatch(); this.onTick_ = this.onTick_.bind(this); this.ticker_ = config.ticker; this.ticker_.emitter.on('tick', this.onTick_); this.value_ = config.value; this.viewProps = config.viewProps; this.view = new FpsView(doc, { viewProps: this.viewProps, }); this.graphC_ = new GraphLogController(doc, { formatter: createNumberFormatter(0), lineCount: config.lineCount, maxValue: config.maxValue, minValue: config.minValue, value: this.value_, viewProps: this.viewProps, }); this.view.graphElement.appendChild(this.graphC_.view.element); this.viewProps.handleDispose(() => { this.graphC_.viewProps.set('disposed', true); this.ticker_.dispose(); }); } begin() { this.stopwatch_.begin(new Date()); } end() { this.stopwatch_.end(new Date()); } onTick_() { const fps = this.stopwatch_.fps; if (fps !== null) { const buffer = this.value_.rawValue; this.value_.rawValue = createPushedBuffer(buffer, fps); this.view.valueElement.textContent = fps.toFixed(0); } } } function createTicker(document, interval) { return interval === 0 ? new ManualTicker() : new IntervalTicker(document, interval !== null && interval !== void 0 ? interval : Constants.monitor.defaultInterval); } const FpsGraphBladePlugin = { id: 'fpsgraph', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { view: p.required.constant('fpsgraph'), interval: p.optional.number, label: p.optional.string, lineCount: p.optional.number, max: p.optional.number, min: p.optional.number, }); return result ? { params: result } : null; }, controller(args) { var _a, _b, _c, _d; const interval = (_a = args.params.interval) !== null && _a !== void 0 ? _a : 500; return new LabelController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: new FpsGraphController(args.document, { lineCount: (_b = args.params.lineCount) !== null && _b !== void 0 ? _b : 2, maxValue: (_c = args.params.max) !== null && _c !== void 0 ? _c : 90, minValue: (_d = args.params.min) !== null && _d !== void 0 ? _d : 0, ticker: createTicker(args.document, interval), value: initializeBuffer(80), viewProps: args.viewProps, }), }); }, api(args) { if (!(args.controller instanceof LabelController)) { return null; } if (!(args.controller.valueController instanceof FpsGraphController)) { return null; } return new FpsGraphBladeApi(args.controller); }, }; class Interval { constructor(min, max) { this.min = min; this.max = max; } static isObject(obj) { if (typeof obj !== 'object' || obj === null) { return false; } const min = obj.min; const max = obj.max; if (typeof min !== 'number' || typeof max !== 'number') { return false; } return true; } static equals(v1, v2) { return v1.min === v2.min && v1.max === v2.max; } get length() { return this.max - this.min; } toObject() { return { min: this.min, max: this.max, }; } } const IntervalAssembly = { fromComponents: (comps) => new Interval(comps[0], comps[1]), toComponents: (p) => [p.min, p.max], }; class IntervalConstraint { constructor(edge) { this.edge = edge; } constrain(value) { var _a, _b, _c, _d, _e, _f, _g, _h; if (value.min <= value.max) { return new Interval((_b = (_a = this.edge) === null || _a === void 0 ? void 0 : _a.constrain(value.min)) !== null && _b !== void 0 ? _b : value.min, (_d = (_c = this.edge) === null || _c === void 0 ? void 0 : _c.constrain(value.max)) !== null && _d !== void 0 ? _d : value.max); } const c = (value.min + value.max) / 2; return new Interval((_f = (_e = this.edge) === null || _e === void 0 ? void 0 : _e.constrain(c)) !== null && _f !== void 0 ? _f : c, (_h = (_g = this.edge) === null || _g === void 0 ? void 0 : _g.constrain(c)) !== null && _h !== void 0 ? _h : c); } } const className$2 = ClassName('rsltxt'); class RangeSliderTextView { constructor(doc, config) { this.sliderView_ = config.sliderView; this.textView_ = config.textView; this.element = doc.createElement('div'); this.element.classList.add(className$2()); const sliderElem = doc.createElement('div'); sliderElem.classList.add(className$2('s')); sliderElem.appendChild(this.sliderView_.element); this.element.appendChild(sliderElem); const textElem = doc.createElement('div'); textElem.classList.add(className$2('t')); textElem.appendChild(this.textView_.element); this.element.appendChild(textElem); } } const className$1 = ClassName('rsl'); class RangeSliderView { constructor(doc, config) { this.maxValue_ = config.maxValue; this.minValue_ = config.minValue; this.element = doc.createElement('div'); this.element.classList.add(className$1()); config.viewProps.bindClassModifiers(this.element); this.value_ = config.value; this.value_.emitter.on('change', this.onValueChange_.bind(this)); const trackElem = doc.createElement('div'); trackElem.classList.add(className$1('t')); this.element.appendChild(trackElem); this.trackElement = trackElem; const barElem = doc.createElement('div'); barElem.classList.add(className$1('b')); trackElem.appendChild(barElem); this.barElement = barElem; const knobElems = ['min', 'max'].map((modifier) => { const elem = doc.createElement('div'); elem.classList.add(className$1('k'), className$1('k', modifier)); trackElem.appendChild(elem); return elem; }); this.knobElements = [knobElems[0], knobElems[1]]; this.update(); } valueToX_(value) { return (constrainRange(mapRange(value, this.minValue_, this.maxValue_, 0, 1), 0, 1) * 100); } update() { const v = this.value_.rawValue; if (v.length === 0) { this.element.classList.add(className$1(undefined, 'zero')); } else { this.element.classList.remove(className$1(undefined, 'zero')); } const xs = [this.valueToX_(v.min), this.valueToX_(v.max)]; this.barElement.style.left = `${xs[0]}%`; this.barElement.style.right = `${100 - xs[1]}%`; this.knobElements.forEach((elem, index) => { elem.style.left = `${xs[index]}%`; }); } onValueChange_() { this.update(); } } class RangeSliderController { constructor(doc, config) { this.grabbing_ = null; this.grabOffset_ = 0; this.onPointerDown_ = this.onPointerDown_.bind(this); this.onPointerMove_ = this.onPointerMove_.bind(this); this.onPointerUp_ = this.onPointerUp_.bind(this); this.maxValue_ = config.maxValue; this.minValue_ = config.minValue; this.viewProps = config.viewProps; this.value = config.value; this.view = new RangeSliderView(doc, { maxValue: config.maxValue, minValue: config.minValue, value: this.value, viewProps: config.viewProps, }); const ptHandler = new PointerHandler(this.view.trackElement); ptHandler.emitter.on('down', this.onPointerDown_); ptHandler.emitter.on('move', this.onPointerMove_); ptHandler.emitter.on('up', this.onPointerUp_); } ofs_() { if (this.grabbing_ === 'min') { return this.view.knobElements[0].getBoundingClientRect().width / 2; } if (this.grabbing_ === 'max') { return -this.view.knobElements[1].getBoundingClientRect().width / 2; } return 0; } valueFromData_(data) { if (!data.point) { return null; } const p = (data.point.x + this.ofs_()) / data.bounds.width; return mapRange(p, 0, 1, this.minValue_, this.maxValue_); } onPointerDown_(ev) { if (!ev.data.point) { return; } const p = ev.data.point.x / ev.data.bounds.width; const v = this.value.rawValue; const pmin = mapRange(v.min, this.minValue_, this.maxValue_, 0, 1); const pmax = mapRange(v.max, this.minValue_, this.maxValue_, 0, 1); if (Math.abs(pmax - p) <= 0.025) { this.grabbing_ = 'max'; } else if (Math.abs(pmin - p) <= 0.025) { this.grabbing_ = 'min'; } else if (p >= pmin && p <= pmax) { this.grabbing_ = 'length'; this.grabOffset_ = mapRange(p - pmin, 0, 1, this.minValue_, this.maxValue_); } else if (p < pmin) { this.grabbing_ = 'min'; this.onPointerMove_(ev); } else if (p > pmax) { this.grabbing_ = 'max'; this.onPointerMove_(ev); } } applyPointToValue_(data, opts) { const v = this.valueFromData_(data); if (v === null) { return; } if (this.grabbing_ === 'min') { this.value.setRawValue(new Interval(v, this.value.rawValue.max), opts); } else if (this.grabbing_ === 'max') { this.value.setRawValue(new Interval(this.value.rawValue.min, v), opts); } else if (this.grabbing_ === 'length') { const len = this.value.rawValue.length; let min = v - this.grabOffset_; let max = min + len; if (min < this.minValue_) { min = this.minValue_; max = this.minValue_ + len; } else if (max > this.maxValue_) { min = this.maxValue_ - len; max = this.maxValue_; } this.value.setRawValue(new Interval(min, max), opts); } } onPointerMove_(ev) { this.applyPointToValue_(ev.data, { forceEmit: false, last: false, }); } onPointerUp_(ev) { this.applyPointToValue_(ev.data, { forceEmit: true, last: true, }); this.grabbing_ = null; } } class RangeSliderTextController { constructor(doc, config) { this.value = config.value; this.viewProps = config.viewProps; this.sc_ = new RangeSliderController(doc, config); const axis = { baseStep: config.baseStep, constraint: config.constraint, textProps: ValueMap.fromObject({ draggingScale: config.draggingScale, formatter: config.formatter, }), }; this.tc_ = new PointNdTextController(doc, { assembly: IntervalAssembly, axes: [axis, axis], parser: config.parser, value: this.value, viewProps: config.viewProps, }); this.view = new RangeSliderTextView(doc, { sliderView: this.sc_.view, textView: this.tc_.view, }); } get textController() { return this.tc_; } } function intervalFromUnknown(value) { return Interval.isObject(value) ? new Interval(value.min, value.max) : new Interval(0, 0); } function writeInterval(target, value) { target.writeProperty('max', value.max); target.writeProperty('min', value.min); } function createConstraint(params) { const constraints = []; const rc = createRangeConstraint(params); if (rc) { constraints.push(rc); } const sc = createStepConstraint(params); if (sc) { constraints.push(sc); } return new IntervalConstraint(new CompositeConstraint(constraints)); } const IntervalInputPlugin = { id: 'input-interval', type: 'input', css: '.tp-cbzv_b,.tp-rslv_k,.tp-radv_b,.tp-cbzgv{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border-width:0;font-family:inherit;font-size:inherit;font-weight:inherit;margin:0;outline:none;padding:0}.tp-cbzv_b,.tp-rslv_k,.tp-radv_b{background-color:var(--btn-bg);border-radius:var(--elm-br);color:var(--btn-fg);cursor:pointer;display:block;font-weight:bold;height:var(--bld-us);line-height:var(--bld-us);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tp-cbzv_b:hover,.tp-rslv_k:hover,.tp-radv_b:hover{background-color:var(--btn-bg-h)}.tp-cbzv_b:focus,.tp-rslv_k:focus,.tp-radv_b:focus{background-color:var(--btn-bg-f)}.tp-cbzv_b:active,.tp-rslv_k:active,.tp-radv_b:active{background-color:var(--btn-bg-a)}.tp-cbzv_b:disabled,.tp-rslv_k:disabled,.tp-radv_b:disabled{opacity:0.5}.tp-cbzgv{background-color:var(--in-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--in-fg);font-family:inherit;height:var(--bld-us);line-height:var(--bld-us);min-width:0;width:100%}.tp-cbzgv:hover{background-color:var(--in-bg-h)}.tp-cbzgv:focus{background-color:var(--in-bg-f)}.tp-cbzgv:active{background-color:var(--in-bg-a)}.tp-cbzgv:disabled{opacity:0.5}.tp-btngridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-btngridv.tp-v-disabled{opacity:0.5}.tp-btngridv .tp-btnv_b:disabled{opacity:1}.tp-btngridv .tp-btnv_b:disabled .tp-btnv_t{opacity:0.5}.tp-btngridv .tp-btnv_b{border-radius:0}.tp-cbzv{position:relative}.tp-cbzv_h{display:flex}.tp-cbzv_b{margin-right:4px;position:relative;width:var(--bld-us)}.tp-cbzv_b svg{display:block;height:16px;left:50%;margin-left:-8px;margin-top:-8px;position:absolute;top:50%;width:16px}.tp-cbzv_b svg path{stroke:var(--bs-bg);stroke-width:2}.tp-cbzv_t{flex:1}.tp-cbzv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-cbzv.tp-cbzv-expanded .tp-cbzv_p{margin-top:var(--bld-s);opacity:1}.tp-cbzv.tp-cbzv-cpl .tp-cbzv_p{overflow:visible}.tp-cbzv .tp-popv{left:calc(-1 * var(--cnt-h-p));position:absolute;right:calc(-1 * var(--cnt-h-p));top:var(--bld-us)}.tp-cbzpv_t{margin-top:var(--bld-s)}.tp-cbzgv{height:auto;overflow:hidden;position:relative}.tp-cbzgv.tp-v-disabled{opacity:0.5}.tp-cbzgv_p{left:16px;position:absolute;right:16px;top:0}.tp-cbzgv_g{cursor:pointer;display:block;height:calc(var(--bld-us) * 5);width:100%}.tp-cbzgv_u{opacity:0.1;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_l{fill:transparent;stroke:var(--in-fg)}.tp-cbzgv_v{opacity:0.5;stroke:var(--in-fg);stroke-dasharray:1}.tp-cbzgv_h{border:var(--in-fg) solid 1px;border-radius:50%;box-sizing:border-box;height:4px;margin-left:-2px;margin-top:-2px;pointer-events:none;position:absolute;width:4px}.tp-cbzgv:focus .tp-cbzgv_h-sel{background-color:var(--in-fg);border-width:0}.tp-cbzprvv{cursor:pointer;height:4px;padding:4px 0;position:relative}.tp-cbzprvv_g{display:block;height:100%;overflow:visible;width:100%}.tp-cbzprvv_t{opacity:0.5;stroke:var(--mo-fg)}.tp-cbzprvv_m{background-color:var(--mo-fg);border-radius:50%;height:4px;margin-left:-2px;margin-top:-2px;opacity:0;position:absolute;top:50%;transition:opacity 0.2s ease-out;width:4px}.tp-cbzprvv_m.tp-cbzprvv_m-a{opacity:1}.tp-fpsv{position:relative}.tp-fpsv_l{bottom:4px;color:var(--mo-fg);line-height:1;right:4px;pointer-events:none;position:absolute}.tp-fpsv_u{margin-left:0.2em;opacity:0.7}.tp-rslv{cursor:pointer;padding-left:8px;padding-right:8px}.tp-rslv.tp-v-disabled{opacity:0.5}.tp-rslv_t{height:calc(var(--bld-us));position:relative}.tp-rslv_t::before{background-color:var(--in-bg);border-radius:1px;content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:-4px;right:-4px}.tp-rslv_b{bottom:0;top:0;position:absolute}.tp-rslv_b::before{background-color:var(--in-fg);content:\'\';height:2px;margin-top:-1px;position:absolute;top:50%;left:0;right:0}.tp-rslv_k{height:calc(var(--bld-us) - 8px);margin-top:calc((var(--bld-us) - 8px) / -2);position:absolute;top:50%;width:8px}.tp-rslv_k.tp-rslv_k-min{margin-left:-8px}.tp-rslv_k.tp-rslv_k-max{margin-left:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-min{border-bottom-right-radius:0;border-top-right-radius:0}.tp-rslv.tp-rslv-zero .tp-rslv_k.tp-rslv_k-max{border-bottom-left-radius:0;border-top-left-radius:0}.tp-rsltxtv{display:flex}.tp-rsltxtv_s{flex:1}.tp-rsltxtv_t{flex:1;margin-left:4px}.tp-radv_l{display:block;position:relative}.tp-radv_i{left:0;opacity:0;position:absolute;top:0}.tp-radv_b{opacity:0.5}.tp-radv_i:hover+.tp-radv_b{background-color:var(--btn-bg-h)}.tp-radv_i:focus+.tp-radv_b{background-color:var(--btn-bg-f)}.tp-radv_i:active+.tp-radv_b{background-color:var(--btn-bg-a)}.tp-radv_i:checked+.tp-radv_b{opacity:1}.tp-radv_t{bottom:0;color:inherit;left:0;overflow:hidden;position:absolute;right:0;text-align:center;text-overflow:ellipsis;top:0}.tp-radv_i:disabled+.tp-radv_b>.tp-radv_t{opacity:0.5}.tp-radgridv{border-radius:var(--elm-br);display:grid;overflow:hidden;gap:2px}.tp-radgridv.tp-v-disabled{opacity:0.5}.tp-radgridv .tp-radv_b{border-radius:0}', accept: (exValue, params) => { if (!Interval.isObject(exValue)) { return null; } const p = ParamsParsers; const result = parseParams(params, { format: p.optional.function, max: p.optional.number, min: p.optional.number, step: p.optional.number, }); return result ? { initialValue: new Interval(exValue.min, exValue.max), params: result, } : null; }, binding: { reader: (_args) => intervalFromUnknown, constraint: (args) => createConstraint(args.params), equals: Interval.equals, writer: (_args) => writeInterval, }, controller(args) { var _a; const v = args.value; const c = args.constraint; if (!(c instanceof IntervalConstraint)) { throw TpError.shouldNeverHappen(); } const midValue = (v.rawValue.min + v.rawValue.max) / 2; const formatter = (_a = args.params.format) !== null && _a !== void 0 ? _a : createNumberFormatter(getSuitableDecimalDigits(c.edge, midValue)); const rc = c.edge && findConstraint(c.edge, RangeConstraint); if ((rc === null || rc === void 0 ? void 0 : rc.minValue) !== undefined && (rc === null || rc === void 0 ? void 0 : rc.maxValue) !== undefined) { return new RangeSliderTextController(args.document, { baseStep: getBaseStep(c.edge), constraint: c.edge, draggingScale: getSuitableDraggingScale(rc, midValue), formatter: formatter, maxValue: rc.maxValue, minValue: rc.minValue, parser: parseNumber, value: v, viewProps: args.viewProps, }); } const axis = { baseStep: getBaseStep(c.edge), constraint: c.edge, textProps: ValueMap.fromObject({ draggingScale: midValue, formatter: formatter, }), }; return new PointNdTextController(args.document, { assembly: IntervalAssembly, axes: [axis, axis], parser: parseNumber, value: v, viewProps: args.viewProps, }); }, }; class RadioCellApi { constructor(controller) { this.controller_ = controller; } get disabled() { return this.controller_.viewProps.get('disabled'); } set disabled(disabled) { this.controller_.viewProps.set('disabled', disabled); } get title() { var _a; return (_a = this.controller_.props.get('title')) !== null && _a !== void 0 ? _a : ''; } set title(title) { this.controller_.props.set('title', title); } } class TpRadioGridChangeEvent extends TpChangeEvent { constructor(target, cell, index, value, presetKey) { super(target, value, presetKey); this.cell = cell; this.index = index; } } class RadioGridApi extends BladeApi { constructor(controller) { super(controller); this.cellToApiMap_ = new Map(); const gc = this.controller_.valueController; gc.cellControllers.forEach((cc) => { const api = new RadioCellApi(cc); this.cellToApiMap_.set(cc, api); }); } get value() { return this.controller_.value; } cell(x, y) { const gc = this.controller_.valueController; const cc = gc.cellControllers[y * gc.size[0] + x]; return this.cellToApiMap_.get(cc); } on(eventName, handler) { const bh = handler.bind(this); this.controller_.value.emitter.on(eventName, (ev) => { const gc = this.controller_.valueController; const cc = gc.findCellByValue(ev.rawValue); if (!cc) { return; } const capi = this.cellToApiMap_.get(cc); if (!capi) { return; } const i = gc.cellControllers.indexOf(cc); bh(new TpRadioGridChangeEvent(this, capi, [i % gc.size[0], Math.floor(i / gc.size[0])], ev.rawValue, undefined)); }); } } const className = ClassName('rad'); class RadioView { constructor(doc, config) { this.element = doc.createElement('div'); this.element.classList.add(className()); config.viewProps.bindClassModifiers(this.element); const labelElem = doc.createElement('label'); labelElem.classList.add(className('l')); this.element.appendChild(labelElem); const inputElem = doc.createElement('input'); inputElem.classList.add(className('i')); inputElem.name = config.name; inputElem.type = 'radio'; config.viewProps.bindDisabled(inputElem); labelElem.appendChild(inputElem); this.inputElement = inputElem; const bodyElem = doc.createElement('div'); bodyElem.classList.add(className('b')); labelElem.appendChild(bodyElem); const titleElem = doc.createElement('div'); titleElem.classList.add(className('t')); bodyElem.appendChild(titleElem); bindValueMap(config.props, 'title', (title) => { titleElem.textContent = title; }); } } class RadioController { constructor(doc, config) { this.props = config.props; this.viewProps = config.viewProps; this.view = new RadioView(doc, { name: config.name, props: this.props, viewProps: this.viewProps, }); } } class RadioGridController { constructor(doc, config) { this.cellCs_ = []; this.cellValues_ = []; this.onCellInputChange_ = this.onCellInputChange_.bind(this); this.size = config.size; const [w, h] = this.size; for (let y = 0; y < h; y++) { for (let x = 0; x < w; x++) { const bc = new RadioController(doc, { name: config.groupName, props: ValueMap.fromObject(Object.assign({}, config.cellConfig(x, y))), viewProps: ViewProps.create(), }); this.cellCs_.push(bc); this.cellValues_.push(config.cellConfig(x, y).value); } } this.value = config.value; bindValue(this.value, (value) => { const cc = this.findCellByValue(value); if (!cc) { return; } cc.view.inputElement.checked = true; }); this.viewProps = ViewProps.create(); this.view = new PlainView(doc, { viewProps: this.viewProps, viewName: 'radgrid', }); this.view.element.style.gridTemplateColumns = `repeat(${w}, 1fr)`; this.cellCs_.forEach((bc) => { bc.view.inputElement.addEventListener('change', this.onCellInputChange_); this.view.element.appendChild(bc.view.element); }); } get cellControllers() { return this.cellCs_; } findCellByValue(value) { const index = this.cellValues_.findIndex((v) => v === value); if (index < 0) { return null; } return this.cellCs_[index]; } onCellInputChange_(ev) { const inputElem = ev.currentTarget; const index = this.cellCs_.findIndex((c) => c.view.inputElement === inputElem); if (index < 0) { return; } this.value.rawValue = this.cellValues_[index]; } } const RadioGridBladePlugin = (function () { return { id: 'radiogrid', type: 'blade', accept(params) { const p = ParamsParsers; const result = parseParams(params, { cells: p.required.function, groupName: p.required.string, size: p.required.array(p.required.number), value: p.required.raw, view: p.required.constant('radiogrid'), label: p.optional.string, }); return result ? { params: result } : null; }, controller(args) { return new LabeledValueController(args.document, { blade: args.blade, props: ValueMap.fromObject({ label: args.params.label, }), valueController: new RadioGridController(args.document, { groupName: args.params.groupName, cellConfig: args.params.cells, size: args.params.size, value: createValue(args.params.value), }), }); }, api(args) { if (!(args.controller instanceof LabeledValueController)) { return null; } if (!(args.controller.valueController instanceof RadioGridController)) { return null; } return new RadioGridApi(args.controller); }, }; })(); const RadioGridNumberInputPlugin = { id: 'input-radiogrid', type: 'input', accept(value, params) { if (typeof value !== 'number') { return null; } const p = ParamsParsers; const result = parseParams(params, { cells: p.required.function, groupName: p.required.string, size: p.required.array(p.required.number), view: p.required.constant('radiogrid'), }); return result ? { initialValue: value, params: result, } : null; }, binding: { reader: (_args) => numberFromUnknown, writer: (_args) => writePrimitive, }, controller: (args) => { return new RadioGridController(args.document, { cellConfig: args.params.cells, groupName: args.params.groupName, size: args.params.size, value: args.value, }); }, }; const plugins = [ ButtonGridBladePlugin, CubicBezierBladePlugin, FpsGraphBladePlugin, IntervalInputPlugin, RadioGridBladePlugin, RadioGridNumberInputPlugin, ]; exports.CubicBezier = CubicBezier; exports.plugins = plugins; Object.defineProperty(exports, '__esModule', { value: true }); }))); /** * @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() { /** 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 global == 'object' && global && global.Object === Object && global; /** 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 = typeof exports == 'object' && exports && !exports.nodeType && exports; /** Detect free variable `module`. */ var freeModule = freeExports && typeof module == '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 < length) { var value = array[index]; setter(accumulator, value, iteratee(value), array); } return accumulator; } /** * A specialized version of `_.forEach` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns `array`. */ function arrayEach(array, iteratee) { var index = -1, length = array == null ? 0 : array.length; while (++index < length) { if (iteratee(array[index], index, array) === false) { break; } } return array; } /** * A specialized version of `_.forEachRight` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns `array`. */ function arrayEachRight(array, iteratee) { var length = array == null ? 0 : array.length; while (length--) { if (iteratee(array[length], length, array) === false) { break; } } return array; } /** * A specialized version of `_.every` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {boolean} Returns `true` if all elements pass the predicate check, * else `false`. */ function arrayEvery(array, predicate) { var index = -1, length = array == null ? 0 : array.length; while (++index < length) { if (!predicate(array[index], index, array)) { return false; } } return true; } /** * A specialized version of `_.filter` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {Array} Returns the new filtered array. */ function arrayFilter(array, predicate) { var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = []; while (++index < length) { var value = array[index]; if (predicate(value, index, array)) { result[resIndex++] = value; } } return result; } /** * A specialized version of `_.includes` for arrays without support for * specifying an index to search from. * * @private * @param {Array} [array] The array to inspect. * @param {*} target The value to search for. * @returns {boolean} Returns `true` if `target` is found, else `false`. */ function arrayIncludes(array, value) { var length = array == null ? 0 : array.length; return !!length && baseIndexOf(array, value, 0) > -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 < length) { if (comparator(value, array[index])) { return true; } } return false; } /** * A specialized version of `_.map` for arrays without support for iteratee * shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns the new mapped array. */ function arrayMap(array, iteratee) { var index = -1, length = array == null ? 0 : array.length, result = Array(length); while (++index < length) { result[index] = iteratee(array[index], index, array); } return result; } /** * Appends the elements of `values` to `array`. * * @private * @param {Array} array The array to modify. * @param {Array} values The values to append. * @returns {Array} Returns `array`. */ function arrayPush(array, values) { var index = -1, length = values.length, offset = array.length; while (++index < length) { array[offset + index] = values[index]; } return array; } /** * A specialized version of `_.reduce` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {*} [accumulator] The initial value. * @param {boolean} [initAccum] Specify using the first element of `array` as * the initial value. * @returns {*} Returns the accumulated value. */ function arrayReduce(array, iteratee, accumulator, initAccum) { var index = -1, length = array == null ? 0 : array.length; if (initAccum && length) { accumulator = array[++index]; } while (++index < length) { accumulator = iteratee(accumulator, array[index], index, array); } return accumulator; } /** * A specialized version of `_.reduceRight` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {*} [accumulator] The initial value. * @param {boolean} [initAccum] Specify using the last element of `array` as * the initial value. * @returns {*} Returns the accumulated value. */ function arrayReduceRight(array, iteratee, accumulator, initAccum) { var length = array == null ? 0 : array.length; if (initAccum && length) { accumulator = array[--length]; } while (length--) { accumulator = iteratee(accumulator, array[length], length, array); } return accumulator; } /** * A specialized version of `_.some` for arrays without support for iteratee * shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {boolean} Returns `true` if any element passes the predicate check, * else `false`. */ function arraySome(array, predicate) { var index = -1, length = array == null ? 0 : array.length; while (++index < length) { if (predicate(array[index], index, array)) { return true; } } return false; } /** * Gets the size of an ASCII `string`. * * @private * @param {string} string The string inspect. * @returns {number} Returns the string size. */ var asciiSize = baseProperty('length'); /** * Converts an ASCII `string` to an array. * * @private * @param {string} string The string to convert. * @returns {Array} Returns the converted array. */ function asciiToArray(string) { return string.split(''); } /** * Splits an ASCII `string` into an array of its words. * * @private * @param {string} The string to inspect. * @returns {Array} Returns the words of `string`. */ function asciiWords(string) { return string.match(reAsciiWord) || []; } /** * The base implementation of methods like `_.findKey` and `_.findLastKey`, * without support for iteratee shorthands, which iterates over `collection` * using `eachFunc`. * * @private * @param {Array|Object} collection The collection to inspect. * @param {Function} predicate The function invoked per iteration. * @param {Function} eachFunc The function to iterate over `collection`. * @returns {*} Returns the found element or its key, else `undefined`. */ function baseFindKey(collection, predicate, eachFunc) { var result; eachFunc(collection, function(value, key, collection) { if (predicate(value, key, collection)) { result = key; return false; } }); return result; } /** * The base implementation of `_.findIndex` and `_.findLastIndex` without * support for iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Function} predicate The function invoked per iteration. * @param {number} fromIndex The index to search from. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseFindIndex(array, predicate, fromIndex, fromRight) { var length = array.length, index = fromIndex + (fromRight ? 1 : -1); while ((fromRight ? index-- : ++index < length)) { if (predicate(array[index], index, array)) { return index; } } return -1; } /** * The base implementation of `_.indexOf` without `fromIndex` bounds checks. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseIndexOf(array, value, fromIndex) { return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex); } /** * This function is like `baseIndexOf` except that it accepts a comparator. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @param {Function} comparator The comparator invoked per element. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseIndexOfWith(array, value, fromIndex, comparator) { var index = fromIndex - 1, length = array.length; while (++index < length) { if (comparator(array[index], value)) { return index; } } return -1; } /** * The base implementation of `_.isNaN` without support for number objects. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. */ function baseIsNaN(value) { return value !== value; } /** * The base implementation of `_.mean` and `_.meanBy` without support for * iteratee shorthands. * * @private * @param {Array} array The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {number} Returns the mean. */ function baseMean(array, iteratee) { var length = array == null ? 0 : array.length; return length ? (baseSum(array, iteratee) / length) : NAN; } /** * The base implementation of `_.property` without support for deep paths. * * @private * @param {string} key The key of the property to get. * @returns {Function} Returns the new accessor function. */ function baseProperty(key) { return function(object) { return object == null ? undefined$1 : object[key]; }; } /** * The base implementation of `_.propertyOf` without support for deep paths. * * @private * @param {Object} object The object to query. * @returns {Function} Returns the new accessor function. */ function basePropertyOf(object) { return function(key) { return object == null ? undefined$1 : object[key]; }; } /** * The base implementation of `_.reduce` and `_.reduceRight`, without support * for iteratee shorthands, which iterates over `collection` using `eachFunc`. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {*} accumulator The initial value. * @param {boolean} initAccum Specify using the first or last element of * `collection` as the initial value. * @param {Function} eachFunc The function to iterate over `collection`. * @returns {*} Returns the accumulated value. */ function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { eachFunc(collection, function(value, index, collection) { accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection); }); return accumulator; } /** * The base implementation of `_.sortBy` which uses `comparer` to define the * sort order of `array` and replaces criteria objects with their corresponding * values. * * @private * @param {Array} array The array to sort. * @param {Function} comparer The function to define sort order. * @returns {Array} Returns `array`. */ function baseSortBy(array, comparer) { var length = array.length; array.sort(comparer); while (length--) { array[length] = array[length].value; } return array; } /** * The base implementation of `_.sum` and `_.sumBy` without support for * iteratee shorthands. * * @private * @param {Array} array The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {number} Returns the sum. */ function baseSum(array, iteratee) { var result, index = -1, length = array.length; while (++index < length) { var current = iteratee(array[index]); if (current !== undefined$1) { result = result === undefined$1 ? current : (result + current); } } return result; } /** * The base implementation of `_.times` without support for iteratee shorthands * or max array length checks. * * @private * @param {number} n The number of times to invoke `iteratee`. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns the array of results. */ function baseTimes(n, iteratee) { var index = -1, result = Array(n); while (++index < n) { result[index] = iteratee(index); } return result; } /** * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array * of key-value pairs for `object` corresponding to the property names of `props`. * * @private * @param {Object} object The object to query. * @param {Array} props The property names to get values for. * @returns {Object} Returns the key-value pairs. */ function baseToPairs(object, props) { return arrayMap(props, function(key) { return [key, object[key]]; }); } /** * The base implementation of `_.trim`. * * @private * @param {string} string The string to trim. * @returns {string} Returns the trimmed string. */ function baseTrim(string) { return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string; } /** * The base implementation of `_.unary` without support for storing metadata. * * @private * @param {Function} func The function to cap arguments for. * @returns {Function} Returns the new capped function. */ function baseUnary(func) { return function(value) { return func(value); }; } /** * The base implementation of `_.values` and `_.valuesIn` which creates an * array of `object` property values corresponding to the property names * of `props`. * * @private * @param {Object} object The object to query. * @param {Array} props The property names to get values for. * @returns {Object} Returns the array of property values. */ function baseValues(object, props) { return arrayMap(props, function(key) { return object[key]; }); } /** * Checks if a `cache` value for `key` exists. * * @private * @param {Object} cache The cache to query. * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function cacheHas(cache, key) { return cache.has(key); } /** * Used by `_.trim` and `_.trimStart` to get the index of the first 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 first unmatched string symbol. */ function charsStartIndex(strSymbols, chrSymbols) { var index = -1, length = strSymbols.length; while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -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 < length) { var value = array[index]; if (value === placeholder || value === PLACEHOLDER) { array[index] = PLACEHOLDER; result[resIndex++] = index; } } return result; } /** * Converts `set` to an array of its values. * * @private * @param {Object} set The set to convert. * @returns {Array} Returns the values. */ function setToArray(set) { var index = -1, result = Array(set.size); set.forEach(function(value) { result[++index] = value; }); return result; } /** * Converts `set` to its value-value pairs. * * @private * @param {Object} set The set to convert. * @returns {Array} Returns the value-value pairs. */ function setToPairs(set) { var index = -1, result = Array(set.size); set.forEach(function(value) { result[++index] = [value, value]; }); return result; } /** * A specialized version of `_.indexOf` which performs strict equality * comparisons of values, i.e. `===`. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function strictIndexOf(array, value, fromIndex) { var index = fromIndex - 1, length = array.length; while (++index < length) { if (array[index] === value) { return index; } } return -1; } /** * A specialized version of `_.lastIndexOf` which performs strict equality * comparisons of values, i.e. `===`. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function strictLastIndexOf(array, value, fromIndex) { var index = fromIndex + 1; while (index--) { if (array[index] === value) { return index; } } return index; } /** * Gets the number of symbols in `string`. * * @private * @param {string} string The string to inspect. * @returns {number} Returns the string size. */ function stringSize(string) { return hasUnicode(string) ? unicodeSize(string) : asciiSize(string); } /** * Converts `string` to an array. * * @private * @param {string} string The string to convert. * @returns {Array} Returns the converted array. */ function stringToArray(string) { return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string); } /** * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace * character of `string`. * * @private * @param {string} string The string to inspect. * @returns {number} Returns the index of the last non-whitespace character. */ function trimmedEndIndex(string) { var index = string.length; while (index-- && reWhitespace.test(string.charAt(index))) {} return index; } /** * Used by `_.unescape` to convert HTML entities to characters. * * @private * @param {string} chr The matched character to unescape. * @returns {string} Returns the unescaped character. */ var unescapeHtmlChar = basePropertyOf(htmlUnescapes); /** * Gets the size of a Unicode `string`. * * @private * @param {string} string The string inspect. * @returns {number} Returns the string size. */ function unicodeSize(string) { var result = reUnicode.lastIndex = 0; while (reUnicode.test(string)) { ++result; } return result; } /** * Converts a Unicode `string` to an array. * * @private * @param {string} string The string to convert. * @returns {Array} Returns the converted array. */ function unicodeToArray(string) { return string.match(reUnicode) || []; } /** * Splits a Unicode `string` into an array of its words. * * @private * @param {string} The string to inspect. * @returns {Array} Returns the words of `string`. */ function unicodeWords(string) { return string.match(reUnicodeWord) || []; } /*--------------------------------------------------------------------------*/ /** * Create a new pristine `lodash` function using the `context` object. * * @static * @memberOf _ * @since 1.1.0 * @category Util * @param {Object} [context=root] The context object. * @returns {Function} Returns a new `lodash` function. * @example * * _.mixin({ 'foo': _.constant('foo') }); * * var lodash = _.runInContext(); * lodash.mixin({ 'bar': lodash.constant('bar') }); * * _.isFunction(_.foo); * // => 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 < takeCount) { index += dir; var iterIndex = -1, value = array[index]; while (++iterIndex < iterLength) { var data = iteratees[iterIndex], iteratee = data.iteratee, type = data.type, computed = iteratee(value); if (type == LAZY_MAP_FLAG) { value = computed; } else if (!computed) { if (type == LAZY_FILTER_FLAG) { continue outer; } else { break outer; } } } result[resIndex++] = value; } return result; } // Ensure `LazyWrapper` is an instance of `baseLodash`. LazyWrapper.prototype = baseCreate(baseLodash.prototype); LazyWrapper.prototype.constructor = LazyWrapper; /*------------------------------------------------------------------------*/ /** * Creates a hash object. * * @private * @constructor * @param {Array} [entries] The key-value pairs to cache. */ function Hash(entries) { var index = -1, length = entries == null ? 0 : entries.length; this.clear(); while (++index < length) { var entry = entries[index]; this.set(entry[0], entry[1]); } } /** * Removes all key-value entries from the hash. * * @private * @name clear * @memberOf Hash */ function hashClear() { this.__data__ = nativeCreate ? nativeCreate(null) : {}; this.size = 0; } /** * Removes `key` and its value from the hash. * * @private * @name delete * @memberOf Hash * @param {Object} hash The hash to modify. * @param {string} key The key of the value to remove. * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function hashDelete(key) { var result = this.has(key) && delete this.__data__[key]; this.size -= result ? 1 : 0; return result; } /** * Gets the hash value for `key`. * * @private * @name get * @memberOf Hash * @param {string} key The key of the value to get. * @returns {*} Returns the entry value. */ function hashGet(key) { var data = this.__data__; if (nativeCreate) { var result = data[key]; return result === HASH_UNDEFINED ? undefined$1 : result; } return hasOwnProperty.call(data, key) ? data[key] : undefined$1; } /** * Checks if a hash value for `key` exists. * * @private * @name has * @memberOf Hash * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function hashHas(key) { var data = this.__data__; return nativeCreate ? (data[key] !== undefined$1) : hasOwnProperty.call(data, key); } /** * Sets the hash `key` to `value`. * * @private * @name set * @memberOf Hash * @param {string} key The key of the value to set. * @param {*} value The value to set. * @returns {Object} Returns the hash instance. */ function hashSet(key, value) { var data = this.__data__; this.size += this.has(key) ? 0 : 1; data[key] = (nativeCreate && value === undefined$1) ? HASH_UNDEFINED : value; return this; } // Add methods to `Hash`. Hash.prototype.clear = hashClear; Hash.prototype['delete'] = hashDelete; Hash.prototype.get = hashGet; Hash.prototype.has = hashHas; Hash.prototype.set = hashSet; /*------------------------------------------------------------------------*/ /** * Creates an list cache object. * * @private * @constructor * @param {Array} [entries] The key-value pairs to cache. */ function ListCache(entries) { var index = -1, length = entries == null ? 0 : entries.length; this.clear(); while (++index < length) { var entry = entries[index]; this.set(entry[0], entry[1]); } } /** * Removes all key-value entries from the list cache. * * @private * @name clear * @memberOf ListCache */ function listCacheClear() { this.__data__ = []; this.size = 0; } /** * Removes `key` and its value from the list cache. * * @private * @name delete * @memberOf ListCache * @param {string} key The key of the value to remove. * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function listCacheDelete(key) { var data = this.__data__, index = assocIndexOf(data, key); if (index < 0) { return false; } var lastIndex = data.length - 1; if (index == lastIndex) { data.pop(); } else { splice.call(data, index, 1); } --this.size; return true; } /** * Gets the list cache value for `key`. * * @private * @name get * @memberOf ListCache * @param {string} key The key of the value to get. * @returns {*} Returns the entry value. */ function listCacheGet(key) { var data = this.__data__, index = assocIndexOf(data, key); return index < 0 ? undefined$1 : data[index][1]; } /** * Checks if a list cache value for `key` exists. * * @private * @name has * @memberOf ListCache * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function listCacheHas(key) { return assocIndexOf(this.__data__, key) > -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 < length) { var entry = entries[index]; this.set(entry[0], entry[1]); } } /** * Removes all key-value entries from the map. * * @private * @name clear * @memberOf MapCache */ function mapCacheClear() { this.size = 0; this.__data__ = { 'hash': new Hash, 'map': new (Map || ListCache), 'string': new Hash }; } /** * Removes `key` and its value from the map. * * @private * @name delete * @memberOf MapCache * @param {string} key The key of the value to remove. * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function mapCacheDelete(key) { var result = getMapData(this, key)['delete'](key); this.size -= result ? 1 : 0; return result; } /** * Gets the map value for `key`. * * @private * @name get * @memberOf MapCache * @param {string} key The key of the value to get. * @returns {*} Returns the entry value. */ function mapCacheGet(key) { return getMapData(this, key).get(key); } /** * Checks if a map value for `key` exists. * * @private * @name has * @memberOf MapCache * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function mapCacheHas(key) { return getMapData(this, key).has(key); } /** * Sets the map `key` to `value`. * * @private * @name set * @memberOf MapCache * @param {string} key The key of the value to set. * @param {*} value The value to set. * @returns {Object} Returns the map cache instance. */ function mapCacheSet(key, value) { var data = getMapData(this, key), size = data.size; data.set(key, value); this.size += data.size == size ? 0 : 1; return this; } // Add methods to `MapCache`. MapCache.prototype.clear = mapCacheClear; MapCache.prototype['delete'] = mapCacheDelete; MapCache.prototype.get = mapCacheGet; MapCache.prototype.has = mapCacheHas; MapCache.prototype.set = mapCacheSet; /*------------------------------------------------------------------------*/ /** * * Creates an array cache object to store unique values. * * @private * @constructor * @param {Array} [values] The values to cache. */ function SetCache(values) { var index = -1, length = values == null ? 0 : values.length; this.__data__ = new MapCache; while (++index < length) { this.add(values[index]); } } /** * Adds `value` to the array cache. * * @private * @name add * @memberOf SetCache * @alias push * @param {*} value The value to cache. * @returns {Object} Returns the cache instance. */ function setCacheAdd(value) { this.__data__.set(value, HASH_UNDEFINED); return this; } /** * Checks if `value` is in the array cache. * * @private * @name has * @memberOf SetCache * @param {*} value The value to search for. * @returns {number} Returns `true` if `value` is found, else `false`. */ function setCacheHas(value) { return this.__data__.has(value); } // Add methods to `SetCache`. SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; SetCache.prototype.has = setCacheHas; /*------------------------------------------------------------------------*/ /** * Creates a stack cache object to store key-value pairs. * * @private * @constructor * @param {Array} [entries] The key-value pairs to cache. */ function Stack(entries) { var data = this.__data__ = new ListCache(entries); this.size = data.size; } /** * Removes all key-value entries from the stack. * * @private * @name clear * @memberOf Stack */ function stackClear() { this.__data__ = new ListCache; this.size = 0; } /** * Removes `key` and its value from the stack. * * @private * @name delete * @memberOf Stack * @param {string} key The key of the value to remove. * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function stackDelete(key) { var data = this.__data__, result = data['delete'](key); this.size = data.size; return result; } /** * Gets the stack value for `key`. * * @private * @name get * @memberOf Stack * @param {string} key The key of the value to get. * @returns {*} Returns the entry value. */ function stackGet(key) { return this.__data__.get(key); } /** * Checks if a stack value for `key` exists. * * @private * @name has * @memberOf Stack * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function stackHas(key) { return this.__data__.has(key); } /** * Sets the stack `key` to `value`. * * @private * @name set * @memberOf Stack * @param {string} key The key of the value to set. * @param {*} value The value to set. * @returns {Object} Returns the stack cache instance. */ function stackSet(key, value) { var data = this.__data__; if (data instanceof ListCache) { var pairs = data.__data__; if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { pairs.push([key, value]); this.size = ++data.size; return this; } data = this.__data__ = new MapCache(pairs); } data.set(key, value); this.size = data.size; return this; } // Add methods to `Stack`. Stack.prototype.clear = stackClear; Stack.prototype['delete'] = stackDelete; Stack.prototype.get = stackGet; Stack.prototype.has = stackHas; Stack.prototype.set = stackSet; /*------------------------------------------------------------------------*/ /** * Creates an array of the enumerable property names of the array-like `value`. * * @private * @param {*} value The value to query. * @param {boolean} inherited Specify returning inherited property names. * @returns {Array} Returns the array of property names. */ function arrayLikeKeys(value, inherited) { var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length; for (var key in value) { if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && ( // Safari 9 has enumerable `arguments.length` in strict mode. key == 'length' || // Node.js 0.10 has enumerable non-index properties on buffers. (isBuff && (key == 'offset' || key == 'parent')) || // PhantomJS 2 has enumerable non-index properties on typed arrays. (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || // Skip index properties. isIndex(key, length) ))) { result.push(key); } } return result; } /** * A specialized version of `_.sample` for arrays. * * @private * @param {Array} array The array to sample. * @returns {*} Returns the random element. */ function arraySample(array) { var length = array.length; return length ? array[baseRandom(0, length - 1)] : undefined$1; } /** * A specialized version of `_.sampleSize` for arrays. * * @private * @param {Array} array The array to sample. * @param {number} n The number of elements to sample. * @returns {Array} Returns the random elements. */ function arraySampleSize(array, n) { return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); } /** * A specialized version of `_.shuffle` for arrays. * * @private * @param {Array} array The array to shuffle. * @returns {Array} Returns the new shuffled array. */ function arrayShuffle(array) { return shuffleSelf(copyArray(array)); } /** * This function is like `assignValue` except that it doesn't assign * `undefined` values. * * @private * @param {Object} object The object to modify. * @param {string} key The key of the property to assign. * @param {*} value The value to assign. */ function assignMergeValue(object, key, value) { if ((value !== undefined$1 && !eq(object[key], value)) || (value === undefined$1 && !(key in object))) { baseAssignValue(object, key, value); } } /** * Assigns `value` to `key` of `object` if the existing value is not equivalent * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * for equality comparisons. * * @private * @param {Object} object The object to modify. * @param {string} key The key of the property to assign. * @param {*} value The value to assign. */ function assignValue(object, key, value) { var objValue = object[key]; if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || (value === undefined$1 && !(key in object))) { baseAssignValue(object, key, value); } } /** * Gets the index at which the `key` is found in `array` of key-value pairs. * * @private * @param {Array} array The array to inspect. * @param {*} key The key to search for. * @returns {number} Returns the index of the matched value, else `-1`. */ function assocIndexOf(array, key) { var length = array.length; while (length--) { if (eq(array[length][0], key)) { return length; } } return -1; } /** * Aggregates elements of `collection` on `accumulator` with keys transformed * by `iteratee` and values set by `setter`. * * @private * @param {Array|Object} collection The collection 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 baseAggregator(collection, setter, iteratee, accumulator) { baseEach(collection, function(value, key, collection) { setter(accumulator, value, iteratee(value), collection); }); return accumulator; } /** * The base implementation of `_.assign` without support for multiple sources * or `customizer` functions. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @returns {Object} Returns `object`. */ function baseAssign(object, source) { return object && copyObject(source, keys(source), object); } /** * The base implementation of `_.assignIn` without support for multiple sources * or `customizer` functions. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @returns {Object} Returns `object`. */ function baseAssignIn(object, source) { return object && copyObject(source, keysIn(source), object); } /** * The base implementation of `assignValue` and `assignMergeValue` without * value checks. * * @private * @param {Object} object The object to modify. * @param {string} key The key of the property to assign. * @param {*} value The value to assign. */ function baseAssignValue(object, key, value) { if (key == '__proto__' && defineProperty) { defineProperty(object, key, { 'configurable': true, 'enumerable': true, 'value': value, 'writable': true }); } else { object[key] = value; } } /** * The base implementation of `_.at` without support for individual paths. * * @private * @param {Object} object The object to iterate over. * @param {string[]} paths The property paths to pick. * @returns {Array} Returns the picked elements. */ function baseAt(object, paths) { var index = -1, length = paths.length, result = Array(length), skip = object == null; while (++index < length) { result[index] = skip ? undefined$1 : get(object, paths[index]); } return result; } /** * The base implementation of `_.clamp` which doesn't coerce arguments. * * @private * @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. */ function baseClamp(number, lower, upper) { if (number === number) { if (upper !== undefined$1) { number = number <= upper ? number : upper; } if (lower !== undefined$1) { number = number >= 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 (++index < length) { var value = array[index], computed = iteratee == null ? value : iteratee(value); value = (comparator || value !== 0) ? value : 0; if (isCommon && computed === computed) { var valuesIndex = valuesLength; while (valuesIndex--) { if (values[valuesIndex] === computed) { continue outer; } } result.push(value); } else if (!includes(values, computed, comparator)) { result.push(value); } } return result; } /** * The base implementation of `_.forEach` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array|Object} Returns `collection`. */ var baseEach = createBaseEach(baseForOwn); /** * The base implementation of `_.forEachRight` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array|Object} Returns `collection`. */ var baseEachRight = createBaseEach(baseForOwnRight, true); /** * The base implementation of `_.every` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {boolean} Returns `true` if all elements pass the predicate check, * else `false` */ function baseEvery(collection, predicate) { var result = true; baseEach(collection, function(value, index, collection) { result = !!predicate(value, index, collection); return result; }); return result; } /** * The base implementation of methods like `_.max` and `_.min` which accepts a * `comparator` to determine the extremum value. * * @private * @param {Array} array The array to iterate over. * @param {Function} iteratee The iteratee invoked per iteration. * @param {Function} comparator The comparator used to compare values. * @returns {*} Returns the extremum value. */ function baseExtremum(array, iteratee, comparator) { var index = -1, length = array.length; while (++index < length) { var value = array[index], current = iteratee(value); if (current != null && (computed === undefined$1 ? (current === current && !isSymbol(current)) : comparator(current, computed) )) { var computed = current, result = value; } } return result; } /** * The base implementation of `_.fill` without an iteratee call guard. * * @private * @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`. */ function baseFill(array, value, start, end) { var length = array.length; start = toInteger(start); if (start < 0) { start = -start > length ? 0 : (length + start); } end = (end === undefined$1 || end > length) ? length : toInteger(end); if (end < 0) { end += length; } end = start > end ? 0 : toLength(end); while (start < end) { array[start++] = value; } return array; } /** * The base implementation of `_.filter` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {Array} Returns the new filtered array. */ function baseFilter(collection, predicate) { var result = []; baseEach(collection, function(value, index, collection) { if (predicate(value, index, collection)) { result.push(value); } }); return result; } /** * The base implementation of `_.flatten` with support for restricting flattening. * * @private * @param {Array} array The array to flatten. * @param {number} depth The maximum recursion depth. * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. * @param {Array} [result=[]] The initial result value. * @returns {Array} Returns the new flattened array. */ function baseFlatten(array, depth, predicate, isStrict, result) { var index = -1, length = array.length; predicate || (predicate = isFlattenable); result || (result = []); while (++index < length) { var value = array[index]; if (depth > 0 && 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 && index < length) { object = object[toKey(path[index++])]; } return (index && index == length) ? object : undefined$1; } /** * The base implementation of `getAllKeys` and `getAllKeysIn` which uses * `keysFunc` and `symbolsFunc` to get the enumerable property names and * symbols of `object`. * * @private * @param {Object} object The object to query. * @param {Function} keysFunc The function to get the keys of `object`. * @param {Function} symbolsFunc The function to get the symbols of `object`. * @returns {Array} Returns the array of property names and symbols. */ function baseGetAllKeys(object, keysFunc, symbolsFunc) { var result = keysFunc(object); return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); } /** * The base implementation of `getTag` without fallbacks for buggy environments. * * @private * @param {*} value The value to query. * @returns {string} Returns the `toStringTag`. */ function baseGetTag(value) { if (value == null) { return value === undefined$1 ? undefinedTag : nullTag; } return (symToStringTag && symToStringTag in Object(value)) ? getRawTag(value) : objectToString(value); } /** * The base implementation of `_.gt` which doesn't coerce arguments. * * @private * @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`. */ function baseGt(value, other) { return value > other; } /** * 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 < nativeMax(start, end); } /** * The base implementation of methods like `_.intersection`, without support * for iteratee shorthands, that accepts an array of arrays to inspect. * * @private * @param {Array} arrays The arrays to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new array of shared values. */ function baseIntersection(arrays, iteratee, comparator) { var includes = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = []; while (othIndex--) { var array = arrays[othIndex]; if (othIndex && iteratee) { array = arrayMap(array, baseUnary(iteratee)); } maxLength = nativeMin(array.length, maxLength); caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) ? new SetCache(othIndex && array) : undefined$1; } array = arrays[0]; var index = -1, seen = caches[0]; outer: while (++index < length && result.length < maxLength) { var value = array[index], computed = iteratee ? iteratee(value) : value; value = (comparator || value !== 0) ? value : 0; if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator) )) { othIndex = othLength; while (--othIndex) { var cache = caches[othIndex]; if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator)) ) { continue outer; } } if (seen) { seen.push(computed); } result.push(value); } } return result; } /** * The base implementation of `_.invert` and `_.invertBy` which inverts * `object` with values transformed by `iteratee` and set by `setter`. * * @private * @param {Object} object The object to iterate over. * @param {Function} setter The function to set `accumulator` values. * @param {Function} iteratee The iteratee to transform values. * @param {Object} accumulator The initial inverted object. * @returns {Function} Returns `accumulator`. */ function baseInverter(object, setter, iteratee, accumulator) { baseForOwn(object, function(value, key, object) { setter(accumulator, iteratee(value), key, object); }); return accumulator; } /** * The base implementation of `_.invoke` without support for individual * method arguments. * * @private * @param {Object} object The object to query. * @param {Array|string} path The path of the method to invoke. * @param {Array} args The arguments to invoke the method with. * @returns {*} Returns the result of the invoked method. */ function baseInvoke(object, path, args) { path = castPath(path, object); object = parent(object, path); var func = object == null ? object : object[toKey(last(path))]; return func == null ? undefined$1 : apply(func, object, args); } /** * The base implementation of `_.isArguments`. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is an `arguments` object, */ function baseIsArguments(value) { return isObjectLike(value) && baseGetTag(value) == argsTag; } /** * The base implementation of `_.isArrayBuffer` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. */ function baseIsArrayBuffer(value) { return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; } /** * The base implementation of `_.isDate` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a date object, else `false`. */ function baseIsDate(value) { return isObjectLike(value) && baseGetTag(value) == dateTag; } /** * The base implementation of `_.isEqual` which supports partial comparisons * and tracks traversed objects. * * @private * @param {*} value The value to compare. * @param {*} other The other value to compare. * @param {boolean} bitmask The bitmask flags. * 1 - Unordered comparison * 2 - Partial comparison * @param {Function} [customizer] The function to customize comparisons. * @param {Object} [stack] Tracks traversed `value` and `other` objects. * @returns {boolean} Returns `true` if the values are equivalent, else `false`. */ function baseIsEqual(value, other, bitmask, customizer, stack) { if (value === other) { return true; } if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { return value !== value && other !== other; } return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); } /** * A specialized version of `baseIsEqual` for arrays and objects which performs * deep comparisons and tracks traversed objects enabling objects with circular * references to be compared. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} [stack] Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other); objTag = objTag == argsTag ? objectTag : objTag; othTag = othTag == argsTag ? objectTag : othTag; var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag; if (isSameTag && isBuffer(object)) { if (!isBuffer(other)) { return false; } objIsArr = true; objIsObj = false; } if (isSameTag && !objIsObj) { stack || (stack = new Stack); return (objIsArr || isTypedArray(object)) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); } if (!(bitmask & COMPARE_PARTIAL_FLAG)) { var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); if (objIsWrapped || othIsWrapped) { var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other; stack || (stack = new Stack); return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); } } if (!isSameTag) { return false; } stack || (stack = new Stack); return equalObjects(object, other, bitmask, customizer, equalFunc, stack); } /** * The base implementation of `_.isMap` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a map, else `false`. */ function baseIsMap(value) { return isObjectLike(value) && getTag(value) == mapTag; } /** * The base implementation of `_.isMatch` without support for iteratee shorthands. * * @private * @param {Object} object The object to inspect. * @param {Object} source The object of property values to match. * @param {Array} matchData The property names, values, and compare flags to match. * @param {Function} [customizer] The function to customize comparisons. * @returns {boolean} Returns `true` if `object` is a match, else `false`. */ function baseIsMatch(object, source, matchData, customizer) { var index = matchData.length, length = index, noCustomizer = !customizer; if (object == null) { return !length; } object = Object(object); while (index--) { var data = matchData[index]; if ((noCustomizer && data[2]) ? data[1] !== object[data[0]] : !(data[0] in object) ) { return false; } } while (++index < length) { data = matchData[index]; var key = data[0], objValue = object[key], srcValue = data[1]; if (noCustomizer && data[2]) { if (objValue === undefined$1 && !(key in object)) { return false; } } else { var stack = new Stack; if (customizer) { var result = customizer(objValue, srcValue, key, object, source, stack); } if (!(result === undefined$1 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result )) { return false; } } } return true; } /** * The base implementation of `_.isNative` without bad shim checks. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a native function, * else `false`. */ function baseIsNative(value) { if (!isObject(value) || isMasked(value)) { return false; } var pattern = isFunction(value) ? reIsNative : reIsHostCtor; return pattern.test(toSource(value)); } /** * The base implementation of `_.isRegExp` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. */ function baseIsRegExp(value) { return isObjectLike(value) && baseGetTag(value) == regexpTag; } /** * The base implementation of `_.isSet` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a set, else `false`. */ function baseIsSet(value) { return isObjectLike(value) && getTag(value) == setTag; } /** * The base implementation of `_.isTypedArray` without Node.js optimizations. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. */ function baseIsTypedArray(value) { return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; } /** * The base implementation of `_.iteratee`. * * @private * @param {*} [value=_.identity] The value to convert to an iteratee. * @returns {Function} Returns the iteratee. */ function baseIteratee(value) { // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. if (typeof value == 'function') { return value; } if (value == null) { return identity; } if (typeof value == 'object') { return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); } return property(value); } /** * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. */ function baseKeys(object) { if (!isPrototype(object)) { return nativeKeys(object); } var result = []; for (var key in Object(object)) { if (hasOwnProperty.call(object, key) && key != 'constructor') { result.push(key); } } return result; } /** * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. */ function baseKeysIn(object) { if (!isObject(object)) { return nativeKeysIn(object); } var isProto = isPrototype(object), result = []; for (var key in object) { if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { result.push(key); } } return result; } /** * The base implementation of `_.lt` which doesn't coerce arguments. * * @private * @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`. */ function baseLt(value, other) { return value < other; } /** * The base implementation of `_.map` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns the new mapped array. */ function baseMap(collection, iteratee) { var index = -1, result = isArrayLike(collection) ? Array(collection.length) : []; baseEach(collection, function(value, key, collection) { result[++index] = iteratee(value, key, collection); }); return result; } /** * The base implementation of `_.matches` which doesn't clone `source`. * * @private * @param {Object} source The object of property values to match. * @returns {Function} Returns the new spec function. */ function baseMatches(source) { var matchData = getMatchData(source); if (matchData.length == 1 && matchData[0][2]) { return matchesStrictComparable(matchData[0][0], matchData[0][1]); } return function(object) { return object === source || baseIsMatch(object, source, matchData); }; } /** * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. * * @private * @param {string} path The path of the property to get. * @param {*} srcValue The value to match. * @returns {Function} Returns the new spec function. */ function baseMatchesProperty(path, srcValue) { if (isKey(path) && isStrictComparable(srcValue)) { return matchesStrictComparable(toKey(path), srcValue); } return function(object) { var objValue = get(object, path); return (objValue === undefined$1 && objValue === srcValue) ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); }; } /** * The base implementation of `_.merge` without support for multiple sources. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {number} srcIndex The index of `source`. * @param {Function} [customizer] The function to customize merged values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMerge(object, source, srcIndex, customizer, stack) { if (object === source) { return; } baseFor(source, function(srcValue, key) { stack || (stack = new Stack); if (isObject(srcValue)) { baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); } else { var newValue = customizer ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) : undefined$1; if (newValue === undefined$1) { newValue = srcValue; } assignMergeValue(object, key, newValue); } }, keysIn); } /** * A specialized version of `baseMerge` for arrays and objects which performs * deep merges and tracks traversed objects enabling objects with circular * references to be merged. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {string} key The key of the value to merge. * @param {number} srcIndex The index of `source`. * @param {Function} mergeFunc The function to merge values. * @param {Function} [customizer] The function to customize assigned values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue); if (stacked) { assignMergeValue(object, key, stacked); return; } var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined$1; var isCommon = newValue === undefined$1; if (isCommon) { var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue); newValue = srcValue; if (isArr || isBuff || isTyped) { if (isArray(objValue)) { newValue = objValue; } else if (isArrayLikeObject(objValue)) { newValue = copyArray(objValue); } else if (isBuff) { isCommon = false; newValue = cloneBuffer(srcValue, true); } else if (isTyped) { isCommon = false; newValue = cloneTypedArray(srcValue, true); } else { newValue = []; } } else if (isPlainObject(srcValue) || isArguments(srcValue)) { newValue = objValue; if (isArguments(objValue)) { newValue = toPlainObject(objValue); } else if (!isObject(objValue) || isFunction(objValue)) { newValue = initCloneObject(srcValue); } } else { isCommon = false; } } if (isCommon) { // Recursively merge objects and arrays (susceptible to call stack limits). stack.set(srcValue, newValue); mergeFunc(newValue, srcValue, srcIndex, customizer, stack); stack['delete'](srcValue); } assignMergeValue(object, key, newValue); } /** * The base implementation of `_.nth` which doesn't coerce arguments. * * @private * @param {Array} array The array to query. * @param {number} n The index of the element to return. * @returns {*} Returns the nth element of `array`. */ function baseNth(array, n) { var length = array.length; if (!length) { return; } n += n < 0 ? length : 0; return isIndex(n, length) ? array[n] : undefined$1; } /** * The base implementation of `_.orderBy` without param guards. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. * @param {string[]} orders The sort orders of `iteratees`. * @returns {Array} Returns the new sorted array. */ function baseOrderBy(collection, iteratees, orders) { if (iteratees.length) { iteratees = arrayMap(iteratees, function(iteratee) { if (isArray(iteratee)) { return function(value) { return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee); } } return iteratee; }); } else { iteratees = [identity]; } var index = -1; iteratees = arrayMap(iteratees, baseUnary(getIteratee())); var result = baseMap(collection, function(value, key, collection) { var criteria = arrayMap(iteratees, function(iteratee) { return iteratee(value); }); return { 'criteria': criteria, 'index': ++index, 'value': value }; }); return baseSortBy(result, function(object, other) { return compareMultiple(object, other, orders); }); } /** * The base implementation of `_.pick` without support for individual * property identifiers. * * @private * @param {Object} object The source object. * @param {string[]} paths The property paths to pick. * @returns {Object} Returns the new object. */ function basePick(object, paths) { return basePickBy(object, paths, function(value, path) { return hasIn(object, path); }); } /** * The base implementation of `_.pickBy` without support for iteratee shorthands. * * @private * @param {Object} object The source object. * @param {string[]} paths The property paths to pick. * @param {Function} predicate The function invoked per property. * @returns {Object} Returns the new object. */ function basePickBy(object, paths, predicate) { var index = -1, length = paths.length, result = {}; while (++index < length) { var path = paths[index], value = baseGet(object, path); if (predicate(value, path)) { baseSet(result, castPath(path, object), value); } } return result; } /** * A specialized version of `baseProperty` which supports deep paths. * * @private * @param {Array|string} path The path of the property to get. * @returns {Function} Returns the new accessor function. */ function basePropertyDeep(path) { return function(object) { return baseGet(object, path); }; } /** * The base implementation of `_.pullAllBy` without support for iteratee * shorthands. * * @private * @param {Array} array The array to modify. * @param {Array} values The values to remove. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns `array`. */ function basePullAll(array, values, iteratee, comparator) { var indexOf = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values.length, seen = array; if (array === values) { values = copyArray(values); } if (iteratee) { seen = arrayMap(array, baseUnary(iteratee)); } while (++index < length) { var fromIndex = 0, value = values[index], computed = iteratee ? iteratee(value) : value; while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -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 && ++index < length) { var key = toKey(path[index]), newValue = value; if (key === '__proto__' || key === 'constructor' || key === 'prototype') { return object; } if (index != lastIndex) { var objValue = nested[key]; newValue = customizer ? customizer(objValue, key, nested) : undefined$1; if (newValue === undefined$1) { newValue = isObject(objValue) ? objValue : (isIndex(path[index + 1]) ? [] : {}); } } assignValue(nested, key, newValue); nested = nested[key]; } return object; } /** * The base implementation of `setData` without support for hot loop shorting. * * @private * @param {Function} func The function to associate metadata with. * @param {*} data The metadata. * @returns {Function} Returns `func`. */ var baseSetData = !metaMap ? identity : function(func, data) { metaMap.set(func, data); return func; }; /** * The base implementation of `setToString` without support for hot loop shorting. * * @private * @param {Function} func The function to modify. * @param {Function} string The `toString` result. * @returns {Function} Returns `func`. */ var baseSetToString = !defineProperty ? identity : function(func, string) { return defineProperty(func, 'toString', { 'configurable': true, 'enumerable': false, 'value': constant(string), 'writable': true }); }; /** * The base implementation of `_.shuffle`. * * @private * @param {Array|Object} collection The collection to shuffle. * @returns {Array} Returns the new shuffled array. */ function baseShuffle(collection) { return shuffleSelf(values(collection)); } /** * The base implementation of `_.slice` without an iteratee call guard. * * @private * @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 baseSlice(array, start, end) { var index = -1, length = array.length; if (start < 0) { start = -start > length ? 0 : (length + start); } end = end > length ? length : end; if (end < 0) { end += length; } length = start > end ? 0 : ((end - start) >>> 0); start >>>= 0; var result = Array(length); while (++index < length) { result[index] = array[index + start]; } return result; } /** * The base implementation of `_.some` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {boolean} Returns `true` if any element passes the predicate check, * else `false`. */ function baseSome(collection, predicate) { var result; baseEach(collection, function(value, index, collection) { result = predicate(value, index, collection); return !result; }); return !!result; } /** * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which * performs a binary search of `array` to determine the index at which `value` * should be inserted into `array` in order to maintain its sort order. * * @private * @param {Array} array The sorted array to inspect. * @param {*} value The value to evaluate. * @param {boolean} [retHighest] Specify returning the highest qualified index. * @returns {number} Returns the index at which `value` should be inserted * into `array`. */ function baseSortedIndex(array, value, retHighest) { var low = 0, high = array == null ? low : array.length; if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { while (low < high) { var mid = (low + high) >>> 1, computed = array[mid]; if (computed !== null && !isSymbol(computed) && (retHighest ? (computed <= value) : (computed < value))) { low = mid + 1; } else { high = mid; } } return high; } return baseSortedIndexBy(array, value, identity, retHighest); } /** * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` * which invokes `iteratee` for `value` and each element of `array` to compute * their sort ranking. The iteratee is invoked with one argument; (value). * * @private * @param {Array} array The sorted array to inspect. * @param {*} value The value to evaluate. * @param {Function} iteratee The iteratee invoked per element. * @param {boolean} [retHighest] Specify returning the highest qualified index. * @returns {number} Returns the index at which `value` should be inserted * into `array`. */ function baseSortedIndexBy(array, value, iteratee, retHighest) { var low = 0, high = array == null ? 0 : array.length; if (high === 0) { return 0; } value = iteratee(value); var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined$1; while (low < high) { var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== undefined$1, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed); if (valIsNaN) { var setLow = retHighest || othIsReflexive; } else if (valIsUndefined) { setLow = othIsReflexive && (retHighest || othIsDefined); } else if (valIsNull) { setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); } else if (valIsSymbol) { setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); } else if (othIsNull || othIsSymbol) { setLow = false; } else { setLow = retHighest ? (computed <= value) : (computed < value); } if (setLow) { low = mid + 1; } else { high = mid; } } return nativeMin(high, MAX_ARRAY_INDEX); } /** * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without * support for iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @returns {Array} Returns the new duplicate free array. */ function baseSortedUniq(array, iteratee) { var index = -1, length = array.length, resIndex = 0, result = []; while (++index < length) { var value = array[index], computed = iteratee ? iteratee(value) : value; if (!index || !eq(computed, seen)) { var seen = computed; result[resIndex++] = value === 0 ? 0 : value; } } return result; } /** * The base implementation of `_.toNumber` which doesn't ensure correct * conversions of binary, hexadecimal, or octal string values. * * @private * @param {*} value The value to process. * @returns {number} Returns the number. */ function baseToNumber(value) { if (typeof value == 'number') { return value; } if (isSymbol(value)) { return NAN; } return +value; } /** * The base implementation of `_.toString` which doesn't convert nullish * values to empty strings. * * @private * @param {*} value The value to process. * @returns {string} Returns the string. */ function baseToString(value) { // Exit early for strings to avoid a performance hit in some environments. if (typeof value == 'string') { return value; } if (isArray(value)) { // Recursively convert values (susceptible to call stack limits). return arrayMap(value, baseToString) + ''; } if (isSymbol(value)) { return symbolToString ? symbolToString.call(value) : ''; } var result = (value + ''); return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; } /** * The base implementation of `_.uniqBy` without support for iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new duplicate free array. */ function baseUniq(array, iteratee, comparator) { var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result; if (comparator) { isCommon = false; includes = arrayIncludesWith; } else if (length >= 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) { var value = array[index], computed = iteratee ? iteratee(value) : value; value = (comparator || value !== 0) ? value : 0; if (isCommon && computed === computed) { var seenIndex = seen.length; while (seenIndex--) { if (seen[seenIndex] === computed) { continue outer; } } if (iteratee) { seen.push(computed); } result.push(value); } else if (!includes(seen, computed, comparator)) { if (seen !== result) { seen.push(computed); } result.push(value); } } return result; } /** * The base implementation of `_.unset`. * * @private * @param {Object} object The object to modify. * @param {Array|string} path The property path to unset. * @returns {boolean} Returns `true` if the property is deleted, else `false`. */ function baseUnset(object, path) { path = castPath(path, object); object = parent(object, path); return object == null || delete object[toKey(last(path))]; } /** * The base implementation of `_.update`. * * @private * @param {Object} object The object to modify. * @param {Array|string} path The path of the property to update. * @param {Function} updater The function to produce the updated value. * @param {Function} [customizer] The function to customize path creation. * @returns {Object} Returns `object`. */ function baseUpdate(object, path, updater, customizer) { return baseSet(object, path, updater(baseGet(object, path)), customizer); } /** * The base implementation of methods like `_.dropWhile` and `_.takeWhile` * without support for iteratee shorthands. * * @private * @param {Array} array The array to query. * @param {Function} predicate The function invoked per iteration. * @param {boolean} [isDrop] Specify dropping elements instead of taking them. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Array} Returns the slice of `array`. */ function baseWhile(array, predicate, isDrop, fromRight) { var length = array.length, index = fromRight ? length : -1; while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {} return isDrop ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length)) : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index)); } /** * The base implementation of `wrapperValue` which returns the result of * performing a sequence of actions on the unwrapped `value`, where each * successive action is supplied the return value of the previous. * * @private * @param {*} value The unwrapped value. * @param {Array} actions Actions to perform to resolve the unwrapped value. * @returns {*} Returns the resolved value. */ function baseWrapperValue(value, actions) { var result = value; if (result instanceof LazyWrapper) { result = result.value(); } return arrayReduce(actions, function(result, action) { return action.func.apply(action.thisArg, arrayPush([result], action.args)); }, result); } /** * The base implementation of methods like `_.xor`, without support for * iteratee shorthands, that accepts an array of arrays to inspect. * * @private * @param {Array} arrays The arrays to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new array of values. */ function baseXor(arrays, iteratee, comparator) { var length = arrays.length; if (length < 2) { return length ? baseUniq(arrays[0]) : []; } var index = -1, result = Array(length); while (++index < length) { var array = arrays[index], othIndex = -1; while (++othIndex < length) { if (othIndex != index) { result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); } } } return baseUniq(baseFlatten(result, 1), iteratee, comparator); } /** * This base implementation of `_.zipObject` which assigns values using `assignFunc`. * * @private * @param {Array} props The property identifiers. * @param {Array} values The property values. * @param {Function} assignFunc The function to assign values. * @returns {Object} Returns the new object. */ function baseZipObject(props, values, assignFunc) { var index = -1, length = props.length, valsLength = values.length, result = {}; while (++index < length) { var value = index < valsLength ? values[index] : undefined$1; assignFunc(result, props[index], value); } return result; } /** * Casts `value` to an empty array if it's not an array like object. * * @private * @param {*} value The value to inspect. * @returns {Array|Object} Returns the cast array-like object. */ function castArrayLikeObject(value) { return isArrayLikeObject(value) ? value : []; } /** * Casts `value` to `identity` if it's not a function. * * @private * @param {*} value The value to inspect. * @returns {Function} Returns cast function. */ function castFunction(value) { return typeof value == 'function' ? value : identity; } /** * Casts `value` to a path array if it's not one. * * @private * @param {*} value The value to inspect. * @param {Object} [object] The object to query keys on. * @returns {Array} Returns the cast property path array. */ function castPath(value, object) { if (isArray(value)) { return value; } return isKey(value, object) ? [value] : stringToPath(toString(value)); } /** * A `baseRest` alias which can be replaced with `identity` by module * replacement plugins. * * @private * @type {Function} * @param {Function} func The function to apply a rest parameter to. * @returns {Function} Returns the new function. */ var castRest = baseRest; /** * Casts `array` to a slice if it's needed. * * @private * @param {Array} array The array to inspect. * @param {number} start The start position. * @param {number} [end=array.length] The end position. * @returns {Array} Returns the cast slice. */ function castSlice(array, start, end) { var length = array.length; end = end === undefined$1 ? length : end; return (!start && end >= 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 < other) || (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || (othIsNull && valIsDefined && valIsReflexive) || (!othIsDefined && valIsReflexive) || !othIsReflexive) { return -1; } } return 0; } /** * Used by `_.orderBy` to compare multiple properties of a value to another * and stable sort them. * * 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. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {boolean[]|string[]} orders The order to sort by for each property. * @returns {number} Returns the sort order indicator for `object`. */ function compareMultiple(object, other, orders) { var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length; while (++index < length) { var result = compareAscending(objCriteria[index], othCriteria[index]); if (result) { if (index >= 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 (++leftIndex < leftLength) { result[leftIndex] = partials[leftIndex]; } while (++argsIndex < holdersLength) { if (isUncurried || argsIndex < argsLength) { result[holders[argsIndex]] = args[argsIndex]; } } while (rangeLength--) { result[leftIndex++] = args[argsIndex++]; } return result; } /** * This function is like `composeArgs` except that the arguments composition * is tailored for `_.partialRight`. * * @private * @param {Array} args The provided arguments. * @param {Array} partials The arguments to append 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 composeArgsRight(args, partials, holders, isCurried) { var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result = Array(rangeLength + rightLength), isUncurried = !isCurried; while (++argsIndex < rangeLength) { result[argsIndex] = args[argsIndex]; } var offset = argsIndex; while (++rightIndex < rightLength) { result[offset + rightIndex] = partials[rightIndex]; } while (++holdersIndex < holdersLength) { if (isUncurried || argsIndex < argsLength) { result[offset + holders[holdersIndex]] = args[argsIndex++]; } } return result; } /** * Copies the values of `source` to `array`. * * @private * @param {Array} source The array to copy values from. * @param {Array} [array=[]] The array to copy values to. * @returns {Array} Returns `array`. */ function copyArray(source, array) { var index = -1, length = source.length; array || (array = Array(length)); while (++index < length) { array[index] = source[index]; } return array; } /** * Copies properties of `source` to `object`. * * @private * @param {Object} source The object to copy properties from. * @param {Array} props The property identifiers to copy. * @param {Object} [object={}] The object to copy properties to. * @param {Function} [customizer] The function to customize copied values. * @returns {Object} Returns `object`. */ function copyObject(source, props, object, customizer) { var isNew = !object; object || (object = {}); var index = -1, length = props.length; while (++index < length) { var key = props[index]; var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined$1; if (newValue === undefined$1) { newValue = source[key]; } if (isNew) { baseAssignValue(object, key, newValue); } else { assignValue(object, key, newValue); } } return object; } /** * Copies own symbols of `source` to `object`. * * @private * @param {Object} source The object to copy symbols from. * @param {Object} [object={}] The object to copy symbols to. * @returns {Object} Returns `object`. */ function copySymbols(source, object) { return copyObject(source, getSymbols(source), object); } /** * Copies own and inherited symbols of `source` to `object`. * * @private * @param {Object} source The object to copy symbols from. * @param {Object} [object={}] The object to copy symbols to. * @returns {Object} Returns `object`. */ function copySymbolsIn(source, object) { return copyObject(source, getSymbolsIn(source), object); } /** * Creates a function like `_.groupBy`. * * @private * @param {Function} setter The function to set accumulator values. * @param {Function} [initializer] The accumulator object initializer. * @returns {Function} Returns the new aggregator function. */ function createAggregator(setter, initializer) { return function(collection, iteratee) { var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {}; return func(collection, setter, getIteratee(iteratee, 2), accumulator); }; } /** * Creates a function like `_.assign`. * * @private * @param {Function} assigner The function to assign values. * @returns {Function} Returns the new assigner function. */ function createAssigner(assigner) { return baseRest(function(object, sources) { var index = -1, length = sources.length, customizer = length > 1 ? 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 < length) { var source = sources[index]; if (source) { assigner(object, source, index, customizer); } } return object; }); } /** * Creates a `baseEach` or `baseEachRight` function. * * @private * @param {Function} eachFunc The function to iterate over a collection. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new base function. */ function createBaseEach(eachFunc, fromRight) { return function(collection, iteratee) { if (collection == null) { return collection; } if (!isArrayLike(collection)) { return eachFunc(collection, iteratee); } var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection); while ((fromRight ? index-- : ++index < length)) { if (iteratee(iterable[index], index, iterable) === false) { break; } } return collection; }; } /** * Creates a base function for methods like `_.forIn` and `_.forOwn`. * * @private * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new base function. */ function createBaseFor(fromRight) { return function(object, iteratee, keysFunc) { var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; while (length--) { var key = props[fromRight ? length : ++index]; if (iteratee(iterable[key], key, iterable) === false) { break; } } return object; }; } /** * Creates a function that wraps `func` to invoke it with the optional `this` * binding of `thisArg`. * * @private * @param {Function} func The function to wrap. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @param {*} [thisArg] The `this` binding of `func`. * @returns {Function} Returns the new wrapped function. */ function createBind(func, bitmask, thisArg) { var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); function wrapper() { var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; return fn.apply(isBind ? thisArg : this, arguments); } return wrapper; } /** * Creates a function like `_.lowerFirst`. * * @private * @param {string} methodName The name of the `String` case method to use. * @returns {Function} Returns the new case function. */ function createCaseFirst(methodName) { return function(string) { string = toString(string); var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined$1; var chr = strSymbols ? strSymbols[0] : string.charAt(0); var trailing = strSymbols ? castSlice(strSymbols, 1).join('') : string.slice(1); return chr[methodName]() + trailing; }; } /** * Creates a function like `_.camelCase`. * * @private * @param {Function} callback The function to combine each word. * @returns {Function} Returns the new compounder function. */ function createCompounder(callback) { return function(string) { return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); }; } /** * Creates a function that produces an instance of `Ctor` regardless of * whether it was invoked as part of a `new` expression or by `call` or `apply`. * * @private * @param {Function} Ctor The constructor to wrap. * @returns {Function} Returns the new wrapped function. */ function createCtor(Ctor) { return function() { // Use a `switch` statement to work with class constructors. See // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist // for more details. var args = arguments; switch (args.length) { case 0: return new Ctor; case 1: return new Ctor(args[0]); case 2: return new Ctor(args[0], args[1]); case 3: return new Ctor(args[0], args[1], args[2]); case 4: return new Ctor(args[0], args[1], args[2], args[3]); case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]); case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); } var thisBinding = baseCreate(Ctor.prototype), result = Ctor.apply(thisBinding, args); // Mimic the constructor's `return` behavior. // See https://es5.github.io/#x13.2.2 for more details. return isObject(result) ? result : thisBinding; }; } /** * Creates a function that wraps `func` to enable currying. * * @private * @param {Function} func The function to wrap. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @param {number} arity The arity of `func`. * @returns {Function} Returns the new wrapped function. */ function createCurry(func, bitmask, arity) { var Ctor = createCtor(func); function wrapper() { var length = arguments.length, args = Array(length), index = length, placeholder = getHolder(wrapper); while (index--) { args[index] = arguments[index]; } var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder) ? [] : replaceHolders(args, placeholder); length -= holders.length; if (length < arity) { return createRecurry( func, bitmask, createHybrid, wrapper.placeholder, undefined$1, args, holders, undefined$1, undefined$1, arity - length); } var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; return apply(fn, this, args); } return wrapper; } /** * Creates a `_.find` or `_.findLast` function. * * @private * @param {Function} findIndexFunc The function to find the collection index. * @returns {Function} Returns the new find function. */ function createFind(findIndexFunc) { return function(collection, predicate, fromIndex) { var iterable = Object(collection); if (!isArrayLike(collection)) { var iteratee = getIteratee(predicate, 3); collection = keys(collection); predicate = function(key) { return iteratee(iterable[key], key, iterable); }; } var index = findIndexFunc(collection, predicate, fromIndex); return 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 (++index < length) { func = funcs[index]; var funcName = getFuncName(func), data = funcName == 'wrapper' ? getData(func) : undefined$1; if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1 ) { wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); } else { wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func); } } return function() { var args = arguments, value = args[0]; if (wrapper && args.length == 1 && isArray(value)) { return wrapper.plant(value).value(); } var index = 0, result = length ? funcs[index].apply(this, args) : value; while (++index < length) { result = funcs[index].call(this, result); } return result; }; }); } /** * Creates a function that wraps `func` to invoke it with optional `this` * binding of `thisArg`, partial application, and currying. * * @private * @param {Function|string} func The function or method name to wrap. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @param {*} [thisArg] The `this` binding of `func`. * @param {Array} [partials] The arguments to prepend to those provided to * the new function. * @param {Array} [holders] The `partials` placeholder indexes. * @param {Array} [partialsRight] The arguments to append to those provided * to the new function. * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. * @param {Array} [argPos] The argument positions of the new function. * @param {number} [ary] The arity cap of `func`. * @param {number} [arity] The arity of `func`. * @returns {Function} Returns the new wrapped function. */ function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined$1 : createCtor(func); function wrapper() { var length = arguments.length, args = Array(length), index = length; while (index--) { args[index] = arguments[index]; } if (isCurried) { var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder); } if (partials) { args = composeArgs(args, partials, holders, isCurried); } if (partialsRight) { args = composeArgsRight(args, partialsRight, holdersRight, isCurried); } length -= holdersCount; if (isCurried && length < arity) { var newHolders = replaceHolders(args, placeholder); return createRecurry( func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary, arity - length ); } var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func; length = args.length; if (argPos) { args = reorder(args, argPos); } else if (isFlip && length > 1) { args.reverse(); } if (isAry && ary < length) { args.length = ary; } if (this && this !== root && this instanceof wrapper) { fn = Ctor || createCtor(fn); } return fn.apply(thisBinding, args); } return wrapper; } /** * Creates a function like `_.invertBy`. * * @private * @param {Function} setter The function to set accumulator values. * @param {Function} toIteratee The function to resolve iteratees. * @returns {Function} Returns the new inverter function. */ function createInverter(setter, toIteratee) { return function(object, iteratee) { return baseInverter(object, setter, toIteratee(iteratee), {}); }; } /** * Creates a function that performs a mathematical operation on two values. * * @private * @param {Function} operator The function to perform the operation. * @param {number} [defaultValue] The value used for `undefined` arguments. * @returns {Function} Returns the new mathematical operation function. */ function createMathOperation(operator, defaultValue) { return function(value, other) { var result; if (value === undefined$1 && other === undefined$1) { return defaultValue; } if (value !== undefined$1) { result = value; } if (other !== undefined$1) { if (result === undefined$1) { return other; } if (typeof value == 'string' || typeof other == 'string') { value = baseToString(value); other = baseToString(other); } else { value = baseToNumber(value); other = baseToNumber(other); } result = operator(value, other); } return result; }; } /** * Creates a function like `_.over`. * * @private * @param {Function} arrayFunc The function to iterate over iteratees. * @returns {Function} Returns the new over function. */ function createOver(arrayFunc) { return flatRest(function(iteratees) { iteratees = arrayMap(iteratees, baseUnary(getIteratee())); return baseRest(function(args) { var thisArg = this; return arrayFunc(iteratees, function(iteratee) { return apply(iteratee, thisArg, args); }); }); }); } /** * Creates the padding for `string` based on `length`. The `chars` string * is truncated if the number of characters exceeds `length`. * * @private * @param {number} length The padding length. * @param {string} [chars=' '] The string used as padding. * @returns {string} Returns the padding for `string`. */ function createPadding(length, chars) { chars = chars === undefined$1 ? ' ' : baseToString(chars); var charsLength = chars.length; if (charsLength < 2) { return charsLength ? baseRepeat(chars, length) : chars; } var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); return hasUnicode(chars) ? castSlice(stringToArray(result), 0, length).join('') : result.slice(0, length); } /** * Creates a function that wraps `func` to invoke it with the `this` binding * of `thisArg` and `partials` prepended to the arguments it receives. * * @private * @param {Function} func The function to wrap. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @param {*} thisArg The `this` binding of `func`. * @param {Array} partials The arguments to prepend to those provided to * the new function. * @returns {Function} Returns the new wrapped function. */ function createPartial(func, bitmask, thisArg, partials) { var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); function wrapper() { var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; while (++leftIndex < leftLength) { args[leftIndex] = partials[leftIndex]; } while (argsLength--) { args[leftIndex++] = arguments[++argsIndex]; } return apply(fn, isBind ? thisArg : this, args); } return wrapper; } /** * Creates a `_.range` or `_.rangeRight` function. * * @private * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new range function. */ function createRange(fromRight) { return function(start, end, step) { if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { end = step = undefined$1; } // Ensure the sign of `-0` is preserved. start = toFinite(start); if (end === undefined$1) { end = start; start = 0; } else { end = toFinite(end); } step = step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step); return baseRange(start, end, step, fromRight); }; } /** * Creates a function that performs a relational operation on two values. * * @private * @param {Function} operator The function to perform the operation. * @returns {Function} Returns the new relational operation function. */ function createRelationalOperation(operator) { return function(value, other) { if (!(typeof value == 'string' && typeof other == 'string')) { value = toNumber(value); other = toNumber(other); } return operator(value, other); }; } /** * Creates a function that wraps `func` to continue currying. * * @private * @param {Function} func The function to wrap. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @param {Function} wrapFunc The function to create the `func` wrapper. * @param {*} placeholder The placeholder value. * @param {*} [thisArg] The `this` binding of `func`. * @param {Array} [partials] The arguments to prepend to those provided to * the new function. * @param {Array} [holders] The `partials` placeholder indexes. * @param {Array} [argPos] The argument positions of the new function. * @param {number} [ary] The arity cap of `func`. * @param {number} [arity] The arity of `func`. * @returns {Function} Returns the new wrapped function. */ function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined$1, newHoldersRight = isCurry ? undefined$1 : holders, newPartials = isCurry ? partials : undefined$1, newPartialsRight = isCurry ? undefined$1 : partials; bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG); bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); } var newData = [ func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, newHoldersRight, argPos, ary, arity ]; var result = wrapFunc.apply(undefined$1, newData); if (isLaziable(func)) { setData(result, newData); } result.placeholder = placeholder; return setWrapToString(result, func, bitmask); } /** * Creates a function like `_.round`. * * @private * @param {string} methodName The name of the `Math` method to use when rounding. * @returns {Function} Returns the new round function. */ function createRound(methodName) { var func = Math[methodName]; return function(number, precision) { number = toNumber(number); precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); if (precision && nativeIsFinite(number)) { // Shift with exponential notation to avoid floating-point issues. // See [MDN](https://mdn.io/round#Examples) for more details. var pair = (toString(number) + 'e').split('e'), value = func(pair[0] + 'e' + (+pair[1] + precision)); pair = (toString(value) + 'e').split('e'); return +(pair[0] + 'e' + (+pair[1] - precision)); } return func(number); }; } /** * Creates a set object of `values`. * * @private * @param {Array} values The values to add to the set. * @returns {Object} Returns the new set. */ var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { return new Set(values); }; /** * Creates a `_.toPairs` or `_.toPairsIn` function. * * @private * @param {Function} keysFunc The function to get the keys of a given object. * @returns {Function} Returns the new pairs function. */ function createToPairs(keysFunc) { return function(object) { var tag = getTag(object); if (tag == mapTag) { return mapToArray(object); } if (tag == setTag) { return setToPairs(object); } return baseToPairs(object, keysFunc(object)); }; } /** * Creates a function that either curries or invokes `func` with optional * `this` binding and partially applied arguments. * * @private * @param {Function|string} func The function or method name to wrap. * @param {number} bitmask The bitmask flags. * 1 - `_.bind` * 2 - `_.bindKey` * 4 - `_.curry` or `_.curryRight` of a bound function * 8 - `_.curry` * 16 - `_.curryRight` * 32 - `_.partial` * 64 - `_.partialRight` * 128 - `_.rearg` * 256 - `_.ary` * 512 - `_.flip` * @param {*} [thisArg] The `this` binding of `func`. * @param {Array} [partials] The arguments to be partially applied. * @param {Array} [holders] The `partials` placeholder indexes. * @param {Array} [argPos] The argument positions of the new function. * @param {number} [ary] The arity cap of `func`. * @param {number} [arity] The arity of `func`. * @returns {Function} Returns the new wrapped function. */ function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; if (!isBindKey && typeof func != 'function') { throw new TypeError(FUNC_ERROR_TEXT); } var length = partials ? partials.length : 0; if (!length) { bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); partials = holders = undefined$1; } ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0); arity = arity === undefined$1 ? arity : toInteger(arity); length -= holders ? holders.length : 0; if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { var partialsRight = partials, holdersRight = holders; partials = holders = undefined$1; } var data = isBindKey ? undefined$1 : getData(func); var newData = [ func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity ]; if (data) { mergeData(newData, data); } func = newData[0]; bitmask = newData[1]; thisArg = newData[2]; partials = newData[3]; holders = newData[4]; arity = newData[9] = newData[9] === undefined$1 ? (isBindKey ? 0 : func.length) : nativeMax(newData[9] - length, 0); if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); } if (!bitmask || bitmask == WRAP_BIND_FLAG) { var result = createBind(func, bitmask, thisArg); } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { result = createCurry(func, bitmask, arity); } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { result = createPartial(func, bitmask, thisArg, partials); } else { result = createHybrid.apply(undefined$1, newData); } var setter = data ? baseSetData : setData; return setWrapToString(setter(result, newData), func, bitmask); } /** * Used by `_.defaults` to customize its `_.assignIn` use to assign properties * of source objects to the destination object for all destination properties * that resolve to `undefined`. * * @private * @param {*} objValue The destination value. * @param {*} srcValue The source value. * @param {string} key The key of the property to assign. * @param {Object} object The parent object of `objValue`. * @returns {*} Returns the value to assign. */ function customDefaultsAssignIn(objValue, srcValue, key, object) { if (objValue === undefined$1 || (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { return srcValue; } return objValue; } /** * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source * objects into destination objects that are passed thru. * * @private * @param {*} objValue The destination value. * @param {*} srcValue The source value. * @param {string} key The key of the property to merge. * @param {Object} object The parent object of `objValue`. * @param {Object} source The parent object of `srcValue`. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. * @returns {*} Returns the value to assign. */ function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { if (isObject(objValue) && isObject(srcValue)) { // Recursively merge objects and arrays (susceptible to call stack limits). stack.set(srcValue, objValue); baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack); stack['delete'](srcValue); } return objValue; } /** * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain * objects. * * @private * @param {*} value The value to inspect. * @param {string} key The key of the property to inspect. * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. */ function customOmitClone(value) { return isPlainObject(value) ? undefined$1 : value; } /** * A specialized version of `baseIsEqualDeep` for arrays with support for * partial deep comparisons. * * @private * @param {Array} array The array to compare. * @param {Array} other The other array to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `array` and `other` objects. * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. */ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length; if (arrLength != othLength && !(isPartial && othLength > arrLength)) { return false; } // 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 (++index < arrLength) { var arrValue = array[index], othValue = other[index]; if (customizer) { var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); } if (compared !== undefined$1) { if (compared) { continue; } result = false; break; } // Recursively compare arrays (susceptible to call stack limits). if (seen) { if (!arraySome(other, function(othValue, othIndex) { if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { return seen.push(othIndex); } })) { result = false; break; } } else if (!( arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack) )) { result = false; break; } } stack['delete'](array); stack['delete'](other); return result; } /** * A specialized version of `baseIsEqualDeep` for comparing objects of * the same `toStringTag`. * * **Note:** This function only supports comparing values with tags of * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {string} tag The `toStringTag` of the objects to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { switch (tag) { case dataViewTag: if ((object.byteLength != other.byteLength) || (object.byteOffset != other.byteOffset)) { return false; } object = object.buffer; other = other.buffer; case arrayBufferTag: if ((object.byteLength != other.byteLength) || !equalFunc(new Uint8Array(object), new Uint8Array(other))) { return false; } return true; case boolTag: case dateTag: case numberTag: // Coerce booleans to `1` or `0` and dates to milliseconds. // Invalid dates are coerced to `NaN`. return eq(+object, +other); case errorTag: return object.name == other.name && object.message == other.message; case regexpTag: case stringTag: // Coerce regexes to strings and treat strings, primitives and objects, // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring // for more details. return object == (other + ''); case mapTag: var convert = mapToArray; case setTag: var isPartial = bitmask & COMPARE_PARTIAL_FLAG; convert || (convert = setToArray); if (object.size != other.size && !isPartial) { return false; } // Assume cyclic values are equal. var stacked = stack.get(object); if (stacked) { return stacked == other; } bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits). stack.set(object, other); var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); stack['delete'](object); return result; case symbolTag: if (symbolValueOf) { return symbolValueOf.call(object) == symbolValueOf.call(other); } } return false; } /** * A specialized version of `baseIsEqualDeep` for objects with support for * partial deep comparisons. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length; if (objLength != othLength && !isPartial) { return false; } var index = objLength; while (index--) { var key = objProps[index]; if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { return false; } } // Check that cyclic values are equal. var objStacked = stack.get(object); var othStacked = stack.get(other); if (objStacked && othStacked) { return objStacked == other && othStacked == object; } var result = true; stack.set(object, other); stack.set(other, object); var skipCtor = isPartial; while (++index < objLength) { key = objProps[index]; var objValue = object[key], othValue = other[key]; if (customizer) { var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); } // Recursively compare objects (susceptible to call stack limits). if (!(compared === undefined$1 ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) : compared )) { result = false; break; } skipCtor || (skipCtor = key == 'constructor'); } if (result && !skipCtor) { var objCtor = object.constructor, othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal. if (objCtor != othCtor && ('constructor' in object && 'constructor' in other) && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) { result = false; } } stack['delete'](object); stack['delete'](other); return result; } /** * A specialized version of `baseRest` which flattens the rest array. * * @private * @param {Function} func The function to apply a rest parameter to. * @returns {Function} Returns the new function. */ function flatRest(func) { return setToString(overRest(func, undefined$1, flatten), func + ''); } /** * Creates an array of own enumerable property names and symbols of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names and symbols. */ function getAllKeys(object) { return baseGetAllKeys(object, keys, getSymbols); } /** * Creates an array of own and inherited enumerable property names and * symbols of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names and symbols. */ function getAllKeysIn(object) { return baseGetAllKeys(object, keysIn, getSymbolsIn); } /** * Gets metadata for `func`. * * @private * @param {Function} func The function to query. * @returns {*} Returns the metadata for `func`. */ var getData = !metaMap ? noop : function(func) { return metaMap.get(func); }; /** * Gets the name of `func`. * * @private * @param {Function} func The function to query. * @returns {string} Returns the function name. */ function getFuncName(func) { var result = (func.name + ''), array = realNames[result], length = hasOwnProperty.call(realNames, result) ? array.length : 0; while (length--) { var data = array[length], otherFunc = data.func; if (otherFunc == null || otherFunc == func) { return data.name; } } return result; } /** * Gets the argument placeholder value for `func`. * * @private * @param {Function} func The function to inspect. * @returns {*} Returns the placeholder value. */ function getHolder(func) { var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; return object.placeholder; } /** * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, * this function returns the custom method, otherwise it returns `baseIteratee`. * If arguments are provided, the chosen function is invoked with them and * its result is returned. * * @private * @param {*} [value] The value to convert to an iteratee. * @param {number} [arity] The arity of the created iteratee. * @returns {Function} Returns the chosen function or its result. */ function getIteratee() { var result = lodash.iteratee || iteratee; result = result === iteratee ? baseIteratee : result; return arguments.length ? result(arguments[0], arguments[1]) : result; } /** * Gets the data for `map`. * * @private * @param {Object} map The map to query. * @param {string} key The reference key. * @returns {*} Returns the map data. */ function getMapData(map, key) { var data = map.__data__; return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map; } /** * Gets the property names, values, and compare flags of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the match data of `object`. */ function getMatchData(object) { var result = keys(object), length = result.length; while (length--) { var key = result[length], value = object[key]; result[length] = [key, value, isStrictComparable(value)]; } return result; } /** * Gets the native function at `key` of `object`. * * @private * @param {Object} object The object to query. * @param {string} key The key of the method to get. * @returns {*} Returns the function if it's native, else `undefined`. */ function getNative(object, key) { var value = getValue(object, key); return baseIsNative(value) ? value : undefined$1; } /** * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. * * @private * @param {*} value The value to query. * @returns {string} Returns the raw `toStringTag`. */ function getRawTag(value) { var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag]; try { value[symToStringTag] = undefined$1; var unmasked = true; } catch (e) {} var result = nativeObjectToString.call(value); if (unmasked) { if (isOwn) { value[symToStringTag] = tag; } else { delete value[symToStringTag]; } } return result; } /** * Creates an array of the own enumerable symbols of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of symbols. */ var getSymbols = !nativeGetSymbols ? stubArray : function(object) { if (object == null) { return []; } object = Object(object); return arrayFilter(nativeGetSymbols(object), function(symbol) { return propertyIsEnumerable.call(object, symbol); }); }; /** * Creates an array of the own and inherited enumerable symbols of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of symbols. */ var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { var result = []; while (object) { arrayPush(result, getSymbols(object)); object = getPrototype(object); } return result; }; /** * Gets the `toStringTag` of `value`. * * @private * @param {*} value The value to query. * @returns {string} Returns the `toStringTag`. */ var getTag = baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || (Map && getTag(new Map) != mapTag) || (Promise && getTag(Promise.resolve()) != promiseTag) || (Set && getTag(new Set) != setTag) || (WeakMap && getTag(new WeakMap) != weakMapTag)) { getTag = function(value) { var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : undefined$1, ctorString = Ctor ? toSource(Ctor) : ''; if (ctorString) { switch (ctorString) { case dataViewCtorString: return dataViewTag; case mapCtorString: return mapTag; case promiseCtorString: return promiseTag; case setCtorString: return setTag; case weakMapCtorString: return weakMapTag; } } return result; }; } /** * Gets the view, applying any `transforms` to the `start` and `end` positions. * * @private * @param {number} start The start of the view. * @param {number} end The end of the view. * @param {Array} transforms The transformations to apply to the view. * @returns {Object} Returns an object containing the `start` and `end` * positions of the view. */ function getView(start, end, transforms) { var index = -1, length = transforms.length; while (++index < length) { var data = transforms[index], size = data.size; switch (data.type) { case 'drop': start += size; break; case 'dropRight': end -= size; break; case 'take': end = nativeMin(end, start + size); break; case 'takeRight': start = nativeMax(start, end - size); break; } } return { 'start': start, 'end': end }; } /** * Extracts wrapper details from the `source` body comment. * * @private * @param {string} source The source to inspect. * @returns {Array} Returns the wrapper details. */ function getWrapDetails(source) { var match = source.match(reWrapDetails); return match ? match[1].split(reSplitDetails) : []; } /** * Checks if `path` exists on `object`. * * @private * @param {Object} object The object to query. * @param {Array|string} path The path to check. * @param {Function} hasFunc The function to check properties. * @returns {boolean} Returns `true` if `path` exists, else `false`. */ function hasPath(object, path, hasFunc) { path = castPath(path, object); var index = -1, length = path.length, result = false; while (++index < length) { var key = toKey(path[index]); if (!(result = object != null && hasFunc(object, key))) { break; } object = object[key]; } if (result || ++index != length) { return result; } length = object == null ? 0 : object.length; return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object)); } /** * Initializes an array clone. * * @private * @param {Array} array The array to clone. * @returns {Array} Returns the initialized clone. */ function initCloneArray(array) { var length = array.length, result = new array.constructor(length); // Add properties assigned by `RegExp#exec`. if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { result.index = array.index; result.input = array.input; } return result; } /** * Initializes an object clone. * * @private * @param {Object} object The object to clone. * @returns {Object} Returns the initialized clone. */ function initCloneObject(object) { return (typeof object.constructor == 'function' && !isPrototype(object)) ? baseCreate(getPrototype(object)) : {}; } /** * Initializes an object clone based on its `toStringTag`. * * **Note:** This function only supports cloning values with tags of * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. * * @private * @param {Object} object The object to clone. * @param {string} tag The `toStringTag` of the object to clone. * @param {boolean} [isDeep] Specify a deep clone. * @returns {Object} Returns the initialized clone. */ function initCloneByTag(object, tag, isDeep) { var Ctor = object.constructor; switch (tag) { case arrayBufferTag: return cloneArrayBuffer(object); case boolTag: case dateTag: return new Ctor(+object); case dataViewTag: return cloneDataView(object, isDeep); case float32Tag: case float64Tag: case int8Tag: case int16Tag: case int32Tag: case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: return cloneTypedArray(object, isDeep); case mapTag: return new Ctor; case numberTag: case stringTag: return new Ctor(object); case regexpTag: return cloneRegExp(object); case setTag: return new Ctor; case symbolTag: return cloneSymbol(object); } } /** * Inserts wrapper `details` in a comment at the top of the `source` body. * * @private * @param {string} source The source to modify. * @returns {Array} details The details to insert. * @returns {string} Returns the modified source. */ function insertWrapDetails(source, details) { var length = details.length; if (!length) { return source; } var lastIndex = length - 1; details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; details = details.join(length > 2 ? ', ' : ' '); return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); } /** * 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 && value < length); } /** * Checks if the given arguments are from an iteratee call. * * @private * @param {*} value The potential iteratee value argument. * @param {*} index The potential iteratee index or key argument. * @param {*} object The potential iteratee object argument. * @returns {boolean} Returns `true` if the arguments are from an iteratee call, * else `false`. */ function isIterateeCall(value, index, object) { if (!isObject(object)) { return false; } var type = typeof index; if (type == 'number' ? (isArrayLike(object) && isIndex(index, object.length)) : (type == 'string' && index in object) ) { return eq(object[index], value); } return false; } /** * Checks if `value` is a property name and not a property path. * * @private * @param {*} value The value to check. * @param {Object} [object] The object to query keys on. * @returns {boolean} Returns `true` if `value` is a property name, else `false`. */ function isKey(value, object) { if (isArray(value)) { return false; } var type = typeof value; if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol(value)) { return true; } return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || (object != null && value in Object(object)); } /** * Checks if `value` is suitable for use as unique object key. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is suitable, else `false`. */ function isKeyable(value) { var type = typeof value; return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') ? (value !== '__proto__') : (value === null); } /** * Checks if `func` has a lazy counterpart. * * @private * @param {Function} func The function to check. * @returns {boolean} Returns `true` if `func` has a lazy counterpart, * else `false`. */ function isLaziable(func) { var funcName = getFuncName(func), other = lodash[funcName]; if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { return false; } if (func === other) { return true; } var data = getData(other); return !!data && func === data[0]; } /** * Checks if `func` has its source masked. * * @private * @param {Function} func The function to check. * @returns {boolean} Returns `true` if `func` is masked, else `false`. */ function isMasked(func) { return !!maskSrcKey && (maskSrcKey in func); } /** * Checks if `func` is capable of being masked. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `func` is maskable, else `false`. */ var isMaskable = coreJsData ? isFunction : stubFalse; /** * Checks if `value` is likely a prototype object. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. */ function isPrototype(value) { var Ctor = value && value.constructor, proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; return value === proto; } /** * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` if suitable for strict * equality comparisons, else `false`. */ function isStrictComparable(value) { return value === value && !isObject(value); } /** * A specialized version of `matchesProperty` for source values suitable * for strict equality comparisons, i.e. `===`. * * @private * @param {string} key The key of the property to get. * @param {*} srcValue The value to match. * @returns {Function} Returns the new spec function. */ function matchesStrictComparable(key, srcValue) { return function(object) { if (object == null) { return false; } return object[key] === srcValue && (srcValue !== undefined$1 || (key in Object(object))); }; } /** * A specialized version of `_.memoize` which clears the memoized function's * cache when it exceeds `MAX_MEMOIZE_SIZE`. * * @private * @param {Function} func The function to have its output memoized. * @returns {Function} Returns the new memoized function. */ function memoizeCapped(func) { var result = memoize(func, function(key) { if (cache.size === MAX_MEMOIZE_SIZE) { cache.clear(); } return key; }); var cache = result.cache; return result; } /** * Merges the function metadata of `source` into `data`. * * Merging metadata reduces the number of wrappers used to invoke a function. * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` * may be applied regardless of execution order. Methods like `_.ary` and * `_.rearg` modify function arguments, making the order in which they are * executed important, preventing the merging of metadata. However, we make * an exception for a safe combined case where curried functions have `_.ary` * and or `_.rearg` applied. * * @private * @param {Array} data The destination metadata. * @param {Array} source The source metadata. * @returns {Array} Returns `data`. */ function mergeData(data, source) { var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); var isCombo = ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) || ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) || ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG)); // Exit early if metadata can't be merged. if (!(isCommon || isCombo)) { return data; } // Use source `thisArg` if available. if (srcBitmask & WRAP_BIND_FLAG) { data[2] = source[2]; // Set when currying a bound function. newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; } // Compose partial arguments. var value = source[3]; if (value) { var partials = data[3]; data[3] = partials ? composeArgs(partials, value, source[4]) : value; data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; } // Compose partial right arguments. value = source[5]; if (value) { partials = data[5]; data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; } // Use source `argPos` if available. value = source[7]; if (value) { data[7] = value; } // Use source `ary` if it's smaller. if (srcBitmask & WRAP_ARY_FLAG) { data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); } // Use source `arity` if one is not provided. if (data[9] == null) { data[9] = source[9]; } // Use source `func` and merge bitmasks. data[0] = source[0]; data[1] = newBitmask; return data; } /** * This function is like * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) * except that it includes inherited enumerable properties. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the array of property names. */ function nativeKeysIn(object) { var result = []; if (object != null) { for (var key in Object(object)) { result.push(key); } } return result; } /** * Converts `value` to a string using `Object.prototype.toString`. * * @private * @param {*} value The value to convert. * @returns {string} Returns the converted string. */ function objectToString(value) { return nativeObjectToString.call(value); } /** * A specialized version of `baseRest` which transforms the rest array. * * @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. * @param {Function} transform The rest array transform. * @returns {Function} Returns the new function. */ function overRest(func, start, transform) { start = nativeMax(start === undefined$1 ? (func.length - 1) : start, 0); return function() { var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length); while (++index < length) { array[index] = args[start + index]; } index = -1; var otherArgs = Array(start + 1); while (++index < start) { otherArgs[index] = args[index]; } otherArgs[start] = transform(array); return apply(func, this, otherArgs); }; } /** * Gets the parent value at `path` of `object`. * * @private * @param {Object} object The object to query. * @param {Array} path The path to get the parent value of. * @returns {*} Returns the parent value. */ function parent(object, path) { return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); } /** * Reorder `array` according to the specified indexes where the element at * the first index is assigned as the first element, the element at * the second index is assigned as the second element, and so on. * * @private * @param {Array} array The array to reorder. * @param {Array} indexes The arranged array indexes. * @returns {Array} Returns `array`. */ function reorder(array, indexes) { var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array); while (length--) { var index = indexes[length]; array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1; } return array; } /** * Gets the value at `key`, unless `key` is "__proto__" or "constructor". * * @private * @param {Object} object The object to query. * @param {string} key The key of the property to get. * @returns {*} Returns the property value. */ function safeGet(object, key) { if (key === 'constructor' && typeof object[key] === 'function') { return; } if (key == '__proto__') { return; } return object[key]; } /** * Sets metadata for `func`. * * **Note:** If this function becomes hot, i.e. is invoked a lot in a short * period of time, it will trip its breaker and transition to an identity * function to avoid garbage collection pauses in V8. See * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) * for more details. * * @private * @param {Function} func The function to associate metadata with. * @param {*} data The metadata. * @returns {Function} Returns `func`. */ var setData = shortOut(baseSetData); /** * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). * * @private * @param {Function} func The function to delay. * @param {number} wait The number of milliseconds to delay invocation. * @returns {number|Object} Returns the timer id or timeout object. */ var setTimeout = ctxSetTimeout || function(func, wait) { return root.setTimeout(func, wait); }; /** * Sets the `toString` method of `func` to return `string`. * * @private * @param {Function} func The function to modify. * @param {Function} string The `toString` result. * @returns {Function} Returns `func`. */ var setToString = shortOut(baseSetToString); /** * Sets the `toString` method of `wrapper` to mimic the source of `reference` * with wrapper details in a comment at the top of the source body. * * @private * @param {Function} wrapper The function to modify. * @param {Function} reference The reference function. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @returns {Function} Returns `wrapper`. */ function setWrapToString(wrapper, reference, bitmask) { var source = (reference + ''); return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); } /** * Creates a function that'll short out and invoke `identity` instead * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` * milliseconds. * * @private * @param {Function} func The function to restrict. * @returns {Function} Returns the new shortable function. */ function shortOut(func) { var count = 0, lastCalled = 0; return function() { var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled); lastCalled = stamp; if (remaining > 0) { if (++count >= HOT_COUNT) { return arguments[0]; } } else { count = 0; } return func.apply(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 < size) { var rand = baseRandom(index, lastIndex), value = array[rand]; array[rand] = array[index]; array[index] = value; } array.length = size; return array; } /** * Converts `string` to a property path array. * * @private * @param {string} string The string to convert. * @returns {Array} Returns the property path array. */ var stringToPath = memoizeCapped(function(string) { var result = []; if (string.charCodeAt(0) === 46 /* . */) { result.push(''); } string.replace(rePropName, function(match, number, quote, subString) { result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); }); return result; }); /** * Converts `value` to a string key if it's not a string or symbol. * * @private * @param {*} value The value to inspect. * @returns {string|symbol} Returns the key. */ function toKey(value) { if (typeof value == 'string' || isSymbol(value)) { return value; } var result = (value + ''); return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; } /** * Converts `func` to its source code. * * @private * @param {Function} func The function to convert. * @returns {string} Returns the source code. */ function toSource(func) { if (func != null) { try { return funcToString.call(func); } catch (e) {} try { return (func + ''); } catch (e) {} } return ''; } /** * Updates wrapper `details` based on `bitmask` flags. * * @private * @returns {Array} details The details to modify. * @param {number} bitmask The bitmask flags. See `createWrap` for more details. * @returns {Array} Returns `details`. */ function updateWrapDetails(details, bitmask) { arrayEach(wrapFlags, function(pair) { var value = '_.' + pair[0]; if ((bitmask & pair[1]) && !arrayIncludes(details, value)) { details.push(value); } }); return details.sort(); } /** * Creates a clone of `wrapper`. * * @private * @param {Object} wrapper The wrapper to clone. * @returns {Object} Returns the cloned wrapper. */ function wrapperClone(wrapper) { if (wrapper instanceof LazyWrapper) { return wrapper.clone(); } var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); result.__actions__ = copyArray(wrapper.__actions__); result.__index__ = wrapper.__index__; result.__values__ = wrapper.__values__; return result; } /*------------------------------------------------------------------------*/ /** * Creates an array of elements split into groups the length of `size`. * If `array` can't be split evenly, the final chunk will be the remaining * elements. * * @static * @memberOf _ * @since 3.0.0 * @category Array * @param {Array} array The array to process. * @param {number} [size=1] The length of each chunk * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. * @returns {Array} Returns the new array of chunks. * @example * * _.chunk(['a', 'b', 'c', 'd'], 2); * // => [['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 < length) { result[resIndex++] = baseSlice(array, index, (index += size)); } return result; } /** * Creates an array with all falsey values removed. The values `false`, `null`, * `0`, `""`, `undefined`, and `NaN` are falsey. * * @static * @memberOf _ * @since 0.1.0 * @category Array * @param {Array} array The array to compact. * @returns {Array} Returns the new array of filtered values. * @example * * _.compact([0, 1, false, 2, '', 3]); * // => [1, 2, 3] */ function compact(array) { var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = []; while (++index < length) { var value = array[index]; if (value) { result[resIndex++] = value; } } return result; } /** * Creates a new array concatenating `array` with any additional arrays * and/or values. * * @static * @memberOf _ * @since 4.0.0 * @category Array * @param {Array} array The array to concatenate. * @param {...*} [values] The values to concatenate. * @returns {Array} Returns the new concatenated array. * @example * * var array = [1]; * var other = _.concat(array, 2, [3], [[4]]); * * console.log(other); * // => [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 < length) { var pair = pairs[index]; result[pair[0]] = pair[1]; } return result; } /** * Gets the first element of `array`. * * @static * @memberOf _ * @since 0.1.0 * @alias first * @category Array * @param {Array} array The array to query. * @returns {*} Returns the first element of `array`. * @example * * _.head([1, 2, 3]); * // => 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 < length) { var value = array[index]; if (predicate(value, index, array)) { result.push(value); indexes.push(index); } } basePullAt(array, indexes); return result; } /** * Reverses `array` so that the first element becomes the last, the second * element becomes the second to last, and so on. * * **Note:** This method mutates `array` and is based on * [`Array#reverse`](https://mdn.io/Array/reverse). * * @static * @memberOf _ * @since 4.0.0 * @category Array * @param {Array} array The array to modify. * @returns {Array} Returns `array`. * @example * * var array = [1, 2, 3]; * * _.reverse(array); * // => [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 < length && eq(array[index], value)) { return index; } } return -1; } /** * This method is like `_.sortedIndex` except that it returns the highest * index at which `value` should be inserted into `array` in order to * maintain its sort order. * * @static * @memberOf _ * @since 3.0.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 * * _.sortedLastIndex([4, 5, 5, 5, 6], 5); * // => 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 < length) { args[index] = transforms[index].call(this, args[index]); } return apply(func, this, args); }); }); /** * Creates a function that invokes `func` with `partials` prepended to the * arguments it receives. This method is like `_.bind` except it does **not** * alter the `this` binding. * * The `_.partial.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 0.2.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 sayHelloTo = _.partial(greet, 'hello'); * sayHelloTo('fred'); * // => '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 < length) { var source = sources[index]; var props = keysIn(source); var propsIndex = -1; var propsLength = props.length; while (++propsIndex < propsLength) { var key = props[propsIndex]; var value = object[key]; if (value === undefined$1 || (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { object[key] = source[key]; } } } return object; }); /** * This method is like `_.defaults` except that it recursively assigns * default properties. * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 3.10.0 * @category Object * @param {Object} object The destination object. * @param {...Object} [sources] The source objects. * @returns {Object} Returns `object`. * @see _.defaults * @example * * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); * // => { '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 < length) { var value = object == null ? undefined$1 : object[toKey(path[index])]; if (value === undefined$1) { index = length; value = defaultValue; } object = isFunction(value) ? value.call(object) : value; } return object; } /** * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, * it's created. Arrays are created for missing index properties while objects * are created for all other missing properties. Use `_.setWith` to customize * `path` creation. * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 3.7.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. * @returns {Object} Returns `object`. * @example * * var object = { 'a': [{ 'b': { 'c': 3 } }] }; * * _.set(object, 'a[0].b.c', 4); * console.log(object.a[0].b.c); * // => 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 < length) ? (string + createPadding(length - strLength, chars)) : string; } /** * Pads `string` on the left 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 * * _.padStart('abc', 6); * // => ' 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 < length) ? (createPadding(length - strLength, chars) + string) : string; } /** * Converts `string` to an integer of the specified radix. If `radix` is * `undefined` or `0`, a `radix` of `10` is used unless `value` is a * hexadecimal, in which case a `radix` of `16` is used. * * **Note:** This method aligns with the * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. * * @static * @memberOf _ * @since 1.1.0 * @category String * @param {string} string The string to convert. * @param {number} [radix=10] The radix to interpret `value` by. * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. * @returns {number} Returns the converted integer. * @example * * _.parseInt('08'); * // => 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': '

#Flatland