33413 lines
1.0 MiB
33413 lines
1.0 MiB
;(function(l, i, v, e) {
|
||
v = l.createElement(i)
|
||
v.async = 1
|
||
v.src =
|
||
"//" +
|
||
(location.host || "localhost").split(":")[0] +
|
||
":35729/livereload.js?snipver=1"
|
||
e = l.getElementsByTagName(i)[0]
|
||
e.parentNode.insertBefore(v, e)
|
||
})(document, "script")
|
||
var app = (function() {
|
||
"use strict"
|
||
|
||
function noop() {}
|
||
function assign(tar, src) {
|
||
// @ts-ignore
|
||
for (const k in src) tar[k] = src[k]
|
||
return tar
|
||
}
|
||
function is_promise(value) {
|
||
return (
|
||
value && typeof value === "object" && typeof value.then === "function"
|
||
)
|
||
}
|
||
function add_location(element, file, line, column, char) {
|
||
element.__svelte_meta = {
|
||
loc: { file, line, column, char },
|
||
}
|
||
}
|
||
function run(fn) {
|
||
return fn()
|
||
}
|
||
function blank_object() {
|
||
return Object.create(null)
|
||
}
|
||
function run_all(fns) {
|
||
fns.forEach(run)
|
||
}
|
||
function is_function(thing) {
|
||
return typeof thing === "function"
|
||
}
|
||
function safe_not_equal(a, b) {
|
||
return a != a
|
||
? b == b
|
||
: a !== b || (a && typeof a === "object") || typeof a === "function"
|
||
}
|
||
function create_slot(definition, ctx, fn) {
|
||
if (definition) {
|
||
const slot_ctx = get_slot_context(definition, ctx, fn)
|
||
return definition[0](slot_ctx)
|
||
}
|
||
}
|
||
function get_slot_context(definition, ctx, fn) {
|
||
return definition[1]
|
||
? assign({}, assign(ctx.$$scope.ctx, definition[1](fn ? fn(ctx) : {})))
|
||
: ctx.$$scope.ctx
|
||
}
|
||
function get_slot_changes(definition, ctx, changed, fn) {
|
||
return definition[1]
|
||
? assign(
|
||
{},
|
||
assign(
|
||
ctx.$$scope.changed || {},
|
||
definition[1](fn ? fn(changed) : {})
|
||
)
|
||
)
|
||
: ctx.$$scope.changed || {}
|
||
}
|
||
function null_to_empty(value) {
|
||
return value == null ? "" : value
|
||
}
|
||
|
||
function append(target, node) {
|
||
target.appendChild(node)
|
||
}
|
||
function insert(target, node, anchor) {
|
||
target.insertBefore(node, anchor || null)
|
||
}
|
||
function detach(node) {
|
||
node.parentNode.removeChild(node)
|
||
}
|
||
function destroy_each(iterations, detaching) {
|
||
for (let i = 0; i < iterations.length; i += 1) {
|
||
if (iterations[i]) iterations[i].d(detaching)
|
||
}
|
||
}
|
||
function element(name) {
|
||
return document.createElement(name)
|
||
}
|
||
function svg_element(name) {
|
||
return document.createElementNS("http://www.w3.org/2000/svg", name)
|
||
}
|
||
function text(data) {
|
||
return document.createTextNode(data)
|
||
}
|
||
function space() {
|
||
return text(" ")
|
||
}
|
||
function empty() {
|
||
return text("")
|
||
}
|
||
function listen(node, event, handler, options) {
|
||
node.addEventListener(event, handler, options)
|
||
return () => node.removeEventListener(event, handler, options)
|
||
}
|
||
function attr(node, attribute, value) {
|
||
if (value == null) node.removeAttribute(attribute)
|
||
else node.setAttribute(attribute, value)
|
||
}
|
||
function children(element) {
|
||
return Array.from(element.childNodes)
|
||
}
|
||
function claim_element(nodes, name, attributes, svg) {
|
||
for (let i = 0; i < nodes.length; i += 1) {
|
||
const node = nodes[i]
|
||
if (node.nodeName === name) {
|
||
for (let j = 0; j < node.attributes.length; j += 1) {
|
||
const attribute = node.attributes[j]
|
||
if (!attributes[attribute.name]) node.removeAttribute(attribute.name)
|
||
}
|
||
return nodes.splice(i, 1)[0] // TODO strip unwanted attributes
|
||
}
|
||
}
|
||
return svg ? svg_element(name) : element(name)
|
||
}
|
||
function claim_text(nodes, data) {
|
||
for (let i = 0; i < nodes.length; i += 1) {
|
||
const node = nodes[i]
|
||
if (node.nodeType === 3) {
|
||
node.data = "" + data
|
||
return nodes.splice(i, 1)[0]
|
||
}
|
||
}
|
||
return text(data)
|
||
}
|
||
function claim_space(nodes) {
|
||
return claim_text(nodes, " ")
|
||
}
|
||
function set_input_value(input, value) {
|
||
if (value != null || input.value) {
|
||
input.value = value
|
||
}
|
||
}
|
||
function set_style(node, key, value, important) {
|
||
node.style.setProperty(key, value, important ? "important" : "")
|
||
}
|
||
function toggle_class(element, name, toggle) {
|
||
element.classList[toggle ? "add" : "remove"](name)
|
||
}
|
||
function custom_event(type, detail) {
|
||
const e = document.createEvent("CustomEvent")
|
||
e.initCustomEvent(type, false, false, detail)
|
||
return e
|
||
}
|
||
|
||
let current_component
|
||
function set_current_component(component) {
|
||
current_component = component
|
||
}
|
||
function get_current_component() {
|
||
if (!current_component)
|
||
throw new Error(`Function called outside component initialization`)
|
||
return current_component
|
||
}
|
||
// TODO figure out if we still want to support
|
||
// shorthand events, or if we want to implement
|
||
// a real bubbling mechanism
|
||
function bubble(component, event) {
|
||
const callbacks = component.$$.callbacks[event.type]
|
||
if (callbacks) {
|
||
callbacks.slice().forEach(fn => fn(event))
|
||
}
|
||
}
|
||
|
||
const dirty_components = []
|
||
const binding_callbacks = []
|
||
const render_callbacks = []
|
||
const flush_callbacks = []
|
||
const resolved_promise = Promise.resolve()
|
||
let update_scheduled = false
|
||
function schedule_update() {
|
||
if (!update_scheduled) {
|
||
update_scheduled = true
|
||
resolved_promise.then(flush)
|
||
}
|
||
}
|
||
function add_render_callback(fn) {
|
||
render_callbacks.push(fn)
|
||
}
|
||
function flush() {
|
||
const seen_callbacks = new Set()
|
||
do {
|
||
// first, call beforeUpdate functions
|
||
// and update components
|
||
while (dirty_components.length) {
|
||
const component = dirty_components.shift()
|
||
set_current_component(component)
|
||
update(component.$$)
|
||
}
|
||
while (binding_callbacks.length) binding_callbacks.pop()()
|
||
// then, once components are updated, call
|
||
// afterUpdate functions. This may cause
|
||
// subsequent updates...
|
||
for (let i = 0; i < render_callbacks.length; i += 1) {
|
||
const callback = render_callbacks[i]
|
||
if (!seen_callbacks.has(callback)) {
|
||
callback()
|
||
// ...so guard against infinite loops
|
||
seen_callbacks.add(callback)
|
||
}
|
||
}
|
||
render_callbacks.length = 0
|
||
} while (dirty_components.length)
|
||
while (flush_callbacks.length) {
|
||
flush_callbacks.pop()()
|
||
}
|
||
update_scheduled = false
|
||
}
|
||
function update($$) {
|
||
if ($$.fragment) {
|
||
$$.update($$.dirty)
|
||
run_all($$.before_update)
|
||
$$.fragment.p($$.dirty, $$.ctx)
|
||
$$.dirty = null
|
||
$$.after_update.forEach(add_render_callback)
|
||
}
|
||
}
|
||
const outroing = new Set()
|
||
let outros
|
||
function group_outros() {
|
||
outros = {
|
||
r: 0,
|
||
c: [],
|
||
p: outros, // parent group
|
||
}
|
||
}
|
||
function check_outros() {
|
||
if (!outros.r) {
|
||
run_all(outros.c)
|
||
}
|
||
outros = outros.p
|
||
}
|
||
function transition_in(block, local) {
|
||
if (block && block.i) {
|
||
outroing.delete(block)
|
||
block.i(local)
|
||
}
|
||
}
|
||
function transition_out(block, local, detach, callback) {
|
||
if (block && block.o) {
|
||
if (outroing.has(block)) return
|
||
outroing.add(block)
|
||
outros.c.push(() => {
|
||
outroing.delete(block)
|
||
if (callback) {
|
||
if (detach) block.d(1)
|
||
callback()
|
||
}
|
||
})
|
||
block.o(local)
|
||
}
|
||
}
|
||
|
||
function handle_promise(promise, info) {
|
||
const token = (info.token = {})
|
||
function update(type, index, key, value) {
|
||
if (info.token !== token) return
|
||
info.resolved = key && { [key]: value }
|
||
const child_ctx = assign(assign({}, info.ctx), info.resolved)
|
||
const block = type && (info.current = type)(child_ctx)
|
||
if (info.block) {
|
||
if (info.blocks) {
|
||
info.blocks.forEach((block, i) => {
|
||
if (i !== index && block) {
|
||
group_outros()
|
||
transition_out(block, 1, 1, () => {
|
||
info.blocks[i] = null
|
||
})
|
||
check_outros()
|
||
}
|
||
})
|
||
} else {
|
||
info.block.d(1)
|
||
}
|
||
block.c()
|
||
transition_in(block, 1)
|
||
block.m(info.mount(), info.anchor)
|
||
flush()
|
||
}
|
||
info.block = block
|
||
if (info.blocks) info.blocks[index] = block
|
||
}
|
||
if (is_promise(promise)) {
|
||
const current_component = get_current_component()
|
||
promise.then(
|
||
value => {
|
||
set_current_component(current_component)
|
||
update(info.then, 1, info.value, value)
|
||
set_current_component(null)
|
||
},
|
||
error => {
|
||
set_current_component(current_component)
|
||
update(info.catch, 2, info.error, error)
|
||
set_current_component(null)
|
||
}
|
||
)
|
||
// if we previously had a then/catch block, destroy it
|
||
if (info.current !== info.pending) {
|
||
update(info.pending, 0)
|
||
return true
|
||
}
|
||
} else {
|
||
if (info.current !== info.then) {
|
||
update(info.then, 1, info.value, promise)
|
||
return true
|
||
}
|
||
info.resolved = { [info.value]: promise }
|
||
}
|
||
}
|
||
|
||
const globals = typeof window !== "undefined" ? window : global
|
||
function mount_component(component, target, anchor) {
|
||
const { fragment, on_mount, on_destroy, after_update } = component.$$
|
||
fragment.m(target, anchor)
|
||
// onMount happens before the initial afterUpdate
|
||
add_render_callback(() => {
|
||
const new_on_destroy = on_mount.map(run).filter(is_function)
|
||
if (on_destroy) {
|
||
on_destroy.push(...new_on_destroy)
|
||
} else {
|
||
// Edge case - component was destroyed immediately,
|
||
// most likely as a result of a binding initialising
|
||
run_all(new_on_destroy)
|
||
}
|
||
component.$$.on_mount = []
|
||
})
|
||
after_update.forEach(add_render_callback)
|
||
}
|
||
function destroy_component(component, detaching) {
|
||
if (component.$$.fragment) {
|
||
run_all(component.$$.on_destroy)
|
||
component.$$.fragment.d(detaching)
|
||
// TODO null out other refs, including component.$$ (but need to
|
||
// preserve final state?)
|
||
component.$$.on_destroy = component.$$.fragment = null
|
||
component.$$.ctx = {}
|
||
}
|
||
}
|
||
function make_dirty(component, key) {
|
||
if (!component.$$.dirty) {
|
||
dirty_components.push(component)
|
||
schedule_update()
|
||
component.$$.dirty = blank_object()
|
||
}
|
||
component.$$.dirty[key] = true
|
||
}
|
||
function init(
|
||
component,
|
||
options,
|
||
instance,
|
||
create_fragment,
|
||
not_equal,
|
||
prop_names
|
||
) {
|
||
const parent_component = current_component
|
||
set_current_component(component)
|
||
const props = options.props || {}
|
||
const $$ = (component.$$ = {
|
||
fragment: null,
|
||
ctx: null,
|
||
// state
|
||
props: prop_names,
|
||
update: noop,
|
||
not_equal,
|
||
bound: blank_object(),
|
||
// lifecycle
|
||
on_mount: [],
|
||
on_destroy: [],
|
||
before_update: [],
|
||
after_update: [],
|
||
context: new Map(parent_component ? parent_component.$$.context : []),
|
||
// everything else
|
||
callbacks: blank_object(),
|
||
dirty: null,
|
||
})
|
||
let ready = false
|
||
$$.ctx = instance
|
||
? instance(component, props, (key, ret, value = ret) => {
|
||
if ($$.ctx && not_equal($$.ctx[key], ($$.ctx[key] = value))) {
|
||
if ($$.bound[key]) $$.bound[key](value)
|
||
if (ready) make_dirty(component, key)
|
||
}
|
||
return ret
|
||
})
|
||
: props
|
||
$$.update()
|
||
ready = true
|
||
run_all($$.before_update)
|
||
$$.fragment = create_fragment($$.ctx)
|
||
if (options.target) {
|
||
if (options.hydrate) {
|
||
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
||
$$.fragment.l(children(options.target))
|
||
} else {
|
||
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
||
$$.fragment.c()
|
||
}
|
||
if (options.intro) transition_in(component.$$.fragment)
|
||
mount_component(component, options.target, options.anchor)
|
||
flush()
|
||
}
|
||
set_current_component(parent_component)
|
||
}
|
||
let SvelteElement
|
||
if (typeof HTMLElement !== "undefined") {
|
||
SvelteElement = class extends HTMLElement {
|
||
constructor() {
|
||
super()
|
||
this.attachShadow({ mode: "open" })
|
||
}
|
||
connectedCallback() {
|
||
// @ts-ignore todo: improve typings
|
||
for (const key in this.$$.slotted) {
|
||
// @ts-ignore todo: improve typings
|
||
this.appendChild(this.$$.slotted[key])
|
||
}
|
||
}
|
||
attributeChangedCallback(attr, _oldValue, newValue) {
|
||
this[attr] = newValue
|
||
}
|
||
$destroy() {
|
||
destroy_component(this, 1)
|
||
this.$destroy = noop
|
||
}
|
||
$on(type, callback) {
|
||
// TODO should this delegate to addEventListener?
|
||
const callbacks =
|
||
this.$$.callbacks[type] || (this.$$.callbacks[type] = [])
|
||
callbacks.push(callback)
|
||
return () => {
|
||
const index = callbacks.indexOf(callback)
|
||
if (index !== -1) callbacks.splice(index, 1)
|
||
}
|
||
}
|
||
$set() {
|
||
// overridden by instance, if it has props
|
||
}
|
||
}
|
||
}
|
||
class SvelteComponent {
|
||
$destroy() {
|
||
destroy_component(this, 1)
|
||
this.$destroy = noop
|
||
}
|
||
$on(type, callback) {
|
||
const callbacks =
|
||
this.$$.callbacks[type] || (this.$$.callbacks[type] = [])
|
||
callbacks.push(callback)
|
||
return () => {
|
||
const index = callbacks.indexOf(callback)
|
||
if (index !== -1) callbacks.splice(index, 1)
|
||
}
|
||
}
|
||
$set() {
|
||
// overridden by instance, if it has props
|
||
}
|
||
}
|
||
|
||
function dispatch_dev(type, detail) {
|
||
document.dispatchEvent(custom_event(type, detail))
|
||
}
|
||
function append_dev(target, node) {
|
||
dispatch_dev("SvelteDOMInsert", { target, node })
|
||
append(target, node)
|
||
}
|
||
function insert_dev(target, node, anchor) {
|
||
dispatch_dev("SvelteDOMInsert", { target, node, anchor })
|
||
insert(target, node, anchor)
|
||
}
|
||
function detach_dev(node) {
|
||
dispatch_dev("SvelteDOMRemove", { node })
|
||
detach(node)
|
||
}
|
||
function listen_dev(
|
||
node,
|
||
event,
|
||
handler,
|
||
options,
|
||
has_prevent_default,
|
||
has_stop_propagation
|
||
) {
|
||
const modifiers =
|
||
options === true
|
||
? ["capture"]
|
||
: options
|
||
? Array.from(Object.keys(options))
|
||
: []
|
||
if (has_prevent_default) modifiers.push("preventDefault")
|
||
if (has_stop_propagation) modifiers.push("stopPropagation")
|
||
dispatch_dev("SvelteDOMAddEventListener", {
|
||
node,
|
||
event,
|
||
handler,
|
||
modifiers,
|
||
})
|
||
const dispose = listen(node, event, handler, options)
|
||
return () => {
|
||
dispatch_dev("SvelteDOMRemoveEventListener", {
|
||
node,
|
||
event,
|
||
handler,
|
||
modifiers,
|
||
})
|
||
dispose()
|
||
}
|
||
}
|
||
function attr_dev(node, attribute, value) {
|
||
attr(node, attribute, value)
|
||
if (value == null)
|
||
dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute })
|
||
else dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value })
|
||
}
|
||
function prop_dev(node, property, value) {
|
||
node[property] = value
|
||
dispatch_dev("SvelteDOMSetProperty", { node, property, value })
|
||
}
|
||
function set_data_dev(text, data) {
|
||
data = "" + data
|
||
if (text.data === data) return
|
||
dispatch_dev("SvelteDOMSetData", { node: text, data })
|
||
text.data = data
|
||
}
|
||
class SvelteComponentDev extends SvelteComponent {
|
||
constructor(options) {
|
||
if (!options || (!options.target && !options.$$inline)) {
|
||
throw new Error(`'target' is a required option`)
|
||
}
|
||
super()
|
||
}
|
||
$destroy() {
|
||
super.$destroy()
|
||
this.$destroy = () => {
|
||
console.warn(`Component was already destroyed`) // eslint-disable-line no-console
|
||
}
|
||
}
|
||
}
|
||
|
||
const subscriber_queue = []
|
||
/**
|
||
* Create a `Writable` store that allows both updating and reading by subscription.
|
||
* @param {*=}value initial value
|
||
* @param {StartStopNotifier=}start start and stop notifications for subscriptions
|
||
*/
|
||
function writable(value, start = noop) {
|
||
let stop
|
||
const subscribers = []
|
||
function set(new_value) {
|
||
if (safe_not_equal(value, new_value)) {
|
||
value = new_value
|
||
if (stop) {
|
||
// store is ready
|
||
const run_queue = !subscriber_queue.length
|
||
for (let i = 0; i < subscribers.length; i += 1) {
|
||
const s = subscribers[i]
|
||
s[1]()
|
||
subscriber_queue.push(s, value)
|
||
}
|
||
if (run_queue) {
|
||
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
||
subscriber_queue[i][0](subscriber_queue[i + 1])
|
||
}
|
||
subscriber_queue.length = 0
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function update(fn) {
|
||
set(fn(value))
|
||
}
|
||
function subscribe(run, invalidate = noop) {
|
||
const subscriber = [run, invalidate]
|
||
subscribers.push(subscriber)
|
||
if (subscribers.length === 1) {
|
||
stop = start(set) || noop
|
||
}
|
||
run(value)
|
||
return () => {
|
||
const index = subscribers.indexOf(subscriber)
|
||
if (index !== -1) {
|
||
subscribers.splice(index, 1)
|
||
}
|
||
if (subscribers.length === 0) {
|
||
stop()
|
||
stop = null
|
||
}
|
||
}
|
||
}
|
||
return { set, update, subscribe }
|
||
}
|
||
|
||
/* src\Textbox.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file = "src\\Textbox.svelte"
|
||
|
||
// (32:0) {:else}
|
||
function create_else_block(ctx) {
|
||
var input, input_class_value
|
||
|
||
const block = {
|
||
c: function create() {
|
||
input = element("input")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
input = claim_element(
|
||
nodes,
|
||
"INPUT",
|
||
{ class: true, type: true, value: true },
|
||
false
|
||
)
|
||
var input_nodes = children(input)
|
||
|
||
input_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
input,
|
||
"class",
|
||
(input_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1ec4wqj")
|
||
)
|
||
attr_dev(input, "type", "text")
|
||
input.value = ctx.actualValue
|
||
add_location(input, file, 32, 0, 546)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, input, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
changed.className &&
|
||
input_class_value !==
|
||
(input_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1ec4wqj")
|
||
) {
|
||
attr_dev(input, "class", input_class_value)
|
||
}
|
||
|
||
if (changed.actualValue) {
|
||
prop_dev(input, "value", ctx.actualValue)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(input)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_else_block.name,
|
||
type: "else",
|
||
source: "(32:0) {:else}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (28:0) {#if hideValue}
|
||
function create_if_block(ctx) {
|
||
var input, input_class_value, dispose
|
||
|
||
const block = {
|
||
c: function create() {
|
||
input = element("input")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
input = claim_element(
|
||
nodes,
|
||
"INPUT",
|
||
{ class: true, type: true, value: true },
|
||
false
|
||
)
|
||
var input_nodes = children(input)
|
||
|
||
input_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
input,
|
||
"class",
|
||
(input_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1ec4wqj")
|
||
)
|
||
attr_dev(input, "type", "password")
|
||
input.value = ctx.actualValue
|
||
add_location(input, file, 28, 0, 455)
|
||
dispose = listen_dev(input, "change", ctx.change_handler)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, input, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
changed.className &&
|
||
input_class_value !==
|
||
(input_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1ec4wqj")
|
||
) {
|
||
attr_dev(input, "class", input_class_value)
|
||
}
|
||
|
||
if (changed.actualValue) {
|
||
prop_dev(input, "value", ctx.actualValue)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(input)
|
||
}
|
||
|
||
dispose()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block.name,
|
||
type: "if",
|
||
source: "(28:0) {#if hideValue}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment(ctx) {
|
||
var if_block_anchor
|
||
|
||
function select_block_type(changed, ctx) {
|
||
if (ctx.hideValue) return create_if_block
|
||
return create_else_block
|
||
}
|
||
|
||
var current_block_type = select_block_type(null, ctx)
|
||
var if_block = current_block_type(ctx)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
if_block.c()
|
||
if_block_anchor = empty()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
if_block.l(nodes)
|
||
if_block_anchor = empty()
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
if_block.m(target, anchor)
|
||
insert_dev(target, if_block_anchor, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
current_block_type ===
|
||
(current_block_type = select_block_type(changed, ctx)) &&
|
||
if_block
|
||
) {
|
||
if_block.p(changed, ctx)
|
||
} else {
|
||
if_block.d(1)
|
||
if_block = current_block_type(ctx)
|
||
if (if_block) {
|
||
if_block.c()
|
||
if_block.m(if_block_anchor.parentNode, if_block_anchor)
|
||
}
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if_block.d(detaching)
|
||
|
||
if (detaching) {
|
||
detach_dev(if_block_anchor)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance($$self, $$props, $$invalidate) {
|
||
let { value = "", hideValue = false, className = "default", _bb } = $$props
|
||
|
||
let actualValue = ""
|
||
|
||
const writable_props = ["value", "hideValue", "className", "_bb"]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Textbox> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function change_handler(event) {
|
||
bubble($$self, event)
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("value" in $$props) $$invalidate("value", (value = $$props.value))
|
||
if ("hideValue" in $$props)
|
||
$$invalidate("hideValue", (hideValue = $$props.hideValue))
|
||
if ("className" in $$props)
|
||
$$invalidate("className", (className = $$props.className))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return { value, hideValue, className, _bb, actualValue }
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("value" in $$props) $$invalidate("value", (value = $$props.value))
|
||
if ("hideValue" in $$props)
|
||
$$invalidate("hideValue", (hideValue = $$props.hideValue))
|
||
if ("className" in $$props)
|
||
$$invalidate("className", (className = $$props.className))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("actualValue" in $$props)
|
||
$$invalidate("actualValue", (actualValue = $$props.actualValue))
|
||
}
|
||
|
||
$$self.$$.update = ($$dirty = { _bb: 1, value: 1 }) => {
|
||
if ($$dirty._bb || $$dirty.value) {
|
||
{
|
||
if (_bb && value._isstate) {
|
||
_bb.store.subscribe(s => {
|
||
$$invalidate(
|
||
"actualValue",
|
||
(actualValue = _bb.store.getValue(s, value))
|
||
)
|
||
})
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
value,
|
||
hideValue,
|
||
className,
|
||
_bb,
|
||
actualValue,
|
||
change_handler,
|
||
}
|
||
}
|
||
|
||
class Textbox extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance, create_fragment, safe_not_equal, [
|
||
"value",
|
||
"hideValue",
|
||
"className",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Textbox",
|
||
options,
|
||
id: create_fragment.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Textbox> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get value() {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set value(value) {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get hideValue() {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set hideValue(value) {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get className() {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set className(value) {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Form.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$1 = "src\\Form.svelte"
|
||
|
||
function get_each_context(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx)
|
||
child_ctx.child = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
// (30:4) {#each formControls as child, index}
|
||
function create_each_block(ctx) {
|
||
var div0,
|
||
t0_value = ctx.labels[ctx.index] + "",
|
||
t0,
|
||
t1,
|
||
div1,
|
||
index = ctx.index
|
||
|
||
const assign_div1 = () => ctx.div1_binding(div1, index)
|
||
const unassign_div1 = () => ctx.div1_binding(null, index)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div0 = element("div")
|
||
t0 = text(t0_value)
|
||
t1 = space()
|
||
div1 = element("div")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div0 = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div0_nodes = children(div0)
|
||
|
||
t0 = claim_text(div0_nodes, t0_value)
|
||
div0_nodes.forEach(detach_dev)
|
||
t1 = claim_space(nodes)
|
||
|
||
div1 = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div1_nodes = children(div1)
|
||
|
||
div1_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div0, "class", "label svelte-m9d6ue")
|
||
add_location(div0, file$1, 30, 4, 559)
|
||
attr_dev(div1, "class", "control svelte-m9d6ue")
|
||
add_location(div1, file$1, 31, 4, 604)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div0, anchor)
|
||
append_dev(div0, t0)
|
||
insert_dev(target, t1, anchor)
|
||
insert_dev(target, div1, anchor)
|
||
assign_div1()
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (
|
||
changed.labels &&
|
||
t0_value !== (t0_value = ctx.labels[ctx.index] + "")
|
||
) {
|
||
set_data_dev(t0, t0_value)
|
||
}
|
||
|
||
if (index !== ctx.index) {
|
||
unassign_div1()
|
||
index = ctx.index
|
||
assign_div1()
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div0)
|
||
detach_dev(t1)
|
||
detach_dev(div1)
|
||
}
|
||
|
||
unassign_div1()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block.name,
|
||
type: "each",
|
||
source: "(30:4) {#each formControls as child, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$1(ctx) {
|
||
var div, div_class_value
|
||
|
||
let each_value = ctx.formControls
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i))
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(div_nodes)
|
||
}
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div,
|
||
"class",
|
||
(div_class_value =
|
||
"form-root " + ctx.containerClass + " svelte-m9d6ue")
|
||
)
|
||
add_location(div, file$1, 28, 0, 473)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.htmlElements || changed.labels || changed.formControls) {
|
||
each_value = ctx.formControls
|
||
|
||
let i
|
||
for (i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context(ctx, each_value, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value.length
|
||
}
|
||
|
||
if (
|
||
changed.containerClass &&
|
||
div_class_value !==
|
||
(div_class_value =
|
||
"form-root " + ctx.containerClass + " svelte-m9d6ue")
|
||
) {
|
||
attr_dev(div, "class", div_class_value)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$1.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$1($$self, $$props, $$invalidate) {
|
||
let { containerClass = "", formControls = [], _bb } = $$props
|
||
|
||
let htmlElements = {}
|
||
let labels = {}
|
||
|
||
const writable_props = ["containerClass", "formControls", "_bb"]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Form> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function div1_binding($$value, index) {
|
||
if (htmlElements[index] === $$value) return
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
htmlElements[index] = $$value
|
||
$$invalidate("htmlElements", htmlElements)
|
||
})
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("formControls" in $$props)
|
||
$$invalidate("formControls", (formControls = $$props.formControls))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return { containerClass, formControls, _bb, htmlElements, labels }
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("formControls" in $$props)
|
||
$$invalidate("formControls", (formControls = $$props.formControls))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("htmlElements" in $$props)
|
||
$$invalidate("htmlElements", (htmlElements = $$props.htmlElements))
|
||
if ("labels" in $$props) $$invalidate("labels", (labels = $$props.labels))
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = { formControls: 1, _bb: 1, htmlElements: 1 }
|
||
) => {
|
||
if ($$dirty.formControls || $$dirty._bb || $$dirty.htmlElements) {
|
||
{
|
||
let cIndex = 0
|
||
for (let c of formControls) {
|
||
$$invalidate("labels", (labels[cIndex] = c.label), labels)
|
||
cIndex++
|
||
}
|
||
|
||
if (_bb && htmlElements) {
|
||
for (let el in htmlElements) {
|
||
_bb.initialiseComponent(
|
||
formControls[el].control,
|
||
htmlElements[el]
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
containerClass,
|
||
formControls,
|
||
_bb,
|
||
htmlElements,
|
||
labels,
|
||
div1_binding,
|
||
}
|
||
}
|
||
|
||
class Form extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$1, create_fragment$1, safe_not_equal, [
|
||
"containerClass",
|
||
"formControls",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Form",
|
||
options,
|
||
id: create_fragment$1.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Form> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get containerClass() {
|
||
throw new Error(
|
||
"<Form>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set containerClass(value) {
|
||
throw new Error(
|
||
"<Form>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get formControls() {
|
||
throw new Error(
|
||
"<Form>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set formControls(value) {
|
||
throw new Error(
|
||
"<Form>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Form>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Form>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Button.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$2 = "src\\Button.svelte"
|
||
|
||
// (30:4) {:else}
|
||
function create_else_block$1(ctx) {
|
||
var current
|
||
|
||
const default_slot_template = ctx.$$slots.default
|
||
const default_slot = create_slot(default_slot_template, ctx, null)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
if (default_slot) default_slot.c()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
if (default_slot) default_slot.l(nodes)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
if (default_slot) {
|
||
default_slot.m(target, anchor)
|
||
}
|
||
|
||
current = true
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (default_slot && default_slot.p && changed.$$scope) {
|
||
default_slot.p(
|
||
get_slot_changes(default_slot_template, ctx, changed, null),
|
||
get_slot_context(default_slot_template, ctx, null)
|
||
)
|
||
}
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return
|
||
transition_in(default_slot, local)
|
||
current = true
|
||
},
|
||
|
||
o: function outro(local) {
|
||
transition_out(default_slot, local)
|
||
current = false
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (default_slot) default_slot.d(detaching)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_else_block$1.name,
|
||
type: "else",
|
||
source: "(30:4) {:else}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (28:26)
|
||
function create_if_block_1(ctx) {
|
||
var t
|
||
|
||
const block = {
|
||
c: function create() {
|
||
t = text(ctx.contentText)
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
t = claim_text(nodes, ctx.contentText)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, t, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.contentText) {
|
||
set_data_dev(t, ctx.contentText)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(t)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_1.name,
|
||
type: "if",
|
||
source: "(28:26) ",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (25:4) {#if contentComponent && contentComponent._component}
|
||
function create_if_block$1(ctx) {
|
||
var div
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", {}, false)
|
||
var div_nodes = children(div)
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
add_location(div, file$2, 25, 1, 543)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
ctx.div_binding(div)
|
||
},
|
||
|
||
p: noop,
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
ctx.div_binding(null)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block$1.name,
|
||
type: "if",
|
||
source: "(25:4) {#if contentComponent && contentComponent._component}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$2(ctx) {
|
||
var button,
|
||
current_block_type_index,
|
||
if_block,
|
||
button_class_value,
|
||
current,
|
||
dispose
|
||
|
||
var if_block_creators = [
|
||
create_if_block$1,
|
||
create_if_block_1,
|
||
create_else_block$1,
|
||
]
|
||
|
||
var if_blocks = []
|
||
|
||
function select_block_type(changed, ctx) {
|
||
if (ctx.contentComponent && ctx.contentComponent._component) return 0
|
||
if (ctx.contentText) return 1
|
||
return 2
|
||
}
|
||
|
||
current_block_type_index = select_block_type(null, ctx)
|
||
if_block = if_blocks[current_block_type_index] = if_block_creators[
|
||
current_block_type_index
|
||
](ctx)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
button = element("button")
|
||
if_block.c()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
button = claim_element(
|
||
nodes,
|
||
"BUTTON",
|
||
{ class: true, disabled: true },
|
||
false
|
||
)
|
||
var button_nodes = children(button)
|
||
|
||
if_block.l(button_nodes)
|
||
button_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
button,
|
||
"class",
|
||
(button_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1q8lga0")
|
||
)
|
||
button.disabled = ctx.disabled
|
||
add_location(button, file$2, 23, 0, 422)
|
||
dispose = listen_dev(button, "click", ctx.clickHandler)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, button, anchor)
|
||
if_blocks[current_block_type_index].m(button, null)
|
||
current = true
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var previous_block_index = current_block_type_index
|
||
current_block_type_index = select_block_type(changed, ctx)
|
||
if (current_block_type_index === previous_block_index) {
|
||
if_blocks[current_block_type_index].p(changed, ctx)
|
||
} else {
|
||
group_outros()
|
||
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
||
if_blocks[previous_block_index] = null
|
||
})
|
||
check_outros()
|
||
|
||
if_block = if_blocks[current_block_type_index]
|
||
if (!if_block) {
|
||
if_block = if_blocks[current_block_type_index] = if_block_creators[
|
||
current_block_type_index
|
||
](ctx)
|
||
if_block.c()
|
||
}
|
||
transition_in(if_block, 1)
|
||
if_block.m(button, null)
|
||
}
|
||
|
||
if (
|
||
(!current || changed.className) &&
|
||
button_class_value !==
|
||
(button_class_value =
|
||
"" + null_to_empty(ctx.className) + " svelte-1q8lga0")
|
||
) {
|
||
attr_dev(button, "class", button_class_value)
|
||
}
|
||
|
||
if (!current || changed.disabled) {
|
||
prop_dev(button, "disabled", ctx.disabled)
|
||
}
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return
|
||
transition_in(if_block)
|
||
current = true
|
||
},
|
||
|
||
o: function outro(local) {
|
||
transition_out(if_block)
|
||
current = false
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(button)
|
||
}
|
||
|
||
if_blocks[current_block_type_index].d()
|
||
dispose()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$2.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$2($$self, $$props, $$invalidate) {
|
||
let {
|
||
className = "default",
|
||
disabled = false,
|
||
contentText,
|
||
contentComponent,
|
||
onClick = () => {},
|
||
} = $$props
|
||
|
||
let { _bb } = $$props
|
||
let contentComponentContainer
|
||
|
||
const clickHandler = () => {
|
||
if (onClick) onClick()
|
||
}
|
||
|
||
const writable_props = [
|
||
"className",
|
||
"disabled",
|
||
"contentText",
|
||
"contentComponent",
|
||
"onClick",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Button> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
let { $$slots = {}, $$scope } = $$props
|
||
|
||
function div_binding($$value) {
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
$$invalidate(
|
||
"contentComponentContainer",
|
||
(contentComponentContainer = $$value)
|
||
)
|
||
})
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("className" in $$props)
|
||
$$invalidate("className", (className = $$props.className))
|
||
if ("disabled" in $$props)
|
||
$$invalidate("disabled", (disabled = $$props.disabled))
|
||
if ("contentText" in $$props)
|
||
$$invalidate("contentText", (contentText = $$props.contentText))
|
||
if ("contentComponent" in $$props)
|
||
$$invalidate(
|
||
"contentComponent",
|
||
(contentComponent = $$props.contentComponent)
|
||
)
|
||
if ("onClick" in $$props)
|
||
$$invalidate("onClick", (onClick = $$props.onClick))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("$$scope" in $$props)
|
||
$$invalidate("$$scope", ($$scope = $$props.$$scope))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
className,
|
||
disabled,
|
||
contentText,
|
||
contentComponent,
|
||
onClick,
|
||
_bb,
|
||
contentComponentContainer,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("className" in $$props)
|
||
$$invalidate("className", (className = $$props.className))
|
||
if ("disabled" in $$props)
|
||
$$invalidate("disabled", (disabled = $$props.disabled))
|
||
if ("contentText" in $$props)
|
||
$$invalidate("contentText", (contentText = $$props.contentText))
|
||
if ("contentComponent" in $$props)
|
||
$$invalidate(
|
||
"contentComponent",
|
||
(contentComponent = $$props.contentComponent)
|
||
)
|
||
if ("onClick" in $$props)
|
||
$$invalidate("onClick", (onClick = $$props.onClick))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("contentComponentContainer" in $$props)
|
||
$$invalidate(
|
||
"contentComponentContainer",
|
||
(contentComponentContainer = $$props.contentComponentContainer)
|
||
)
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = { _bb: 1, contentComponentContainer: 1, contentComponent: 1 }
|
||
) => {
|
||
if (
|
||
$$dirty._bb ||
|
||
$$dirty.contentComponentContainer ||
|
||
$$dirty.contentComponent
|
||
) {
|
||
{
|
||
if (_bb && contentComponentContainer && contentComponent._component)
|
||
_bb.initialiseComponent(contentComponent, contentComponentContainer)
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
className,
|
||
disabled,
|
||
contentText,
|
||
contentComponent,
|
||
onClick,
|
||
_bb,
|
||
contentComponentContainer,
|
||
clickHandler,
|
||
div_binding,
|
||
$$slots,
|
||
$$scope,
|
||
}
|
||
}
|
||
|
||
class Button extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$2, create_fragment$2, safe_not_equal, [
|
||
"className",
|
||
"disabled",
|
||
"contentText",
|
||
"contentComponent",
|
||
"onClick",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Button",
|
||
options,
|
||
id: create_fragment$2.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx.contentText === undefined && !("contentText" in props)) {
|
||
console.warn("<Button> was created without expected prop 'contentText'")
|
||
}
|
||
if (
|
||
ctx.contentComponent === undefined &&
|
||
!("contentComponent" in props)
|
||
) {
|
||
console.warn(
|
||
"<Button> was created without expected prop 'contentComponent'"
|
||
)
|
||
}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Button> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get className() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set className(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get disabled() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set disabled(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get contentText() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set contentText(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get contentComponent() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set contentComponent(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get onClick() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set onClick(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Login.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$3 = "src\\Login.svelte"
|
||
|
||
// (57:8) {#if _logo}
|
||
function create_if_block_1$1(ctx) {
|
||
var div, img
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
img = element("img")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
img = claim_element(
|
||
div_nodes,
|
||
"IMG",
|
||
{ src: true, alt: true, class: true },
|
||
false
|
||
)
|
||
var img_nodes = children(img)
|
||
|
||
img_nodes.forEach(detach_dev)
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(img, "src", ctx._logo)
|
||
attr_dev(img, "alt", "logo")
|
||
attr_dev(img, "class", "svelte-crnq0a")
|
||
add_location(img, file$3, 58, 12, 1206)
|
||
attr_dev(div, "class", "logo-container svelte-crnq0a")
|
||
add_location(div, file$3, 57, 8, 1165)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
append_dev(div, img)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed._logo) {
|
||
attr_dev(img, "src", ctx._logo)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_1$1.name,
|
||
type: "if",
|
||
source: "(57:8) {#if _logo}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (86:8) {#if incorrect}
|
||
function create_if_block$2(ctx) {
|
||
var div, t
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
t = text("Incorrect username or password")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
t = claim_text(div_nodes, "Incorrect username or password")
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", "incorrect-details-panel svelte-crnq0a")
|
||
add_location(div, file$3, 86, 8, 2018)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
append_dev(div, t)
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block$2.name,
|
||
type: "if",
|
||
source: "(86:8) {#if incorrect}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$3(ctx) {
|
||
var div7,
|
||
div6,
|
||
t0,
|
||
div4,
|
||
div0,
|
||
t1,
|
||
t2,
|
||
div1,
|
||
input0,
|
||
input0_class_value,
|
||
t3,
|
||
div2,
|
||
t4,
|
||
t5,
|
||
div3,
|
||
input1,
|
||
input1_class_value,
|
||
t6,
|
||
div5,
|
||
button,
|
||
t7,
|
||
button_class_value,
|
||
t8,
|
||
dispose
|
||
|
||
var if_block0 = ctx._logo && create_if_block_1$1(ctx)
|
||
|
||
var if_block1 = ctx.incorrect && create_if_block$2(ctx)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div7 = element("div")
|
||
div6 = element("div")
|
||
if (if_block0) if_block0.c()
|
||
t0 = space()
|
||
div4 = element("div")
|
||
div0 = element("div")
|
||
t1 = text(ctx.usernameLabel)
|
||
t2 = space()
|
||
div1 = element("div")
|
||
input0 = element("input")
|
||
t3 = space()
|
||
div2 = element("div")
|
||
t4 = text(ctx.passwordLabel)
|
||
t5 = space()
|
||
div3 = element("div")
|
||
input1 = element("input")
|
||
t6 = space()
|
||
div5 = element("div")
|
||
button = element("button")
|
||
t7 = text(ctx.loginButtonLabel)
|
||
t8 = space()
|
||
if (if_block1) if_block1.c()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div7 = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div7_nodes = children(div7)
|
||
|
||
div6 = claim_element(div7_nodes, "DIV", { class: true }, false)
|
||
var div6_nodes = children(div6)
|
||
|
||
if (if_block0) if_block0.l(div6_nodes)
|
||
t0 = claim_space(div6_nodes)
|
||
|
||
div4 = claim_element(div6_nodes, "DIV", { class: true }, false)
|
||
var div4_nodes = children(div4)
|
||
|
||
div0 = claim_element(div4_nodes, "DIV", { class: true }, false)
|
||
var div0_nodes = children(div0)
|
||
|
||
t1 = claim_text(div0_nodes, ctx.usernameLabel)
|
||
div0_nodes.forEach(detach_dev)
|
||
t2 = claim_space(div4_nodes)
|
||
|
||
div1 = claim_element(div4_nodes, "DIV", { class: true }, false)
|
||
var div1_nodes = children(div1)
|
||
|
||
input0 = claim_element(
|
||
div1_nodes,
|
||
"INPUT",
|
||
{ type: true, class: true },
|
||
false
|
||
)
|
||
var input0_nodes = children(input0)
|
||
|
||
input0_nodes.forEach(detach_dev)
|
||
div1_nodes.forEach(detach_dev)
|
||
t3 = claim_space(div4_nodes)
|
||
|
||
div2 = claim_element(div4_nodes, "DIV", { class: true }, false)
|
||
var div2_nodes = children(div2)
|
||
|
||
t4 = claim_text(div2_nodes, ctx.passwordLabel)
|
||
div2_nodes.forEach(detach_dev)
|
||
t5 = claim_space(div4_nodes)
|
||
|
||
div3 = claim_element(div4_nodes, "DIV", { class: true }, false)
|
||
var div3_nodes = children(div3)
|
||
|
||
input1 = claim_element(
|
||
div3_nodes,
|
||
"INPUT",
|
||
{ type: true, class: true },
|
||
false
|
||
)
|
||
var input1_nodes = children(input1)
|
||
|
||
input1_nodes.forEach(detach_dev)
|
||
div3_nodes.forEach(detach_dev)
|
||
div4_nodes.forEach(detach_dev)
|
||
t6 = claim_space(div6_nodes)
|
||
|
||
div5 = claim_element(div6_nodes, "DIV", { class: true }, false)
|
||
var div5_nodes = children(div5)
|
||
|
||
button = claim_element(
|
||
div5_nodes,
|
||
"BUTTON",
|
||
{ disabled: true, class: true },
|
||
false
|
||
)
|
||
var button_nodes = children(button)
|
||
|
||
t7 = claim_text(button_nodes, ctx.loginButtonLabel)
|
||
button_nodes.forEach(detach_dev)
|
||
div5_nodes.forEach(detach_dev)
|
||
t8 = claim_space(div6_nodes)
|
||
if (if_block1) if_block1.l(div6_nodes)
|
||
div6_nodes.forEach(detach_dev)
|
||
div7_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div0, "class", "label svelte-crnq0a")
|
||
add_location(div0, file$3, 63, 12, 1310)
|
||
attr_dev(input0, "type", "text")
|
||
attr_dev(
|
||
input0,
|
||
"class",
|
||
(input0_class_value =
|
||
"" + null_to_empty(ctx._inputClass) + " svelte-crnq0a")
|
||
)
|
||
add_location(input0, file$3, 67, 16, 1431)
|
||
attr_dev(div1, "class", "control svelte-crnq0a")
|
||
add_location(div1, file$3, 66, 12, 1393)
|
||
attr_dev(div2, "class", "label svelte-crnq0a")
|
||
add_location(div2, file$3, 69, 12, 1525)
|
||
attr_dev(input1, "type", "password")
|
||
attr_dev(
|
||
input1,
|
||
"class",
|
||
(input1_class_value =
|
||
"" + null_to_empty(ctx._inputClass) + " svelte-crnq0a")
|
||
)
|
||
add_location(input1, file$3, 73, 16, 1646)
|
||
attr_dev(div3, "class", "control svelte-crnq0a")
|
||
add_location(div3, file$3, 72, 12, 1608)
|
||
attr_dev(div4, "class", "form-root svelte-crnq0a")
|
||
add_location(div4, file$3, 62, 8, 1274)
|
||
button.disabled = ctx.busy
|
||
attr_dev(
|
||
button,
|
||
"class",
|
||
(button_class_value =
|
||
"" + null_to_empty(ctx._buttonClass) + " svelte-crnq0a")
|
||
)
|
||
add_location(button, file$3, 78, 12, 1805)
|
||
attr_dev(div5, "class", "login-button-container svelte-crnq0a")
|
||
add_location(div5, file$3, 77, 8, 1756)
|
||
attr_dev(div6, "class", "content svelte-crnq0a")
|
||
add_location(div6, file$3, 54, 4, 1114)
|
||
attr_dev(div7, "class", "root svelte-crnq0a")
|
||
add_location(div7, file$3, 52, 0, 1090)
|
||
|
||
dispose = [
|
||
listen_dev(input0, "input", ctx.input0_input_handler),
|
||
listen_dev(input1, "input", ctx.input1_input_handler),
|
||
listen_dev(button, "click", ctx.login),
|
||
]
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div7, anchor)
|
||
append_dev(div7, div6)
|
||
if (if_block0) if_block0.m(div6, null)
|
||
append_dev(div6, t0)
|
||
append_dev(div6, div4)
|
||
append_dev(div4, div0)
|
||
append_dev(div0, t1)
|
||
append_dev(div4, t2)
|
||
append_dev(div4, div1)
|
||
append_dev(div1, input0)
|
||
|
||
set_input_value(input0, ctx.username)
|
||
|
||
append_dev(div4, t3)
|
||
append_dev(div4, div2)
|
||
append_dev(div2, t4)
|
||
append_dev(div4, t5)
|
||
append_dev(div4, div3)
|
||
append_dev(div3, input1)
|
||
|
||
set_input_value(input1, ctx.password)
|
||
|
||
append_dev(div6, t6)
|
||
append_dev(div6, div5)
|
||
append_dev(div5, button)
|
||
append_dev(button, t7)
|
||
append_dev(div6, t8)
|
||
if (if_block1) if_block1.m(div6, null)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (ctx._logo) {
|
||
if (if_block0) {
|
||
if_block0.p(changed, ctx)
|
||
} else {
|
||
if_block0 = create_if_block_1$1(ctx)
|
||
if_block0.c()
|
||
if_block0.m(div6, t0)
|
||
}
|
||
} else if (if_block0) {
|
||
if_block0.d(1)
|
||
if_block0 = null
|
||
}
|
||
|
||
if (changed.usernameLabel) {
|
||
set_data_dev(t1, ctx.usernameLabel)
|
||
}
|
||
|
||
if (changed.username && input0.value !== ctx.username)
|
||
set_input_value(input0, ctx.username)
|
||
|
||
if (
|
||
changed._inputClass &&
|
||
input0_class_value !==
|
||
(input0_class_value =
|
||
"" + null_to_empty(ctx._inputClass) + " svelte-crnq0a")
|
||
) {
|
||
attr_dev(input0, "class", input0_class_value)
|
||
}
|
||
|
||
if (changed.passwordLabel) {
|
||
set_data_dev(t4, ctx.passwordLabel)
|
||
}
|
||
|
||
if (changed.password && input1.value !== ctx.password)
|
||
set_input_value(input1, ctx.password)
|
||
|
||
if (
|
||
changed._inputClass &&
|
||
input1_class_value !==
|
||
(input1_class_value =
|
||
"" + null_to_empty(ctx._inputClass) + " svelte-crnq0a")
|
||
) {
|
||
attr_dev(input1, "class", input1_class_value)
|
||
}
|
||
|
||
if (changed.loginButtonLabel) {
|
||
set_data_dev(t7, ctx.loginButtonLabel)
|
||
}
|
||
|
||
if (changed.busy) {
|
||
prop_dev(button, "disabled", ctx.busy)
|
||
}
|
||
|
||
if (
|
||
changed._buttonClass &&
|
||
button_class_value !==
|
||
(button_class_value =
|
||
"" + null_to_empty(ctx._buttonClass) + " svelte-crnq0a")
|
||
) {
|
||
attr_dev(button, "class", button_class_value)
|
||
}
|
||
|
||
if (ctx.incorrect) {
|
||
if (!if_block1) {
|
||
if_block1 = create_if_block$2(ctx)
|
||
if_block1.c()
|
||
if_block1.m(div6, null)
|
||
}
|
||
} else if (if_block1) {
|
||
if_block1.d(1)
|
||
if_block1 = null
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div7)
|
||
}
|
||
|
||
if (if_block0) if_block0.d()
|
||
if (if_block1) if_block1.d()
|
||
run_all(dispose)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$3.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$3($$self, $$props, $$invalidate) {
|
||
let {
|
||
usernameLabel = "Username",
|
||
passwordLabel = "Password",
|
||
loginButtonLabel = "Login",
|
||
loginRedirect = "",
|
||
logo = "",
|
||
buttonClass = "",
|
||
inputClass = "",
|
||
_bb,
|
||
} = $$props
|
||
|
||
let username = ""
|
||
let password = ""
|
||
let busy = false
|
||
let incorrect = false
|
||
let _logo = ""
|
||
let _buttonClass = ""
|
||
let _inputClass = ""
|
||
|
||
const login = () => {
|
||
$$invalidate("busy", (busy = true))
|
||
_bb.api
|
||
.post("/api/authenticate", { username, password })
|
||
.then(r => {
|
||
$$invalidate("busy", (busy = false))
|
||
if (r.status === 200) {
|
||
return r.json()
|
||
} else {
|
||
$$invalidate("incorrect", (incorrect = true))
|
||
return
|
||
}
|
||
})
|
||
.then(user => {
|
||
if (user) {
|
||
localStorage.setItem("budibase:user", user)
|
||
location.reload()
|
||
}
|
||
})
|
||
}
|
||
|
||
const writable_props = [
|
||
"usernameLabel",
|
||
"passwordLabel",
|
||
"loginButtonLabel",
|
||
"loginRedirect",
|
||
"logo",
|
||
"buttonClass",
|
||
"inputClass",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Login> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function input0_input_handler() {
|
||
username = this.value
|
||
$$invalidate("username", username)
|
||
}
|
||
|
||
function input1_input_handler() {
|
||
password = this.value
|
||
$$invalidate("password", password)
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("usernameLabel" in $$props)
|
||
$$invalidate("usernameLabel", (usernameLabel = $$props.usernameLabel))
|
||
if ("passwordLabel" in $$props)
|
||
$$invalidate("passwordLabel", (passwordLabel = $$props.passwordLabel))
|
||
if ("loginButtonLabel" in $$props)
|
||
$$invalidate(
|
||
"loginButtonLabel",
|
||
(loginButtonLabel = $$props.loginButtonLabel)
|
||
)
|
||
if ("loginRedirect" in $$props)
|
||
$$invalidate("loginRedirect", (loginRedirect = $$props.loginRedirect))
|
||
if ("logo" in $$props) $$invalidate("logo", (logo = $$props.logo))
|
||
if ("buttonClass" in $$props)
|
||
$$invalidate("buttonClass", (buttonClass = $$props.buttonClass))
|
||
if ("inputClass" in $$props)
|
||
$$invalidate("inputClass", (inputClass = $$props.inputClass))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
usernameLabel,
|
||
passwordLabel,
|
||
loginButtonLabel,
|
||
loginRedirect,
|
||
logo,
|
||
buttonClass,
|
||
inputClass,
|
||
_bb,
|
||
username,
|
||
password,
|
||
busy,
|
||
incorrect,
|
||
_logo,
|
||
_buttonClass,
|
||
_inputClass,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("usernameLabel" in $$props)
|
||
$$invalidate("usernameLabel", (usernameLabel = $$props.usernameLabel))
|
||
if ("passwordLabel" in $$props)
|
||
$$invalidate("passwordLabel", (passwordLabel = $$props.passwordLabel))
|
||
if ("loginButtonLabel" in $$props)
|
||
$$invalidate(
|
||
"loginButtonLabel",
|
||
(loginButtonLabel = $$props.loginButtonLabel)
|
||
)
|
||
if ("loginRedirect" in $$props)
|
||
$$invalidate("loginRedirect", (loginRedirect = $$props.loginRedirect))
|
||
if ("logo" in $$props) $$invalidate("logo", (logo = $$props.logo))
|
||
if ("buttonClass" in $$props)
|
||
$$invalidate("buttonClass", (buttonClass = $$props.buttonClass))
|
||
if ("inputClass" in $$props)
|
||
$$invalidate("inputClass", (inputClass = $$props.inputClass))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("username" in $$props)
|
||
$$invalidate("username", (username = $$props.username))
|
||
if ("password" in $$props)
|
||
$$invalidate("password", (password = $$props.password))
|
||
if ("busy" in $$props) $$invalidate("busy", (busy = $$props.busy))
|
||
if ("incorrect" in $$props)
|
||
$$invalidate("incorrect", (incorrect = $$props.incorrect))
|
||
if ("_logo" in $$props) $$invalidate("_logo", (_logo = $$props._logo))
|
||
if ("_buttonClass" in $$props)
|
||
$$invalidate("_buttonClass", (_buttonClass = $$props._buttonClass))
|
||
if ("_inputClass" in $$props)
|
||
$$invalidate("_inputClass", (_inputClass = $$props._inputClass))
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = { _bb: 1, logo: 1, buttonClass: 1, inputClass: 1 }
|
||
) => {
|
||
if (
|
||
$$dirty._bb ||
|
||
$$dirty.logo ||
|
||
$$dirty.buttonClass ||
|
||
$$dirty.inputClass
|
||
) {
|
||
{
|
||
$$invalidate("_logo", (_logo = _bb.relativeUrl(logo)))
|
||
$$invalidate(
|
||
"_buttonClass",
|
||
(_buttonClass = buttonClass || "default-button")
|
||
)
|
||
$$invalidate(
|
||
"_inputClass",
|
||
(_inputClass = inputClass || "default-input")
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
usernameLabel,
|
||
passwordLabel,
|
||
loginButtonLabel,
|
||
loginRedirect,
|
||
logo,
|
||
buttonClass,
|
||
inputClass,
|
||
_bb,
|
||
username,
|
||
password,
|
||
busy,
|
||
incorrect,
|
||
_logo,
|
||
_buttonClass,
|
||
_inputClass,
|
||
login,
|
||
input0_input_handler,
|
||
input1_input_handler,
|
||
}
|
||
}
|
||
|
||
class Login extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$3, create_fragment$3, safe_not_equal, [
|
||
"usernameLabel",
|
||
"passwordLabel",
|
||
"loginButtonLabel",
|
||
"loginRedirect",
|
||
"logo",
|
||
"buttonClass",
|
||
"inputClass",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Login",
|
||
options,
|
||
id: create_fragment$3.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Login> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get usernameLabel() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set usernameLabel(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get passwordLabel() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set passwordLabel(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get loginButtonLabel() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set loginButtonLabel(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get loginRedirect() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set loginRedirect(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get logo() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set logo(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get buttonClass() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set buttonClass(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get inputClass() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set inputClass(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Login>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Login>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
const buildStyle = styles => {
|
||
let str = ""
|
||
for (let s in styles) {
|
||
if (styles[s]) {
|
||
str += `${s}: ${styles[s]}; `
|
||
}
|
||
}
|
||
return str
|
||
}
|
||
|
||
/* src\Grid.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$4 = "src\\Grid.svelte"
|
||
|
||
function get_each_context$1(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx)
|
||
child_ctx.child = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
// (49:4) {#each children as child, index}
|
||
function create_each_block$1(ctx) {
|
||
var div,
|
||
index = ctx.index,
|
||
div_class_value,
|
||
div_style_value
|
||
|
||
const assign_div = () => ctx.div_binding(div, index)
|
||
const unassign_div = () => ctx.div_binding(null, index)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true, style: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div,
|
||
"class",
|
||
(div_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-10kw8to")
|
||
)
|
||
attr_dev(div, "style", (div_style_value = ctx.childStyle(ctx.child)))
|
||
add_location(div, file$4, 49, 4, 1268)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
assign_div()
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (index !== ctx.index) {
|
||
unassign_div()
|
||
index = ctx.index
|
||
assign_div()
|
||
}
|
||
|
||
if (
|
||
changed.itemContainerClass &&
|
||
div_class_value !==
|
||
(div_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-10kw8to")
|
||
) {
|
||
attr_dev(div, "class", div_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.children &&
|
||
div_style_value !== (div_style_value = ctx.childStyle(ctx.child))
|
||
) {
|
||
attr_dev(div, "style", div_style_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
unassign_div()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block$1.name,
|
||
type: "each",
|
||
source: "(49:4) {#each children as child, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$4(ctx) {
|
||
var div, div_class_value
|
||
|
||
let each_value = ctx.children
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block$1(
|
||
get_each_context$1(ctx, each_value, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true, style: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(div_nodes)
|
||
}
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div,
|
||
"class",
|
||
(div_class_value = "root " + ctx.containerClass + " svelte-10kw8to")
|
||
)
|
||
set_style(div, "width", ctx.width)
|
||
set_style(div, "height", ctx.height)
|
||
set_style(div, "grid-template-columns", ctx.gridTemplateColumns)
|
||
set_style(div, "grid-template-rows", ctx.gridTemplateRows)
|
||
add_location(div, file$4, 46, 0, 1055)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
changed.itemContainerClass ||
|
||
changed.childStyle ||
|
||
changed.children ||
|
||
changed.htmlElements
|
||
) {
|
||
each_value = ctx.children
|
||
|
||
let i
|
||
for (i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context$1(ctx, each_value, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block$1(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value.length
|
||
}
|
||
|
||
if (
|
||
changed.containerClass &&
|
||
div_class_value !==
|
||
(div_class_value = "root " + ctx.containerClass + " svelte-10kw8to")
|
||
) {
|
||
attr_dev(div, "class", div_class_value)
|
||
}
|
||
|
||
if (changed.width) {
|
||
set_style(div, "width", ctx.width)
|
||
}
|
||
|
||
if (changed.height) {
|
||
set_style(div, "height", ctx.height)
|
||
}
|
||
|
||
if (changed.gridTemplateColumns) {
|
||
set_style(div, "grid-template-columns", ctx.gridTemplateColumns)
|
||
}
|
||
|
||
if (changed.gridTemplateRows) {
|
||
set_style(div, "grid-template-rows", ctx.gridTemplateRows)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$4.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
let style = ""
|
||
|
||
function instance$4($$self, $$props, $$invalidate) {
|
||
let {
|
||
gridTemplateRows = "",
|
||
gridTemplateColumns = "",
|
||
children = [],
|
||
width = "auto",
|
||
height = "auto",
|
||
containerClass = "",
|
||
itemContainerClass = "",
|
||
_bb,
|
||
} = $$props
|
||
let htmlElements = {}
|
||
|
||
const childStyle = child =>
|
||
buildStyle({
|
||
"grid-column-start": child.gridColumnStart,
|
||
"grid-column-end": child.gridColumnEnd,
|
||
"grid-column": child.gridColumn,
|
||
"grid-row-start": child.gridRowStart,
|
||
"grid-row-end": child.gridRowStart,
|
||
"grid-row": child.gridRow,
|
||
})
|
||
|
||
const writable_props = [
|
||
"gridTemplateRows",
|
||
"gridTemplateColumns",
|
||
"children",
|
||
"width",
|
||
"height",
|
||
"containerClass",
|
||
"itemContainerClass",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Grid> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function div_binding($$value, index) {
|
||
if (htmlElements[index] === $$value) return
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
htmlElements[index] = $$value
|
||
$$invalidate("htmlElements", htmlElements)
|
||
})
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("gridTemplateRows" in $$props)
|
||
$$invalidate(
|
||
"gridTemplateRows",
|
||
(gridTemplateRows = $$props.gridTemplateRows)
|
||
)
|
||
if ("gridTemplateColumns" in $$props)
|
||
$$invalidate(
|
||
"gridTemplateColumns",
|
||
(gridTemplateColumns = $$props.gridTemplateColumns)
|
||
)
|
||
if ("children" in $$props)
|
||
$$invalidate("children", (children = $$props.children))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("itemContainerClass" in $$props)
|
||
$$invalidate(
|
||
"itemContainerClass",
|
||
(itemContainerClass = $$props.itemContainerClass)
|
||
)
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
gridTemplateRows,
|
||
gridTemplateColumns,
|
||
children,
|
||
width,
|
||
height,
|
||
containerClass,
|
||
itemContainerClass,
|
||
_bb,
|
||
style,
|
||
htmlElements,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("gridTemplateRows" in $$props)
|
||
$$invalidate(
|
||
"gridTemplateRows",
|
||
(gridTemplateRows = $$props.gridTemplateRows)
|
||
)
|
||
if ("gridTemplateColumns" in $$props)
|
||
$$invalidate(
|
||
"gridTemplateColumns",
|
||
(gridTemplateColumns = $$props.gridTemplateColumns)
|
||
)
|
||
if ("children" in $$props)
|
||
$$invalidate("children", (children = $$props.children))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("itemContainerClass" in $$props)
|
||
$$invalidate(
|
||
"itemContainerClass",
|
||
(itemContainerClass = $$props.itemContainerClass)
|
||
)
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("style" in $$props) style = $$props.style
|
||
if ("htmlElements" in $$props)
|
||
$$invalidate("htmlElements", (htmlElements = $$props.htmlElements))
|
||
}
|
||
|
||
$$self.$$.update = ($$dirty = { _bb: 1, htmlElements: 1, children: 1 }) => {
|
||
if ($$dirty._bb || $$dirty.htmlElements || $$dirty.children) {
|
||
{
|
||
if (_bb && htmlElements) {
|
||
for (let el in htmlElements) {
|
||
_bb.initialiseComponent(children[el].control, htmlElements[el])
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
gridTemplateRows,
|
||
gridTemplateColumns,
|
||
children,
|
||
width,
|
||
height,
|
||
containerClass,
|
||
itemContainerClass,
|
||
_bb,
|
||
htmlElements,
|
||
childStyle,
|
||
div_binding,
|
||
}
|
||
}
|
||
|
||
class Grid extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$4, create_fragment$4, safe_not_equal, [
|
||
"gridTemplateRows",
|
||
"gridTemplateColumns",
|
||
"children",
|
||
"width",
|
||
"height",
|
||
"containerClass",
|
||
"itemContainerClass",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Grid",
|
||
options,
|
||
id: create_fragment$4.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Grid> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get gridTemplateRows() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set gridTemplateRows(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get gridTemplateColumns() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set gridTemplateColumns(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get children() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set children(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get width() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set width(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get height() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set height(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get containerClass() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set containerClass(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get itemContainerClass() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set itemContainerClass(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Text.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$5 = "src\\Text.svelte"
|
||
|
||
function create_fragment$5(ctx) {
|
||
var div, t
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
t = text(ctx.value)
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true, style: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
t = claim_text(div_nodes, ctx.value)
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", ctx.containerClass)
|
||
attr_dev(div, "style", ctx.style)
|
||
add_location(div, file$5, 27, 0, 442)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
append_dev(div, t)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.value) {
|
||
set_data_dev(t, ctx.value)
|
||
}
|
||
|
||
if (changed.containerClass) {
|
||
attr_dev(div, "class", ctx.containerClass)
|
||
}
|
||
|
||
if (changed.style) {
|
||
attr_dev(div, "style", ctx.style)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$5.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$5($$self, $$props, $$invalidate) {
|
||
let {
|
||
value = "",
|
||
containerClass = "",
|
||
font = "",
|
||
textAlign = "",
|
||
verticalAlign = "",
|
||
color = "",
|
||
display = "",
|
||
_bb,
|
||
} = $$props
|
||
|
||
let style = ""
|
||
|
||
const writable_props = [
|
||
"value",
|
||
"containerClass",
|
||
"font",
|
||
"textAlign",
|
||
"verticalAlign",
|
||
"color",
|
||
"display",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Text> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
$$self.$set = $$props => {
|
||
if ("value" in $$props) $$invalidate("value", (value = $$props.value))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("font" in $$props) $$invalidate("font", (font = $$props.font))
|
||
if ("textAlign" in $$props)
|
||
$$invalidate("textAlign", (textAlign = $$props.textAlign))
|
||
if ("verticalAlign" in $$props)
|
||
$$invalidate("verticalAlign", (verticalAlign = $$props.verticalAlign))
|
||
if ("color" in $$props) $$invalidate("color", (color = $$props.color))
|
||
if ("display" in $$props)
|
||
$$invalidate("display", (display = $$props.display))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
value,
|
||
containerClass,
|
||
font,
|
||
textAlign,
|
||
verticalAlign,
|
||
color,
|
||
display,
|
||
_bb,
|
||
style,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("value" in $$props) $$invalidate("value", (value = $$props.value))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("font" in $$props) $$invalidate("font", (font = $$props.font))
|
||
if ("textAlign" in $$props)
|
||
$$invalidate("textAlign", (textAlign = $$props.textAlign))
|
||
if ("verticalAlign" in $$props)
|
||
$$invalidate("verticalAlign", (verticalAlign = $$props.verticalAlign))
|
||
if ("color" in $$props) $$invalidate("color", (color = $$props.color))
|
||
if ("display" in $$props)
|
||
$$invalidate("display", (display = $$props.display))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("style" in $$props) $$invalidate("style", (style = $$props.style))
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = { font: 1, verticalAlign: 1, color: 1, textAlign: 1 }
|
||
) => {
|
||
if (
|
||
$$dirty.font ||
|
||
$$dirty.verticalAlign ||
|
||
$$dirty.color ||
|
||
$$dirty.textAlign
|
||
) {
|
||
{
|
||
$$invalidate(
|
||
"style",
|
||
(style = buildStyle({
|
||
font,
|
||
verticalAlign,
|
||
color,
|
||
"text-align": textAlign,
|
||
"vertical-align": verticalAlign,
|
||
}))
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
value,
|
||
containerClass,
|
||
font,
|
||
textAlign,
|
||
verticalAlign,
|
||
color,
|
||
display,
|
||
_bb,
|
||
style,
|
||
}
|
||
}
|
||
|
||
class Text extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$5, create_fragment$5, safe_not_equal, [
|
||
"value",
|
||
"containerClass",
|
||
"font",
|
||
"textAlign",
|
||
"verticalAlign",
|
||
"color",
|
||
"display",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Text",
|
||
options,
|
||
id: create_fragment$5.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Text> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get value() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set value(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get containerClass() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set containerClass(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get font() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set font(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get textAlign() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set textAlign(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get verticalAlign() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set verticalAlign(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get color() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set color(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get display() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set display(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Text>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Text>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
// https://github.com/kaisermann/svelte-css-vars
|
||
|
||
var cssVars = (node, props) => {
|
||
Object.entries(props).forEach(([key, value]) => {
|
||
node.style.setProperty(`--${key}`, value)
|
||
})
|
||
|
||
return {
|
||
update(new_props) {
|
||
Object.entries(new_props).forEach(([key, value]) => {
|
||
node.style.setProperty(`--${key}`, value)
|
||
delete props[key]
|
||
})
|
||
|
||
Object.keys(props).forEach(name =>
|
||
node.style.removeProperty(`--${name}`)
|
||
)
|
||
props = new_props
|
||
},
|
||
}
|
||
}
|
||
|
||
/* src\Nav.svelte generated by Svelte v3.12.1 */
|
||
const { Object: Object_1 } = globals
|
||
|
||
const file$6 = "src\\Nav.svelte"
|
||
|
||
function get_each_context$2(ctx, list, i) {
|
||
const child_ctx = Object_1.create(ctx)
|
||
child_ctx.navItem = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
function get_each_context_1(ctx, list, i) {
|
||
const child_ctx = Object_1.create(ctx)
|
||
child_ctx.navItem = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
// (66:4) {#if !hideNavBar}
|
||
function create_if_block$3(ctx) {
|
||
var div
|
||
|
||
let each_value_1 = ctx.items
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value_1.length; i += 1) {
|
||
each_blocks[i] = create_each_block_1(
|
||
get_each_context_1(ctx, each_value_1, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(div_nodes)
|
||
}
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", "navbar svelte-aihwli")
|
||
add_location(div, file$6, 66, 4, 1774)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.selectedIndex || changed.items) {
|
||
each_value_1 = ctx.items
|
||
|
||
let i
|
||
for (i = 0; i < each_value_1.length; i += 1) {
|
||
const child_ctx = get_each_context_1(ctx, each_value_1, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block_1(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value_1.length
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block$3.name,
|
||
type: "if",
|
||
source: "(66:4) {#if !hideNavBar}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (68:8) {#each items as navItem, index}
|
||
function create_each_block_1(ctx) {
|
||
var div,
|
||
t0_value = ctx.navItem.title + "",
|
||
t0,
|
||
t1,
|
||
dispose
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
t0 = text(t0_value)
|
||
t1 = space()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
t0 = claim_text(div_nodes, t0_value)
|
||
t1 = claim_space(div_nodes)
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", "navitem svelte-aihwli")
|
||
toggle_class(div, "selected", ctx.selectedIndex === ctx.index)
|
||
add_location(div, file$6, 68, 8, 1845)
|
||
dispose = listen_dev(div, "click", ctx.onSelectItem(ctx.index))
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
append_dev(div, t0)
|
||
append_dev(div, t1)
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (changed.items && t0_value !== (t0_value = ctx.navItem.title + "")) {
|
||
set_data_dev(t0, t0_value)
|
||
}
|
||
|
||
if (changed.selectedIndex) {
|
||
toggle_class(div, "selected", ctx.selectedIndex === ctx.index)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
dispose()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block_1.name,
|
||
type: "each",
|
||
source: "(68:8) {#each items as navItem, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (77:4) {#each items as navItem, index}
|
||
function create_each_block$2(ctx) {
|
||
var div,
|
||
index = ctx.index
|
||
|
||
const assign_div = () => ctx.div_binding(div, index)
|
||
const unassign_div = () => ctx.div_binding(null, index)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", "content svelte-aihwli")
|
||
add_location(div, file$6, 78, 4, 2096)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
assign_div()
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (index !== ctx.index) {
|
||
unassign_div()
|
||
index = ctx.index
|
||
assign_div()
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
unassign_div()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block$2.name,
|
||
type: "each",
|
||
source: "(77:4) {#each items as navItem, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$6(ctx) {
|
||
var div, t, cssVars_action
|
||
|
||
var if_block = !ctx.hideNavBar && create_if_block$3(ctx)
|
||
|
||
let each_value = ctx.items
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block$2(
|
||
get_each_context$2(ctx, each_value, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
if (if_block) if_block.c()
|
||
t = space()
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
if (if_block) if_block.l(div_nodes)
|
||
t = claim_space(div_nodes)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(div_nodes)
|
||
}
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "class", "root svelte-aihwli")
|
||
add_location(div, file$6, 64, 0, 1703)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
if (if_block) if_block.m(div, null)
|
||
append_dev(div, t)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
|
||
cssVars_action = cssVars.call(null, div, ctx.styleVars) || {}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (!ctx.hideNavBar) {
|
||
if (if_block) {
|
||
if_block.p(changed, ctx)
|
||
} else {
|
||
if_block = create_if_block$3(ctx)
|
||
if_block.c()
|
||
if_block.m(div, t)
|
||
}
|
||
} else if (if_block) {
|
||
if_block.d(1)
|
||
if_block = null
|
||
}
|
||
|
||
if (changed.componentElements || changed.items) {
|
||
each_value = ctx.items
|
||
|
||
let i
|
||
for (i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context$2(ctx, each_value, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block$2(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(div, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value.length
|
||
}
|
||
|
||
if (typeof cssVars_action.update === "function" && changed.styleVars) {
|
||
cssVars_action.update.call(null, ctx.styleVars)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
if (if_block) if_block.d()
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
|
||
if (cssVars_action && typeof cssVars_action.destroy === "function")
|
||
cssVars_action.destroy()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$6.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$6($$self, $$props, $$invalidate) {
|
||
let {
|
||
navBarBackground = "",
|
||
navBarBorder = "",
|
||
navBarColor = "",
|
||
selectedItemBackground = "",
|
||
selectedItemColor = "",
|
||
selectedItemBorder = "",
|
||
itemHoverBackground = "",
|
||
itemHoverColor = "",
|
||
items = [],
|
||
hideNavBar = false,
|
||
selectedItem = "",
|
||
_bb,
|
||
} = $$props
|
||
|
||
let selectedIndex = -1
|
||
let styleVars = {}
|
||
let components = {}
|
||
let componentElements = {}
|
||
|
||
const hasComponentElements = () =>
|
||
Object.getOwnPropertyNames(componentElements).length > 0
|
||
|
||
const onSelectItem = index => () => {
|
||
$$invalidate("selectedIndex", (selectedIndex = index))
|
||
if (!components[index]) {
|
||
const comp = _bb.initialiseComponent(
|
||
items[index].component,
|
||
componentElements[index]
|
||
)
|
||
components[index] = comp
|
||
}
|
||
}
|
||
|
||
const writable_props = [
|
||
"navBarBackground",
|
||
"navBarBorder",
|
||
"navBarColor",
|
||
"selectedItemBackground",
|
||
"selectedItemColor",
|
||
"selectedItemBorder",
|
||
"itemHoverBackground",
|
||
"itemHoverColor",
|
||
"items",
|
||
"hideNavBar",
|
||
"selectedItem",
|
||
"_bb",
|
||
]
|
||
Object_1.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Nav> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function div_binding($$value, index) {
|
||
if (componentElements[index] === $$value) return
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
componentElements[index] = $$value
|
||
$$invalidate("componentElements", componentElements)
|
||
})
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("navBarBackground" in $$props)
|
||
$$invalidate(
|
||
"navBarBackground",
|
||
(navBarBackground = $$props.navBarBackground)
|
||
)
|
||
if ("navBarBorder" in $$props)
|
||
$$invalidate("navBarBorder", (navBarBorder = $$props.navBarBorder))
|
||
if ("navBarColor" in $$props)
|
||
$$invalidate("navBarColor", (navBarColor = $$props.navBarColor))
|
||
if ("selectedItemBackground" in $$props)
|
||
$$invalidate(
|
||
"selectedItemBackground",
|
||
(selectedItemBackground = $$props.selectedItemBackground)
|
||
)
|
||
if ("selectedItemColor" in $$props)
|
||
$$invalidate(
|
||
"selectedItemColor",
|
||
(selectedItemColor = $$props.selectedItemColor)
|
||
)
|
||
if ("selectedItemBorder" in $$props)
|
||
$$invalidate(
|
||
"selectedItemBorder",
|
||
(selectedItemBorder = $$props.selectedItemBorder)
|
||
)
|
||
if ("itemHoverBackground" in $$props)
|
||
$$invalidate(
|
||
"itemHoverBackground",
|
||
(itemHoverBackground = $$props.itemHoverBackground)
|
||
)
|
||
if ("itemHoverColor" in $$props)
|
||
$$invalidate(
|
||
"itemHoverColor",
|
||
(itemHoverColor = $$props.itemHoverColor)
|
||
)
|
||
if ("items" in $$props) $$invalidate("items", (items = $$props.items))
|
||
if ("hideNavBar" in $$props)
|
||
$$invalidate("hideNavBar", (hideNavBar = $$props.hideNavBar))
|
||
if ("selectedItem" in $$props)
|
||
$$invalidate("selectedItem", (selectedItem = $$props.selectedItem))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
navBarBackground,
|
||
navBarBorder,
|
||
navBarColor,
|
||
selectedItemBackground,
|
||
selectedItemColor,
|
||
selectedItemBorder,
|
||
itemHoverBackground,
|
||
itemHoverColor,
|
||
items,
|
||
hideNavBar,
|
||
selectedItem,
|
||
_bb,
|
||
selectedIndex,
|
||
styleVars,
|
||
components,
|
||
componentElements,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("navBarBackground" in $$props)
|
||
$$invalidate(
|
||
"navBarBackground",
|
||
(navBarBackground = $$props.navBarBackground)
|
||
)
|
||
if ("navBarBorder" in $$props)
|
||
$$invalidate("navBarBorder", (navBarBorder = $$props.navBarBorder))
|
||
if ("navBarColor" in $$props)
|
||
$$invalidate("navBarColor", (navBarColor = $$props.navBarColor))
|
||
if ("selectedItemBackground" in $$props)
|
||
$$invalidate(
|
||
"selectedItemBackground",
|
||
(selectedItemBackground = $$props.selectedItemBackground)
|
||
)
|
||
if ("selectedItemColor" in $$props)
|
||
$$invalidate(
|
||
"selectedItemColor",
|
||
(selectedItemColor = $$props.selectedItemColor)
|
||
)
|
||
if ("selectedItemBorder" in $$props)
|
||
$$invalidate(
|
||
"selectedItemBorder",
|
||
(selectedItemBorder = $$props.selectedItemBorder)
|
||
)
|
||
if ("itemHoverBackground" in $$props)
|
||
$$invalidate(
|
||
"itemHoverBackground",
|
||
(itemHoverBackground = $$props.itemHoverBackground)
|
||
)
|
||
if ("itemHoverColor" in $$props)
|
||
$$invalidate(
|
||
"itemHoverColor",
|
||
(itemHoverColor = $$props.itemHoverColor)
|
||
)
|
||
if ("items" in $$props) $$invalidate("items", (items = $$props.items))
|
||
if ("hideNavBar" in $$props)
|
||
$$invalidate("hideNavBar", (hideNavBar = $$props.hideNavBar))
|
||
if ("selectedItem" in $$props)
|
||
$$invalidate("selectedItem", (selectedItem = $$props.selectedItem))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("selectedIndex" in $$props)
|
||
$$invalidate("selectedIndex", (selectedIndex = $$props.selectedIndex))
|
||
if ("styleVars" in $$props)
|
||
$$invalidate("styleVars", (styleVars = $$props.styleVars))
|
||
if ("components" in $$props) components = $$props.components
|
||
if ("componentElements" in $$props)
|
||
$$invalidate(
|
||
"componentElements",
|
||
(componentElements = $$props.componentElements)
|
||
)
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = {
|
||
navBarBackground: 1,
|
||
navBarBorder: 1,
|
||
navBarColor: 1,
|
||
selectedItemBackground: 1,
|
||
selectedItemColor: 1,
|
||
selectedItemBorder: 1,
|
||
itemHoverBackground: 1,
|
||
itemHoverColor: 1,
|
||
items: 1,
|
||
selectedIndex: 1,
|
||
selectedItem: 1,
|
||
}
|
||
) => {
|
||
if (
|
||
$$dirty.navBarBackground ||
|
||
$$dirty.navBarBorder ||
|
||
$$dirty.navBarColor ||
|
||
$$dirty.selectedItemBackground ||
|
||
$$dirty.selectedItemColor ||
|
||
$$dirty.selectedItemBorder ||
|
||
$$dirty.itemHoverBackground ||
|
||
$$dirty.itemHoverColor ||
|
||
$$dirty.items ||
|
||
$$dirty.selectedIndex ||
|
||
$$dirty.selectedItem
|
||
) {
|
||
{
|
||
$$invalidate(
|
||
"styleVars",
|
||
(styleVars = {
|
||
navBarBackground,
|
||
navBarBorder,
|
||
navBarColor,
|
||
selectedItemBackground,
|
||
selectedItemColor,
|
||
selectedItemBorder,
|
||
itemHoverBackground,
|
||
itemHoverColor,
|
||
})
|
||
)
|
||
|
||
if (items && items.length > 0 && hasComponentElements()) {
|
||
const currentSelectedItem =
|
||
selectedIndex > 0 ? items[selectedIndex].title : ""
|
||
if (selectedItem && currentSelectedItem !== selectedItem) {
|
||
let i = 0
|
||
for (let item of items) {
|
||
if (item.title === selectedItem) {
|
||
onSelectItem(i)()
|
||
}
|
||
i++
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
navBarBackground,
|
||
navBarBorder,
|
||
navBarColor,
|
||
selectedItemBackground,
|
||
selectedItemColor,
|
||
selectedItemBorder,
|
||
itemHoverBackground,
|
||
itemHoverColor,
|
||
items,
|
||
hideNavBar,
|
||
selectedItem,
|
||
_bb,
|
||
selectedIndex,
|
||
styleVars,
|
||
componentElements,
|
||
onSelectItem,
|
||
div_binding,
|
||
}
|
||
}
|
||
|
||
class Nav extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$6, create_fragment$6, safe_not_equal, [
|
||
"navBarBackground",
|
||
"navBarBorder",
|
||
"navBarColor",
|
||
"selectedItemBackground",
|
||
"selectedItemColor",
|
||
"selectedItemBorder",
|
||
"itemHoverBackground",
|
||
"itemHoverColor",
|
||
"items",
|
||
"hideNavBar",
|
||
"selectedItem",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Nav",
|
||
options,
|
||
id: create_fragment$6.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Nav> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get navBarBackground() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set navBarBackground(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get navBarBorder() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set navBarBorder(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get navBarColor() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set navBarColor(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get selectedItemBackground() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set selectedItemBackground(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get selectedItemColor() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set selectedItemColor(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get selectedItemBorder() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set selectedItemBorder(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get itemHoverBackground() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set itemHoverBackground(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get itemHoverColor() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set itemHoverColor(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get items() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set items(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get hideNavBar() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set hideNavBar(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get selectedItem() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set selectedItem(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Panel.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$7 = "src\\Panel.svelte"
|
||
|
||
function create_fragment$7(ctx) {
|
||
var div,
|
||
t_value = ctx.component && ctx.component._component ? "" : ctx.text + "",
|
||
t,
|
||
div_class_value,
|
||
cssVars_action,
|
||
dispose
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
t = text(t_value)
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(
|
||
nodes,
|
||
"DIV",
|
||
{ class: true, style: true, "this:bind": true },
|
||
false
|
||
)
|
||
var div_nodes = children(div)
|
||
|
||
t = claim_text(div_nodes, t_value)
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div,
|
||
"class",
|
||
(div_class_value =
|
||
"" + ctx.containerClass + " panel" + " svelte-6yfcjx")
|
||
)
|
||
attr_dev(div, "style", ctx.style)
|
||
attr_dev(div, "this:bind", ctx.componentElement)
|
||
add_location(div, file$7, 53, 0, 1137)
|
||
dispose = listen_dev(div, "click", ctx.clickHandler)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
append_dev(div, t)
|
||
cssVars_action = cssVars.call(null, div, ctx.styleVars) || {}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
(changed.component || changed.text) &&
|
||
t_value !==
|
||
(t_value =
|
||
ctx.component && ctx.component._component ? "" : ctx.text + "")
|
||
) {
|
||
set_data_dev(t, t_value)
|
||
}
|
||
|
||
if (
|
||
changed.containerClass &&
|
||
div_class_value !==
|
||
(div_class_value =
|
||
"" + ctx.containerClass + " panel" + " svelte-6yfcjx")
|
||
) {
|
||
attr_dev(div, "class", div_class_value)
|
||
}
|
||
|
||
if (changed.style) {
|
||
attr_dev(div, "style", ctx.style)
|
||
}
|
||
|
||
if (typeof cssVars_action.update === "function" && changed.styleVars) {
|
||
cssVars_action.update.call(null, ctx.styleVars)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
if (cssVars_action && typeof cssVars_action.destroy === "function")
|
||
cssVars_action.destroy()
|
||
dispose()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$7.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$7($$self, $$props, $$invalidate) {
|
||
let {
|
||
component = "",
|
||
text = "",
|
||
containerClass = "",
|
||
background = "",
|
||
border = "",
|
||
borderRadius = "",
|
||
font = "",
|
||
display = "",
|
||
textAlign = "",
|
||
color = "",
|
||
padding = "",
|
||
margin = "",
|
||
hoverBackground = "",
|
||
hoverColor = "",
|
||
onClick,
|
||
height,
|
||
width,
|
||
_bb,
|
||
} = $$props
|
||
|
||
let styleVars
|
||
let style = ""
|
||
let componentElement
|
||
|
||
const clickHandler = () => {
|
||
if (onClick) onClick()
|
||
}
|
||
|
||
const writable_props = [
|
||
"component",
|
||
"text",
|
||
"containerClass",
|
||
"background",
|
||
"border",
|
||
"borderRadius",
|
||
"font",
|
||
"display",
|
||
"textAlign",
|
||
"color",
|
||
"padding",
|
||
"margin",
|
||
"hoverBackground",
|
||
"hoverColor",
|
||
"onClick",
|
||
"height",
|
||
"width",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Panel> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
$$self.$set = $$props => {
|
||
if ("component" in $$props)
|
||
$$invalidate("component", (component = $$props.component))
|
||
if ("text" in $$props) $$invalidate("text", (text = $$props.text))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("background" in $$props)
|
||
$$invalidate("background", (background = $$props.background))
|
||
if ("border" in $$props) $$invalidate("border", (border = $$props.border))
|
||
if ("borderRadius" in $$props)
|
||
$$invalidate("borderRadius", (borderRadius = $$props.borderRadius))
|
||
if ("font" in $$props) $$invalidate("font", (font = $$props.font))
|
||
if ("display" in $$props)
|
||
$$invalidate("display", (display = $$props.display))
|
||
if ("textAlign" in $$props)
|
||
$$invalidate("textAlign", (textAlign = $$props.textAlign))
|
||
if ("color" in $$props) $$invalidate("color", (color = $$props.color))
|
||
if ("padding" in $$props)
|
||
$$invalidate("padding", (padding = $$props.padding))
|
||
if ("margin" in $$props) $$invalidate("margin", (margin = $$props.margin))
|
||
if ("hoverBackground" in $$props)
|
||
$$invalidate(
|
||
"hoverBackground",
|
||
(hoverBackground = $$props.hoverBackground)
|
||
)
|
||
if ("hoverColor" in $$props)
|
||
$$invalidate("hoverColor", (hoverColor = $$props.hoverColor))
|
||
if ("onClick" in $$props)
|
||
$$invalidate("onClick", (onClick = $$props.onClick))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
component,
|
||
text,
|
||
containerClass,
|
||
background,
|
||
border,
|
||
borderRadius,
|
||
font,
|
||
display,
|
||
textAlign,
|
||
color,
|
||
padding,
|
||
margin,
|
||
hoverBackground,
|
||
hoverColor,
|
||
onClick,
|
||
height,
|
||
width,
|
||
_bb,
|
||
styleVars,
|
||
style,
|
||
componentElement,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("component" in $$props)
|
||
$$invalidate("component", (component = $$props.component))
|
||
if ("text" in $$props) $$invalidate("text", (text = $$props.text))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("background" in $$props)
|
||
$$invalidate("background", (background = $$props.background))
|
||
if ("border" in $$props) $$invalidate("border", (border = $$props.border))
|
||
if ("borderRadius" in $$props)
|
||
$$invalidate("borderRadius", (borderRadius = $$props.borderRadius))
|
||
if ("font" in $$props) $$invalidate("font", (font = $$props.font))
|
||
if ("display" in $$props)
|
||
$$invalidate("display", (display = $$props.display))
|
||
if ("textAlign" in $$props)
|
||
$$invalidate("textAlign", (textAlign = $$props.textAlign))
|
||
if ("color" in $$props) $$invalidate("color", (color = $$props.color))
|
||
if ("padding" in $$props)
|
||
$$invalidate("padding", (padding = $$props.padding))
|
||
if ("margin" in $$props) $$invalidate("margin", (margin = $$props.margin))
|
||
if ("hoverBackground" in $$props)
|
||
$$invalidate(
|
||
"hoverBackground",
|
||
(hoverBackground = $$props.hoverBackground)
|
||
)
|
||
if ("hoverColor" in $$props)
|
||
$$invalidate("hoverColor", (hoverColor = $$props.hoverColor))
|
||
if ("onClick" in $$props)
|
||
$$invalidate("onClick", (onClick = $$props.onClick))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("styleVars" in $$props)
|
||
$$invalidate("styleVars", (styleVars = $$props.styleVars))
|
||
if ("style" in $$props) $$invalidate("style", (style = $$props.style))
|
||
if ("componentElement" in $$props)
|
||
$$invalidate(
|
||
"componentElement",
|
||
(componentElement = $$props.componentElement)
|
||
)
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = {
|
||
border: 1,
|
||
background: 1,
|
||
font: 1,
|
||
margin: 1,
|
||
padding: 1,
|
||
display: 1,
|
||
color: 1,
|
||
height: 1,
|
||
width: 1,
|
||
textAlign: 1,
|
||
borderRadius: 1,
|
||
onClick: 1,
|
||
_bb: 1,
|
||
component: 1,
|
||
componentElement: 1,
|
||
hoverBackground: 1,
|
||
hoverColor: 1,
|
||
}
|
||
) => {
|
||
if (
|
||
$$dirty.border ||
|
||
$$dirty.background ||
|
||
$$dirty.font ||
|
||
$$dirty.margin ||
|
||
$$dirty.padding ||
|
||
$$dirty.display ||
|
||
$$dirty.color ||
|
||
$$dirty.height ||
|
||
$$dirty.width ||
|
||
$$dirty.textAlign ||
|
||
$$dirty.borderRadius ||
|
||
$$dirty.onClick ||
|
||
$$dirty._bb ||
|
||
$$dirty.component ||
|
||
$$dirty.componentElement ||
|
||
$$dirty.hoverBackground ||
|
||
$$dirty.hoverColor
|
||
) {
|
||
{
|
||
$$invalidate(
|
||
"style",
|
||
(style = buildStyle({
|
||
border,
|
||
background,
|
||
font,
|
||
margin,
|
||
padding,
|
||
display,
|
||
color,
|
||
height,
|
||
width,
|
||
"text-align": textAlign,
|
||
"border-radius": borderRadius,
|
||
cursor: onClick ? "pointer" : "none",
|
||
}))
|
||
)
|
||
|
||
if (_bb && component) {
|
||
_bb.initialiseComponent(component, componentElement)
|
||
}
|
||
|
||
$$invalidate(
|
||
"styleVars",
|
||
(styleVars = {
|
||
hoverBackground: hoverBackground || background,
|
||
hoverColor: hoverColor || color,
|
||
})
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
component,
|
||
text,
|
||
containerClass,
|
||
background,
|
||
border,
|
||
borderRadius,
|
||
font,
|
||
display,
|
||
textAlign,
|
||
color,
|
||
padding,
|
||
margin,
|
||
hoverBackground,
|
||
hoverColor,
|
||
onClick,
|
||
height,
|
||
width,
|
||
_bb,
|
||
styleVars,
|
||
style,
|
||
componentElement,
|
||
clickHandler,
|
||
}
|
||
}
|
||
|
||
class Panel extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$7, create_fragment$7, safe_not_equal, [
|
||
"component",
|
||
"text",
|
||
"containerClass",
|
||
"background",
|
||
"border",
|
||
"borderRadius",
|
||
"font",
|
||
"display",
|
||
"textAlign",
|
||
"color",
|
||
"padding",
|
||
"margin",
|
||
"hoverBackground",
|
||
"hoverColor",
|
||
"onClick",
|
||
"height",
|
||
"width",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Panel",
|
||
options,
|
||
id: create_fragment$7.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx.onClick === undefined && !("onClick" in props)) {
|
||
console.warn("<Panel> was created without expected prop 'onClick'")
|
||
}
|
||
if (ctx.height === undefined && !("height" in props)) {
|
||
console.warn("<Panel> was created without expected prop 'height'")
|
||
}
|
||
if (ctx.width === undefined && !("width" in props)) {
|
||
console.warn("<Panel> was created without expected prop 'width'")
|
||
}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Panel> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get component() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set component(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get text() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set text(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get containerClass() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set containerClass(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get background() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set background(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get border() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set border(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get borderRadius() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set borderRadius(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get font() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set font(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get display() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set display(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get textAlign() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set textAlign(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get color() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set color(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get padding() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set padding(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get margin() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set margin(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get hoverBackground() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set hoverBackground(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get hoverColor() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set hoverColor(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get onClick() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set onClick(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get height() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set height(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get width() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set width(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Panel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\StackPanel.svelte generated by Svelte v3.12.1 */
|
||
const { Object: Object_1$1 } = globals
|
||
|
||
const file$8 = "src\\StackPanel.svelte"
|
||
|
||
function get_each_context$3(ctx, list, i) {
|
||
const child_ctx = Object_1$1.create(ctx)
|
||
child_ctx.child = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
function get_each_context_1$1(ctx, list, i) {
|
||
const child_ctx = Object_1$1.create(ctx)
|
||
child_ctx.child = list[i]
|
||
child_ctx.index = i
|
||
return child_ctx
|
||
}
|
||
|
||
// (84:4) {#if children}
|
||
function create_if_block_1$2(ctx) {
|
||
var each_1_anchor
|
||
|
||
let each_value_1 = ctx.children
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value_1.length; i += 1) {
|
||
each_blocks[i] = create_each_block_1$1(
|
||
get_each_context_1$1(ctx, each_value_1, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
|
||
each_1_anchor = empty()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(nodes)
|
||
}
|
||
|
||
each_1_anchor = empty()
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(target, anchor)
|
||
}
|
||
|
||
insert_dev(target, each_1_anchor, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
changed.direction ||
|
||
changed.itemContainerClass ||
|
||
changed.staticHtmlElements ||
|
||
changed.children
|
||
) {
|
||
each_value_1 = ctx.children
|
||
|
||
let i
|
||
for (i = 0; i < each_value_1.length; i += 1) {
|
||
const child_ctx = get_each_context_1$1(ctx, each_value_1, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block_1$1(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value_1.length
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
destroy_each(each_blocks, detaching)
|
||
|
||
if (detaching) {
|
||
detach_dev(each_1_anchor)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_1$2.name,
|
||
type: "if",
|
||
source: "(84:4) {#if children}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (85:4) {#each children as child, index}
|
||
function create_each_block_1$1(ctx) {
|
||
var div1,
|
||
div0,
|
||
index = ctx.index,
|
||
div0_class_value,
|
||
t,
|
||
div1_class_value
|
||
|
||
const assign_div0 = () => ctx.div0_binding(div0, index)
|
||
const unassign_div0 = () => ctx.div0_binding(null, index)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div1 = element("div")
|
||
div0 = element("div")
|
||
t = space()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div1 = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div1_nodes = children(div1)
|
||
|
||
div0 = claim_element(div1_nodes, "DIV", { class: true }, false)
|
||
var div0_nodes = children(div0)
|
||
|
||
div0_nodes.forEach(detach_dev)
|
||
t = claim_space(div1_nodes)
|
||
div1_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div0,
|
||
"class",
|
||
(div0_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-osi0db")
|
||
)
|
||
add_location(div0, file$8, 86, 8, 1926)
|
||
attr_dev(
|
||
div1,
|
||
"class",
|
||
(div1_class_value =
|
||
"" + null_to_empty(ctx.direction) + " svelte-osi0db")
|
||
)
|
||
add_location(div1, file$8, 85, 4, 1894)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div1, anchor)
|
||
append_dev(div1, div0)
|
||
assign_div0()
|
||
append_dev(div1, t)
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (index !== ctx.index) {
|
||
unassign_div0()
|
||
index = ctx.index
|
||
assign_div0()
|
||
}
|
||
|
||
if (
|
||
changed.itemContainerClass &&
|
||
div0_class_value !==
|
||
(div0_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-osi0db")
|
||
) {
|
||
attr_dev(div0, "class", div0_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.direction &&
|
||
div1_class_value !==
|
||
(div1_class_value =
|
||
"" + null_to_empty(ctx.direction) + " svelte-osi0db")
|
||
) {
|
||
attr_dev(div1, "class", div1_class_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div1)
|
||
}
|
||
|
||
unassign_div0()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block_1$1.name,
|
||
type: "each",
|
||
source: "(85:4) {#each children as child, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (94:4) {#if data && data.length > 0}
|
||
function create_if_block$4(ctx) {
|
||
var each_1_anchor
|
||
|
||
let each_value = ctx.data
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block$3(
|
||
get_each_context$3(ctx, each_value, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
|
||
each_1_anchor = empty()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(nodes)
|
||
}
|
||
|
||
each_1_anchor = empty()
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(target, anchor)
|
||
}
|
||
|
||
insert_dev(target, each_1_anchor, anchor)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
changed.direction ||
|
||
changed.itemContainerClass ||
|
||
changed.dataBoundElements ||
|
||
changed.data
|
||
) {
|
||
each_value = ctx.data
|
||
|
||
let i
|
||
for (i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context$3(ctx, each_value, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block$3(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value.length
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
destroy_each(each_blocks, detaching)
|
||
|
||
if (detaching) {
|
||
detach_dev(each_1_anchor)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block$4.name,
|
||
type: "if",
|
||
source: "(94:4) {#if data && data.length > 0}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (95:4) {#each data as child, index}
|
||
function create_each_block$3(ctx) {
|
||
var div1,
|
||
div0,
|
||
index = ctx.index,
|
||
div0_class_value,
|
||
t,
|
||
div1_class_value
|
||
|
||
const assign_div0 = () => ctx.div0_binding_1(div0, index)
|
||
const unassign_div0 = () => ctx.div0_binding_1(null, index)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div1 = element("div")
|
||
div0 = element("div")
|
||
t = space()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div1 = claim_element(nodes, "DIV", { class: true }, false)
|
||
var div1_nodes = children(div1)
|
||
|
||
div0 = claim_element(div1_nodes, "DIV", { class: true }, false)
|
||
var div0_nodes = children(div0)
|
||
|
||
div0_nodes.forEach(detach_dev)
|
||
t = claim_space(div1_nodes)
|
||
div1_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div0,
|
||
"class",
|
||
(div0_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-osi0db")
|
||
)
|
||
add_location(div0, file$8, 96, 8, 2163)
|
||
attr_dev(
|
||
div1,
|
||
"class",
|
||
(div1_class_value =
|
||
"" + null_to_empty(ctx.direction) + " svelte-osi0db")
|
||
)
|
||
add_location(div1, file$8, 95, 4, 2131)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div1, anchor)
|
||
append_dev(div1, div0)
|
||
assign_div0()
|
||
append_dev(div1, t)
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (index !== ctx.index) {
|
||
unassign_div0()
|
||
index = ctx.index
|
||
assign_div0()
|
||
}
|
||
|
||
if (
|
||
changed.itemContainerClass &&
|
||
div0_class_value !==
|
||
(div0_class_value =
|
||
"" + null_to_empty(ctx.itemContainerClass) + " svelte-osi0db")
|
||
) {
|
||
attr_dev(div0, "class", div0_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.direction &&
|
||
div1_class_value !==
|
||
(div1_class_value =
|
||
"" + null_to_empty(ctx.direction) + " svelte-osi0db")
|
||
) {
|
||
attr_dev(div1, "class", div1_class_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div1)
|
||
}
|
||
|
||
unassign_div0()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block$3.name,
|
||
type: "each",
|
||
source: "(95:4) {#each data as child, index}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$8(ctx) {
|
||
var div, t, div_class_value
|
||
|
||
var if_block0 = ctx.children && create_if_block_1$2(ctx)
|
||
|
||
var if_block1 = ctx.data && ctx.data.length > 0 && create_if_block$4(ctx)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
if (if_block0) if_block0.c()
|
||
t = space()
|
||
if (if_block1) if_block1.c()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { class: true, style: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
if (if_block0) if_block0.l(div_nodes)
|
||
t = claim_space(div_nodes)
|
||
if (if_block1) if_block1.l(div_nodes)
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
div,
|
||
"class",
|
||
(div_class_value = "root " + ctx.containerClass + " svelte-osi0db")
|
||
)
|
||
set_style(div, "width", ctx.width)
|
||
set_style(div, "height", ctx.height)
|
||
add_location(div, file$8, 80, 0, 1751)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
if (if_block0) if_block0.m(div, null)
|
||
append_dev(div, t)
|
||
if (if_block1) if_block1.m(div, null)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (ctx.children) {
|
||
if (if_block0) {
|
||
if_block0.p(changed, ctx)
|
||
} else {
|
||
if_block0 = create_if_block_1$2(ctx)
|
||
if_block0.c()
|
||
if_block0.m(div, t)
|
||
}
|
||
} else if (if_block0) {
|
||
if_block0.d(1)
|
||
if_block0 = null
|
||
}
|
||
|
||
if (ctx.data && ctx.data.length > 0) {
|
||
if (if_block1) {
|
||
if_block1.p(changed, ctx)
|
||
} else {
|
||
if_block1 = create_if_block$4(ctx)
|
||
if_block1.c()
|
||
if_block1.m(div, null)
|
||
}
|
||
} else if (if_block1) {
|
||
if_block1.d(1)
|
||
if_block1 = null
|
||
}
|
||
|
||
if (
|
||
changed.containerClass &&
|
||
div_class_value !==
|
||
(div_class_value = "root " + ctx.containerClass + " svelte-osi0db")
|
||
) {
|
||
attr_dev(div, "class", div_class_value)
|
||
}
|
||
|
||
if (changed.width) {
|
||
set_style(div, "width", ctx.width)
|
||
}
|
||
|
||
if (changed.height) {
|
||
set_style(div, "height", ctx.height)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
if (if_block0) if_block0.d()
|
||
if (if_block1) if_block1.d()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$8.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$8($$self, $$props, $$invalidate) {
|
||
let {
|
||
direction = "horizontal",
|
||
children = [],
|
||
width = "auto",
|
||
height = "auto",
|
||
containerClass = "",
|
||
itemContainerClass = "",
|
||
onLoad,
|
||
data = [],
|
||
dataItemComponent,
|
||
_bb,
|
||
} = $$props
|
||
|
||
let staticHtmlElements = {}
|
||
let staticComponents = {}
|
||
let dataBoundElements = {}
|
||
let dataBoundComponents = {}
|
||
|
||
let onLoadCalled = false
|
||
|
||
const hasDataBoundComponents = () =>
|
||
Object.getOwnPropertyNames(dataBoundComponents).length > 0
|
||
|
||
const hasData = () => Array.isArray(data) && data.length > 0
|
||
|
||
const hasStaticComponents = () => {
|
||
return Object.getOwnPropertyNames(staticComponents).length > 0
|
||
}
|
||
|
||
const writable_props = [
|
||
"direction",
|
||
"children",
|
||
"width",
|
||
"height",
|
||
"containerClass",
|
||
"itemContainerClass",
|
||
"onLoad",
|
||
"data",
|
||
"dataItemComponent",
|
||
"_bb",
|
||
]
|
||
Object_1$1.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<StackPanel> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
function div0_binding($$value, index) {
|
||
if (staticHtmlElements[index] === $$value) return
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
staticHtmlElements[index] = $$value
|
||
$$invalidate("staticHtmlElements", staticHtmlElements)
|
||
})
|
||
}
|
||
|
||
function div0_binding_1($$value, index) {
|
||
if (dataBoundElements[index] === $$value) return
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
dataBoundElements[index] = $$value
|
||
$$invalidate("dataBoundElements", dataBoundElements)
|
||
})
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ("direction" in $$props)
|
||
$$invalidate("direction", (direction = $$props.direction))
|
||
if ("children" in $$props)
|
||
$$invalidate("children", (children = $$props.children))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("itemContainerClass" in $$props)
|
||
$$invalidate(
|
||
"itemContainerClass",
|
||
(itemContainerClass = $$props.itemContainerClass)
|
||
)
|
||
if ("onLoad" in $$props) $$invalidate("onLoad", (onLoad = $$props.onLoad))
|
||
if ("data" in $$props) $$invalidate("data", (data = $$props.data))
|
||
if ("dataItemComponent" in $$props)
|
||
$$invalidate(
|
||
"dataItemComponent",
|
||
(dataItemComponent = $$props.dataItemComponent)
|
||
)
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
direction,
|
||
children,
|
||
width,
|
||
height,
|
||
containerClass,
|
||
itemContainerClass,
|
||
onLoad,
|
||
data,
|
||
dataItemComponent,
|
||
_bb,
|
||
staticHtmlElements,
|
||
staticComponents,
|
||
dataBoundElements,
|
||
dataBoundComponents,
|
||
onLoadCalled,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("direction" in $$props)
|
||
$$invalidate("direction", (direction = $$props.direction))
|
||
if ("children" in $$props)
|
||
$$invalidate("children", (children = $$props.children))
|
||
if ("width" in $$props) $$invalidate("width", (width = $$props.width))
|
||
if ("height" in $$props) $$invalidate("height", (height = $$props.height))
|
||
if ("containerClass" in $$props)
|
||
$$invalidate(
|
||
"containerClass",
|
||
(containerClass = $$props.containerClass)
|
||
)
|
||
if ("itemContainerClass" in $$props)
|
||
$$invalidate(
|
||
"itemContainerClass",
|
||
(itemContainerClass = $$props.itemContainerClass)
|
||
)
|
||
if ("onLoad" in $$props) $$invalidate("onLoad", (onLoad = $$props.onLoad))
|
||
if ("data" in $$props) $$invalidate("data", (data = $$props.data))
|
||
if ("dataItemComponent" in $$props)
|
||
$$invalidate(
|
||
"dataItemComponent",
|
||
(dataItemComponent = $$props.dataItemComponent)
|
||
)
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("staticHtmlElements" in $$props)
|
||
$$invalidate(
|
||
"staticHtmlElements",
|
||
(staticHtmlElements = $$props.staticHtmlElements)
|
||
)
|
||
if ("staticComponents" in $$props)
|
||
$$invalidate(
|
||
"staticComponents",
|
||
(staticComponents = $$props.staticComponents)
|
||
)
|
||
if ("dataBoundElements" in $$props)
|
||
$$invalidate(
|
||
"dataBoundElements",
|
||
(dataBoundElements = $$props.dataBoundElements)
|
||
)
|
||
if ("dataBoundComponents" in $$props)
|
||
$$invalidate(
|
||
"dataBoundComponents",
|
||
(dataBoundComponents = $$props.dataBoundComponents)
|
||
)
|
||
if ("onLoadCalled" in $$props)
|
||
$$invalidate("onLoadCalled", (onLoadCalled = $$props.onLoadCalled))
|
||
}
|
||
|
||
$$self.$$.update = (
|
||
$$dirty = {
|
||
staticHtmlElements: 1,
|
||
staticComponents: 1,
|
||
_bb: 1,
|
||
children: 1,
|
||
dataBoundComponents: 1,
|
||
dataBoundElements: 1,
|
||
dataItemComponent: 1,
|
||
data: 1,
|
||
onLoadCalled: 1,
|
||
onLoad: 1,
|
||
}
|
||
) => {
|
||
if (
|
||
$$dirty.staticHtmlElements ||
|
||
$$dirty.staticComponents ||
|
||
$$dirty._bb ||
|
||
$$dirty.children ||
|
||
$$dirty.dataBoundComponents ||
|
||
$$dirty.dataBoundElements ||
|
||
$$dirty.dataItemComponent ||
|
||
$$dirty.data ||
|
||
$$dirty.onLoadCalled ||
|
||
$$dirty.onLoad
|
||
) {
|
||
{
|
||
if (staticHtmlElements) {
|
||
if (hasStaticComponents()) {
|
||
for (let c in staticComponents) {
|
||
staticComponents[c].$destroy()
|
||
}
|
||
$$invalidate("staticComponents", (staticComponents = {}))
|
||
}
|
||
|
||
for (let el in staticHtmlElements) {
|
||
$$invalidate(
|
||
"staticComponents",
|
||
(staticComponents[el] = _bb.initialiseComponent(
|
||
children[el].control,
|
||
staticHtmlElements[el]
|
||
)),
|
||
staticComponents
|
||
)
|
||
}
|
||
}
|
||
|
||
if (hasDataBoundComponents()) {
|
||
for (let c in dataBoundComponents) {
|
||
dataBoundComponents[c].$destroy()
|
||
}
|
||
$$invalidate("dataBoundComponents", (dataBoundComponents = {}))
|
||
}
|
||
|
||
if (hasData()) {
|
||
for (let d in dataBoundElements) {
|
||
_bb.initialiseComponent(
|
||
dataItemComponent,
|
||
dataBoundElements[d],
|
||
data[parseInt(d)]
|
||
)
|
||
}
|
||
}
|
||
|
||
if (!onLoadCalled && onLoad && !onLoad.isPlaceholder) {
|
||
onLoad()
|
||
$$invalidate("onLoadCalled", (onLoadCalled = true))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
direction,
|
||
children,
|
||
width,
|
||
height,
|
||
containerClass,
|
||
itemContainerClass,
|
||
onLoad,
|
||
data,
|
||
dataItemComponent,
|
||
_bb,
|
||
staticHtmlElements,
|
||
dataBoundElements,
|
||
div0_binding,
|
||
div0_binding_1,
|
||
}
|
||
}
|
||
|
||
class StackPanel extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$8, create_fragment$8, safe_not_equal, [
|
||
"direction",
|
||
"children",
|
||
"width",
|
||
"height",
|
||
"containerClass",
|
||
"itemContainerClass",
|
||
"onLoad",
|
||
"data",
|
||
"dataItemComponent",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "StackPanel",
|
||
options,
|
||
id: create_fragment$8.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx.onLoad === undefined && !("onLoad" in props)) {
|
||
console.warn("<StackPanel> was created without expected prop 'onLoad'")
|
||
}
|
||
if (
|
||
ctx.dataItemComponent === undefined &&
|
||
!("dataItemComponent" in props)
|
||
) {
|
||
console.warn(
|
||
"<StackPanel> was created without expected prop 'dataItemComponent'"
|
||
)
|
||
}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<StackPanel> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get direction() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set direction(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get children() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set children(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get width() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set width(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get height() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set height(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get containerClass() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set containerClass(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get itemContainerClass() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set itemContainerClass(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get onLoad() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set onLoad(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get data() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set data(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get dataItemComponent() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set dataItemComponent(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<StackPanel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
/* src\Table.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$9 = "src\\Table.svelte"
|
||
|
||
function get_each_context_1$2(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx)
|
||
child_ctx.col = list[i]
|
||
return child_ctx
|
||
}
|
||
|
||
function get_each_context$4(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx)
|
||
child_ctx.row = list[i]
|
||
return child_ctx
|
||
}
|
||
|
||
function get_each_context_2(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx)
|
||
child_ctx.col = list[i]
|
||
return child_ctx
|
||
}
|
||
|
||
// (23:12) {#each columns as col}
|
||
function create_each_block_2(ctx) {
|
||
var th,
|
||
t_value = ctx.col.title + "",
|
||
t,
|
||
th_class_value
|
||
|
||
const block = {
|
||
c: function create() {
|
||
th = element("th")
|
||
t = text(t_value)
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
th = claim_element(nodes, "TH", { class: true }, false)
|
||
var th_nodes = children(th)
|
||
|
||
t = claim_text(th_nodes, t_value)
|
||
th_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
th,
|
||
"class",
|
||
(th_class_value = "" + null_to_empty(ctx.thClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(th, file$9, 23, 12, 452)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, th, anchor)
|
||
append_dev(th, t)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.columns && t_value !== (t_value = ctx.col.title + "")) {
|
||
set_data_dev(t, t_value)
|
||
}
|
||
|
||
if (
|
||
changed.thClass &&
|
||
th_class_value !==
|
||
(th_class_value =
|
||
"" + null_to_empty(ctx.thClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(th, "class", th_class_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(th)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block_2.name,
|
||
type: "each",
|
||
source: "(23:12) {#each columns as col}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (32:12) {#each columns as col}
|
||
function create_each_block_1$2(ctx) {
|
||
var th,
|
||
t_value = ctx._bb.getStateOrValue(ctx.col.value, ctx.row) + "",
|
||
t,
|
||
th_class_value
|
||
|
||
const block = {
|
||
c: function create() {
|
||
th = element("th")
|
||
t = text(t_value)
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
th = claim_element(nodes, "TH", { class: true }, false)
|
||
var th_nodes = children(th)
|
||
|
||
t = claim_text(th_nodes, t_value)
|
||
th_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
th,
|
||
"class",
|
||
(th_class_value = "" + null_to_empty(ctx.thClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(th, file$9, 32, 12, 725)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, th, anchor)
|
||
append_dev(th, t)
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (
|
||
(changed._bb || changed.columns || changed.data) &&
|
||
t_value !==
|
||
(t_value = ctx._bb.getStateOrValue(ctx.col.value, ctx.row) + "")
|
||
) {
|
||
set_data_dev(t, t_value)
|
||
}
|
||
|
||
if (
|
||
changed.thClass &&
|
||
th_class_value !==
|
||
(th_class_value =
|
||
"" + null_to_empty(ctx.thClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(th, "class", th_class_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(th)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block_1$2.name,
|
||
type: "each",
|
||
source: "(32:12) {#each columns as col}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (29:8) {#each data as row}
|
||
function create_each_block$4(ctx) {
|
||
var tr, t, tr_class_value, dispose
|
||
|
||
let each_value_1 = ctx.columns
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value_1.length; i += 1) {
|
||
each_blocks[i] = create_each_block_1$2(
|
||
get_each_context_1$2(ctx, each_value_1, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
tr = element("tr")
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
|
||
t = space()
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
tr = claim_element(nodes, "TR", { class: true }, false)
|
||
var tr_nodes = children(tr)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(tr_nodes)
|
||
}
|
||
|
||
t = claim_space(tr_nodes)
|
||
tr_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
tr,
|
||
"class",
|
||
(tr_class_value = "" + null_to_empty(ctx.trClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(tr, file$9, 29, 8, 609)
|
||
dispose = listen_dev(tr, "click", ctx.rowClickHandler(ctx.row))
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, tr, anchor)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(tr, null)
|
||
}
|
||
|
||
append_dev(tr, t)
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
if (changed.thClass || changed._bb || changed.columns || changed.data) {
|
||
each_value_1 = ctx.columns
|
||
|
||
let i
|
||
for (i = 0; i < each_value_1.length; i += 1) {
|
||
const child_ctx = get_each_context_1$2(ctx, each_value_1, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block_1$2(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(tr, t)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value_1.length
|
||
}
|
||
|
||
if (
|
||
changed.trClass &&
|
||
tr_class_value !==
|
||
(tr_class_value =
|
||
"" + null_to_empty(ctx.trClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(tr, "class", tr_class_value)
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(tr)
|
||
}
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
|
||
dispose()
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_each_block$4.name,
|
||
type: "each",
|
||
source: "(29:8) {#each data as row}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$9(ctx) {
|
||
var table,
|
||
thead,
|
||
tr,
|
||
tr_class_value,
|
||
thead_class_value,
|
||
t,
|
||
tbody,
|
||
tbody_class_value,
|
||
table_class_value
|
||
|
||
let each_value_2 = ctx.columns
|
||
|
||
let each_blocks_1 = []
|
||
|
||
for (let i = 0; i < each_value_2.length; i += 1) {
|
||
each_blocks_1[i] = create_each_block_2(
|
||
get_each_context_2(ctx, each_value_2, i)
|
||
)
|
||
}
|
||
|
||
let each_value = ctx.data
|
||
|
||
let each_blocks = []
|
||
|
||
for (let i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block$4(
|
||
get_each_context$4(ctx, each_value, i)
|
||
)
|
||
}
|
||
|
||
const block = {
|
||
c: function create() {
|
||
table = element("table")
|
||
thead = element("thead")
|
||
tr = element("tr")
|
||
|
||
for (let i = 0; i < each_blocks_1.length; i += 1) {
|
||
each_blocks_1[i].c()
|
||
}
|
||
|
||
t = space()
|
||
tbody = element("tbody")
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c()
|
||
}
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
table = claim_element(nodes, "TABLE", { class: true }, false)
|
||
var table_nodes = children(table)
|
||
|
||
thead = claim_element(table_nodes, "THEAD", { class: true }, false)
|
||
var thead_nodes = children(thead)
|
||
|
||
tr = claim_element(thead_nodes, "TR", { class: true }, false)
|
||
var tr_nodes = children(tr)
|
||
|
||
for (let i = 0; i < each_blocks_1.length; i += 1) {
|
||
each_blocks_1[i].l(tr_nodes)
|
||
}
|
||
|
||
tr_nodes.forEach(detach_dev)
|
||
thead_nodes.forEach(detach_dev)
|
||
t = claim_space(table_nodes)
|
||
|
||
tbody = claim_element(table_nodes, "TBODY", { class: true }, false)
|
||
var tbody_nodes = children(tbody)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].l(tbody_nodes)
|
||
}
|
||
|
||
tbody_nodes.forEach(detach_dev)
|
||
table_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(
|
||
tr,
|
||
"class",
|
||
(tr_class_value = "" + null_to_empty(ctx.trClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(tr, file$9, 21, 8, 382)
|
||
attr_dev(
|
||
thead,
|
||
"class",
|
||
(thead_class_value =
|
||
"" + null_to_empty(ctx.theadClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(thead, file$9, 20, 4, 346)
|
||
attr_dev(
|
||
tbody,
|
||
"class",
|
||
(tbody_class_value =
|
||
"" + null_to_empty(ctx.tbodyClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(tbody, file$9, 27, 4, 544)
|
||
attr_dev(
|
||
table,
|
||
"class",
|
||
(table_class_value =
|
||
"" + null_to_empty(ctx.tableClass) + " svelte-h8rqk6")
|
||
)
|
||
add_location(table, file$9, 19, 1, 314)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, table, anchor)
|
||
append_dev(table, thead)
|
||
append_dev(thead, tr)
|
||
|
||
for (let i = 0; i < each_blocks_1.length; i += 1) {
|
||
each_blocks_1[i].m(tr, null)
|
||
}
|
||
|
||
append_dev(table, t)
|
||
append_dev(table, tbody)
|
||
|
||
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(tbody, null)
|
||
}
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.thClass || changed.columns) {
|
||
each_value_2 = ctx.columns
|
||
|
||
let i
|
||
for (i = 0; i < each_value_2.length; i += 1) {
|
||
const child_ctx = get_each_context_2(ctx, each_value_2, i)
|
||
|
||
if (each_blocks_1[i]) {
|
||
each_blocks_1[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks_1[i] = create_each_block_2(child_ctx)
|
||
each_blocks_1[i].c()
|
||
each_blocks_1[i].m(tr, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks_1.length; i += 1) {
|
||
each_blocks_1[i].d(1)
|
||
}
|
||
each_blocks_1.length = each_value_2.length
|
||
}
|
||
|
||
if (
|
||
changed.trClass &&
|
||
tr_class_value !==
|
||
(tr_class_value =
|
||
"" + null_to_empty(ctx.trClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(tr, "class", tr_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.theadClass &&
|
||
thead_class_value !==
|
||
(thead_class_value =
|
||
"" + null_to_empty(ctx.theadClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(thead, "class", thead_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.trClass ||
|
||
changed.columns ||
|
||
changed.thClass ||
|
||
changed._bb ||
|
||
changed.data
|
||
) {
|
||
each_value = ctx.data
|
||
|
||
let i
|
||
for (i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context$4(ctx, each_value, i)
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx)
|
||
} else {
|
||
each_blocks[i] = create_each_block$4(child_ctx)
|
||
each_blocks[i].c()
|
||
each_blocks[i].m(tbody, null)
|
||
}
|
||
}
|
||
|
||
for (; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].d(1)
|
||
}
|
||
each_blocks.length = each_value.length
|
||
}
|
||
|
||
if (
|
||
changed.tbodyClass &&
|
||
tbody_class_value !==
|
||
(tbody_class_value =
|
||
"" + null_to_empty(ctx.tbodyClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(tbody, "class", tbody_class_value)
|
||
}
|
||
|
||
if (
|
||
changed.tableClass &&
|
||
table_class_value !==
|
||
(table_class_value =
|
||
"" + null_to_empty(ctx.tableClass) + " svelte-h8rqk6")
|
||
) {
|
||
attr_dev(table, "class", table_class_value)
|
||
}
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(table)
|
||
}
|
||
|
||
destroy_each(each_blocks_1, detaching)
|
||
|
||
destroy_each(each_blocks, detaching)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$9.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$9($$self, $$props, $$invalidate) {
|
||
let {
|
||
columns = [],
|
||
data = "",
|
||
tableClass = "",
|
||
theadClass = "",
|
||
tbodyClass = "",
|
||
trClass = "",
|
||
thClass = "",
|
||
onRowClick,
|
||
_bb,
|
||
} = $$props
|
||
|
||
const rowClickHandler = row => () => {
|
||
onRowClick(row)
|
||
}
|
||
|
||
const writable_props = [
|
||
"columns",
|
||
"data",
|
||
"tableClass",
|
||
"theadClass",
|
||
"tbodyClass",
|
||
"trClass",
|
||
"thClass",
|
||
"onRowClick",
|
||
"_bb",
|
||
]
|
||
Object.keys($$props).forEach(key => {
|
||
if (!writable_props.includes(key) && !key.startsWith("$$"))
|
||
console.warn(`<Table> was created with unknown prop '${key}'`)
|
||
})
|
||
|
||
$$self.$set = $$props => {
|
||
if ("columns" in $$props)
|
||
$$invalidate("columns", (columns = $$props.columns))
|
||
if ("data" in $$props) $$invalidate("data", (data = $$props.data))
|
||
if ("tableClass" in $$props)
|
||
$$invalidate("tableClass", (tableClass = $$props.tableClass))
|
||
if ("theadClass" in $$props)
|
||
$$invalidate("theadClass", (theadClass = $$props.theadClass))
|
||
if ("tbodyClass" in $$props)
|
||
$$invalidate("tbodyClass", (tbodyClass = $$props.tbodyClass))
|
||
if ("trClass" in $$props)
|
||
$$invalidate("trClass", (trClass = $$props.trClass))
|
||
if ("thClass" in $$props)
|
||
$$invalidate("thClass", (thClass = $$props.thClass))
|
||
if ("onRowClick" in $$props)
|
||
$$invalidate("onRowClick", (onRowClick = $$props.onRowClick))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {
|
||
columns,
|
||
data,
|
||
tableClass,
|
||
theadClass,
|
||
tbodyClass,
|
||
trClass,
|
||
thClass,
|
||
onRowClick,
|
||
_bb,
|
||
}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("columns" in $$props)
|
||
$$invalidate("columns", (columns = $$props.columns))
|
||
if ("data" in $$props) $$invalidate("data", (data = $$props.data))
|
||
if ("tableClass" in $$props)
|
||
$$invalidate("tableClass", (tableClass = $$props.tableClass))
|
||
if ("theadClass" in $$props)
|
||
$$invalidate("theadClass", (theadClass = $$props.theadClass))
|
||
if ("tbodyClass" in $$props)
|
||
$$invalidate("tbodyClass", (tbodyClass = $$props.tbodyClass))
|
||
if ("trClass" in $$props)
|
||
$$invalidate("trClass", (trClass = $$props.trClass))
|
||
if ("thClass" in $$props)
|
||
$$invalidate("thClass", (thClass = $$props.thClass))
|
||
if ("onRowClick" in $$props)
|
||
$$invalidate("onRowClick", (onRowClick = $$props.onRowClick))
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
}
|
||
|
||
return {
|
||
columns,
|
||
data,
|
||
tableClass,
|
||
theadClass,
|
||
tbodyClass,
|
||
trClass,
|
||
thClass,
|
||
onRowClick,
|
||
_bb,
|
||
rowClickHandler,
|
||
}
|
||
}
|
||
|
||
class Table extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$9, create_fragment$9, safe_not_equal, [
|
||
"columns",
|
||
"data",
|
||
"tableClass",
|
||
"theadClass",
|
||
"tbodyClass",
|
||
"trClass",
|
||
"thClass",
|
||
"onRowClick",
|
||
"_bb",
|
||
])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Table",
|
||
options,
|
||
id: create_fragment$9.name,
|
||
})
|
||
|
||
const { ctx } = this.$$
|
||
const props = options.props || {}
|
||
if (ctx.onRowClick === undefined && !("onRowClick" in props)) {
|
||
console.warn("<Table> was created without expected prop 'onRowClick'")
|
||
}
|
||
if (ctx._bb === undefined && !("_bb" in props)) {
|
||
console.warn("<Table> was created without expected prop '_bb'")
|
||
}
|
||
}
|
||
|
||
get columns() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set columns(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get data() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set data(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get tableClass() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set tableClass(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get theadClass() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set theadClass(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get tbodyClass() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set tbodyClass(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get trClass() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set trClass(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get thClass() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set thClass(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get onRowClick() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set onRowClick(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
get _bb() {
|
||
throw new Error(
|
||
"<Table>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
|
||
set _bb(value) {
|
||
throw new Error(
|
||
"<Table>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"
|
||
)
|
||
}
|
||
}
|
||
|
||
var commonjsGlobal =
|
||
typeof globalThis !== "undefined"
|
||
? globalThis
|
||
: typeof window !== "undefined"
|
||
? window
|
||
: typeof global !== "undefined"
|
||
? global
|
||
: typeof self !== "undefined"
|
||
? self
|
||
: {}
|
||
|
||
function createCommonjsModule(fn, module) {
|
||
return (
|
||
(module = { exports: {} }), fn(module, module.exports), module.exports
|
||
)
|
||
}
|
||
|
||
var lodash_min = createCommonjsModule(function(module, exports) {
|
||
;(function() {
|
||
function n(n, t, r) {
|
||
switch (r.length) {
|
||
case 0:
|
||
return n.call(t)
|
||
case 1:
|
||
return n.call(t, r[0])
|
||
case 2:
|
||
return n.call(t, r[0], r[1])
|
||
case 3:
|
||
return n.call(t, r[0], r[1], r[2])
|
||
}
|
||
return n.apply(t, r)
|
||
}
|
||
function t(n, t, r, e) {
|
||
for (var u = -1, i = null == n ? 0 : n.length; ++u < i; ) {
|
||
var o = n[u]
|
||
t(e, o, r(o), n)
|
||
}
|
||
return e
|
||
}
|
||
function r(n, t) {
|
||
for (
|
||
var r = -1, e = null == n ? 0 : n.length;
|
||
++r < e && false !== t(n[r], r, n);
|
||
|
||
);
|
||
return n
|
||
}
|
||
function e(n, t) {
|
||
for (
|
||
var r = null == n ? 0 : n.length;
|
||
r-- && false !== t(n[r], r, n);
|
||
|
||
);
|
||
return n
|
||
}
|
||
function u(n, t) {
|
||
for (var r = -1, e = null == n ? 0 : n.length; ++r < e; )
|
||
if (!t(n[r], r, n)) return false
|
||
return true
|
||
}
|
||
function i(n, t) {
|
||
for (
|
||
var r = -1, e = null == n ? 0 : n.length, u = 0, i = [];
|
||
++r < e;
|
||
|
||
) {
|
||
var o = n[r]
|
||
t(o, r, n) && (i[u++] = o)
|
||
}
|
||
return i
|
||
}
|
||
function o(n, t) {
|
||
return !(null == n || !n.length) && -1 < v(n, t, 0)
|
||
}
|
||
function f(n, t, r) {
|
||
for (var e = -1, u = null == n ? 0 : n.length; ++e < u; )
|
||
if (r(t, n[e])) return true
|
||
return false
|
||
}
|
||
function c(n, t) {
|
||
for (var r = -1, e = null == n ? 0 : n.length, u = Array(e); ++r < e; )
|
||
u[r] = t(n[r], r, n)
|
||
return u
|
||
}
|
||
function a(n, t) {
|
||
for (var r = -1, e = t.length, u = n.length; ++r < e; ) n[u + r] = t[r]
|
||
return n
|
||
}
|
||
function l(n, t, r, e) {
|
||
var u = -1,
|
||
i = null == n ? 0 : n.length
|
||
for (e && i && (r = n[++u]); ++u < i; ) r = t(r, n[u], u, n)
|
||
return r
|
||
}
|
||
function s(n, t, r, e) {
|
||
var u = null == n ? 0 : n.length
|
||
for (e && u && (r = n[--u]); u--; ) r = t(r, n[u], u, n)
|
||
return r
|
||
}
|
||
function h(n, t) {
|
||
for (var r = -1, e = null == n ? 0 : n.length; ++r < e; )
|
||
if (t(n[r], r, n)) return true
|
||
return false
|
||
}
|
||
function p(n, t, r) {
|
||
var e
|
||
return (
|
||
r(n, function(n, r, u) {
|
||
if (t(n, r, u)) return (e = r), false
|
||
}),
|
||
e
|
||
)
|
||
}
|
||
function _(n, t, r, e) {
|
||
var u = n.length
|
||
for (r += e ? 1 : -1; e ? r-- : ++r < u; ) if (t(n[r], r, n)) return r
|
||
return -1
|
||
}
|
||
function v(n, t, r) {
|
||
if (t === t)
|
||
n: {
|
||
--r
|
||
for (var e = n.length; ++r < e; )
|
||
if (n[r] === t) {
|
||
n = r
|
||
break n
|
||
}
|
||
n = -1
|
||
}
|
||
else n = _(n, d, r)
|
||
return n
|
||
}
|
||
function g(n, t, r, e) {
|
||
--r
|
||
for (var u = n.length; ++r < u; ) if (e(n[r], t)) return r
|
||
return -1
|
||
}
|
||
function d(n) {
|
||
return n !== n
|
||
}
|
||
function y(n, t) {
|
||
var r = null == n ? 0 : n.length
|
||
return r ? m(n, t) / r : F
|
||
}
|
||
function b(n) {
|
||
return function(t) {
|
||
return null == t ? T : t[n]
|
||
}
|
||
}
|
||
function x(n) {
|
||
return function(t) {
|
||
return null == n ? T : n[t]
|
||
}
|
||
}
|
||
function j(n, t, r, e, u) {
|
||
return (
|
||
u(n, function(n, u, i) {
|
||
r = e ? ((e = false), n) : t(r, n, u, i)
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function w(n, t) {
|
||
var r = n.length
|
||
for (n.sort(t); r--; ) n[r] = n[r].c
|
||
return n
|
||
}
|
||
function m(n, t) {
|
||
for (var r, e = -1, u = n.length; ++e < u; ) {
|
||
var i = t(n[e])
|
||
i !== T && (r = r === T ? i : r + i)
|
||
}
|
||
return r
|
||
}
|
||
function A(n, t) {
|
||
for (var r = -1, e = Array(n); ++r < n; ) e[r] = t(r)
|
||
return e
|
||
}
|
||
function E(n, t) {
|
||
return c(t, function(t) {
|
||
return [t, n[t]]
|
||
})
|
||
}
|
||
function k(n) {
|
||
return function(t) {
|
||
return n(t)
|
||
}
|
||
}
|
||
function S(n, t) {
|
||
return c(t, function(t) {
|
||
return n[t]
|
||
})
|
||
}
|
||
function O(n, t) {
|
||
return n.has(t)
|
||
}
|
||
function I(n, t) {
|
||
for (var r = -1, e = n.length; ++r < e && -1 < v(t, n[r], 0); );
|
||
return r
|
||
}
|
||
function R(n, t) {
|
||
for (var r = n.length; r-- && -1 < v(t, n[r], 0); );
|
||
return r
|
||
}
|
||
function z(n) {
|
||
return "\\" + Un[n]
|
||
}
|
||
function W(n) {
|
||
var t = -1,
|
||
r = Array(n.size)
|
||
return (
|
||
n.forEach(function(n, e) {
|
||
r[++t] = [e, n]
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function B(n, t) {
|
||
return function(r) {
|
||
return n(t(r))
|
||
}
|
||
}
|
||
function L(n, t) {
|
||
for (var r = -1, e = n.length, u = 0, i = []; ++r < e; ) {
|
||
var o = n[r]
|
||
;(o !== t && "__lodash_placeholder__" !== o) ||
|
||
((n[r] = "__lodash_placeholder__"), (i[u++] = r))
|
||
}
|
||
return i
|
||
}
|
||
function U(n) {
|
||
var t = -1,
|
||
r = Array(n.size)
|
||
return (
|
||
n.forEach(function(n) {
|
||
r[++t] = n
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function C(n) {
|
||
var t = -1,
|
||
r = Array(n.size)
|
||
return (
|
||
n.forEach(function(n) {
|
||
r[++t] = [n, n]
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function D(n) {
|
||
if (Rn.test(n)) {
|
||
for (var t = (On.lastIndex = 0); On.test(n); ) ++t
|
||
n = t
|
||
} else n = Qn(n)
|
||
return n
|
||
}
|
||
function M(n) {
|
||
return Rn.test(n) ? n.match(On) || [] : n.split("")
|
||
}
|
||
var T,
|
||
$ = 1 / 0,
|
||
F = NaN,
|
||
N = [
|
||
["ary", 128],
|
||
["bind", 1],
|
||
["bindKey", 2],
|
||
["curry", 8],
|
||
["curryRight", 16],
|
||
["flip", 512],
|
||
["partial", 32],
|
||
["partialRight", 64],
|
||
["rearg", 256],
|
||
],
|
||
P = /\b__p\+='';/g,
|
||
Z = /\b(__p\+=)''\+/g,
|
||
q = /(__e\(.*?\)|\b__t\))\+'';/g,
|
||
V = /&(?:amp|lt|gt|quot|#39);/g,
|
||
K = /[&<>"']/g,
|
||
G = RegExp(V.source),
|
||
H = RegExp(K.source),
|
||
J = /<%-([\s\S]+?)%>/g,
|
||
Y = /<%([\s\S]+?)%>/g,
|
||
Q = /<%=([\s\S]+?)%>/g,
|
||
X = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
|
||
nn = /^\w*$/,
|
||
tn = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,
|
||
rn = /[\\^$.*+?()[\]{}|]/g,
|
||
en = RegExp(rn.source),
|
||
un = /^\s+|\s+$/g,
|
||
on = /^\s+/,
|
||
fn = /\s+$/,
|
||
cn = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
|
||
an = /\{\n\/\* \[wrapped with (.+)\] \*/,
|
||
ln = /,? & /,
|
||
sn = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,
|
||
hn = /\\(\\)?/g,
|
||
pn = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,
|
||
_n = /\w*$/,
|
||
vn = /^[-+]0x[0-9a-f]+$/i,
|
||
gn = /^0b[01]+$/i,
|
||
dn = /^\[object .+?Constructor\]$/,
|
||
yn = /^0o[0-7]+$/i,
|
||
bn = /^(?:0|[1-9]\d*)$/,
|
||
xn = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,
|
||
jn = /($^)/,
|
||
wn = /['\n\r\u2028\u2029\\]/g,
|
||
mn =
|
||
"[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?(?:\\u200d(?:[^\\ud800-\\udfff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?)*",
|
||
An =
|
||
"(?:[\\u2700-\\u27bf]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])" +
|
||
mn,
|
||
En =
|
||
"(?:[^\\ud800-\\udfff][\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]?|[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff])",
|
||
kn = RegExp("['\u2019]", "g"),
|
||
Sn = RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]", "g"),
|
||
On = RegExp(
|
||
"\\ud83c[\\udffb-\\udfff](?=\\ud83c[\\udffb-\\udfff])|" + En + mn,
|
||
"g"
|
||
),
|
||
In = RegExp(
|
||
[
|
||
"[A-Z\\xc0-\\xd6\\xd8-\\xde]?[a-z\\xdf-\\xf6\\xf8-\\xff]+(?:['\u2019](?:d|ll|m|re|s|t|ve))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\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]|[A-Z\\xc0-\\xd6\\xd8-\\xde]|$)|(?:[A-Z\\xc0-\\xd6\\xd8-\\xde]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\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\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\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]|[A-Z\\xc0-\\xd6\\xd8-\\xde](?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\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\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])|$)|[A-Z\\xc0-\\xd6\\xd8-\\xde]?(?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\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\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:d|ll|m|re|s|t|ve))?|[A-Z\\xc0-\\xd6\\xd8-\\xde]+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?|\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])|\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])|\\d+",
|
||
An,
|
||
].join("|"),
|
||
"g"
|
||
),
|
||
Rn = RegExp(
|
||
"[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]"
|
||
),
|
||
zn = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,
|
||
Wn = "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".split(
|
||
" "
|
||
),
|
||
Bn = {}
|
||
;(Bn["[object Float32Array]"] = Bn["[object Float64Array]"] = Bn[
|
||
"[object Int8Array]"
|
||
] = Bn["[object Int16Array]"] = Bn["[object Int32Array]"] = Bn[
|
||
"[object Uint8Array]"
|
||
] = Bn["[object Uint8ClampedArray]"] = Bn["[object Uint16Array]"] = Bn[
|
||
"[object Uint32Array]"
|
||
] = true),
|
||
(Bn["[object Arguments]"] = Bn["[object Array]"] = Bn[
|
||
"[object ArrayBuffer]"
|
||
] = Bn["[object Boolean]"] = Bn["[object DataView]"] = Bn[
|
||
"[object Date]"
|
||
] = Bn["[object Error]"] = Bn["[object Function]"] = Bn[
|
||
"[object Map]"
|
||
] = Bn["[object Number]"] = Bn["[object Object]"] = Bn[
|
||
"[object RegExp]"
|
||
] = Bn["[object Set]"] = Bn["[object String]"] = Bn[
|
||
"[object WeakMap]"
|
||
] = false)
|
||
var Ln = {}
|
||
;(Ln["[object Arguments]"] = Ln["[object Array]"] = Ln[
|
||
"[object ArrayBuffer]"
|
||
] = Ln["[object DataView]"] = Ln["[object Boolean]"] = Ln[
|
||
"[object Date]"
|
||
] = Ln["[object Float32Array]"] = Ln["[object Float64Array]"] = Ln[
|
||
"[object Int8Array]"
|
||
] = Ln["[object Int16Array]"] = Ln["[object Int32Array]"] = Ln[
|
||
"[object Map]"
|
||
] = Ln["[object Number]"] = Ln["[object Object]"] = Ln[
|
||
"[object RegExp]"
|
||
] = Ln["[object Set]"] = Ln["[object String]"] = Ln[
|
||
"[object Symbol]"
|
||
] = Ln["[object Uint8Array]"] = Ln["[object Uint8ClampedArray]"] = Ln[
|
||
"[object Uint16Array]"
|
||
] = Ln["[object Uint32Array]"] = true),
|
||
(Ln["[object Error]"] = Ln["[object Function]"] = Ln[
|
||
"[object WeakMap]"
|
||
] = false)
|
||
var Un = {
|
||
"\\": "\\",
|
||
"'": "'",
|
||
"\n": "n",
|
||
"\r": "r",
|
||
"\u2028": "u2028",
|
||
"\u2029": "u2029",
|
||
},
|
||
Cn = parseFloat,
|
||
Dn = parseInt,
|
||
Mn =
|
||
typeof commonjsGlobal == "object" &&
|
||
commonjsGlobal &&
|
||
commonjsGlobal.Object === Object &&
|
||
commonjsGlobal,
|
||
Tn = typeof self == "object" && self && self.Object === Object && self,
|
||
$n = Mn || Tn || Function("return this")(),
|
||
Fn = exports && !exports.nodeType && exports,
|
||
Nn = Fn && "object" == "object" && module && !module.nodeType && module,
|
||
Pn = Nn && Nn.exports === Fn,
|
||
Zn = Pn && Mn.process,
|
||
qn = (function() {
|
||
try {
|
||
var n = Nn && Nn.f && Nn.f("util").types
|
||
return n ? n : Zn && Zn.binding && Zn.binding("util")
|
||
} catch (n) {}
|
||
})(),
|
||
Vn = qn && qn.isArrayBuffer,
|
||
Kn = qn && qn.isDate,
|
||
Gn = qn && qn.isMap,
|
||
Hn = qn && qn.isRegExp,
|
||
Jn = qn && qn.isSet,
|
||
Yn = qn && qn.isTypedArray,
|
||
Qn = b("length"),
|
||
Xn = x({
|
||
À: "A",
|
||
Á: "A",
|
||
Â: "A",
|
||
Ã: "A",
|
||
Ä: "A",
|
||
Å: "A",
|
||
à: "a",
|
||
á: "a",
|
||
â: "a",
|
||
ã: "a",
|
||
ä: "a",
|
||
å: "a",
|
||
Ç: "C",
|
||
ç: "c",
|
||
Ð: "D",
|
||
ð: "d",
|
||
È: "E",
|
||
É: "E",
|
||
Ê: "E",
|
||
Ë: "E",
|
||
è: "e",
|
||
é: "e",
|
||
ê: "e",
|
||
ë: "e",
|
||
Ì: "I",
|
||
Í: "I",
|
||
Î: "I",
|
||
Ï: "I",
|
||
ì: "i",
|
||
í: "i",
|
||
î: "i",
|
||
ï: "i",
|
||
Ñ: "N",
|
||
ñ: "n",
|
||
Ò: "O",
|
||
Ó: "O",
|
||
Ô: "O",
|
||
Õ: "O",
|
||
Ö: "O",
|
||
Ø: "O",
|
||
ò: "o",
|
||
ó: "o",
|
||
ô: "o",
|
||
õ: "o",
|
||
ö: "o",
|
||
ø: "o",
|
||
Ù: "U",
|
||
Ú: "U",
|
||
Û: "U",
|
||
Ü: "U",
|
||
ù: "u",
|
||
ú: "u",
|
||
û: "u",
|
||
ü: "u",
|
||
Ý: "Y",
|
||
ý: "y",
|
||
ÿ: "y",
|
||
Æ: "Ae",
|
||
æ: "ae",
|
||
Þ: "Th",
|
||
þ: "th",
|
||
ß: "ss",
|
||
Ā: "A",
|
||
Ă: "A",
|
||
Ą: "A",
|
||
ā: "a",
|
||
ă: "a",
|
||
ą: "a",
|
||
Ć: "C",
|
||
Ĉ: "C",
|
||
Ċ: "C",
|
||
Č: "C",
|
||
ć: "c",
|
||
ĉ: "c",
|
||
ċ: "c",
|
||
č: "c",
|
||
Ď: "D",
|
||
Đ: "D",
|
||
ď: "d",
|
||
đ: "d",
|
||
Ē: "E",
|
||
Ĕ: "E",
|
||
Ė: "E",
|
||
Ę: "E",
|
||
Ě: "E",
|
||
ē: "e",
|
||
ĕ: "e",
|
||
ė: "e",
|
||
ę: "e",
|
||
ě: "e",
|
||
Ĝ: "G",
|
||
Ğ: "G",
|
||
Ġ: "G",
|
||
Ģ: "G",
|
||
ĝ: "g",
|
||
ğ: "g",
|
||
ġ: "g",
|
||
ģ: "g",
|
||
Ĥ: "H",
|
||
Ħ: "H",
|
||
ĥ: "h",
|
||
ħ: "h",
|
||
Ĩ: "I",
|
||
Ī: "I",
|
||
Ĭ: "I",
|
||
Į: "I",
|
||
İ: "I",
|
||
ĩ: "i",
|
||
ī: "i",
|
||
ĭ: "i",
|
||
į: "i",
|
||
ı: "i",
|
||
Ĵ: "J",
|
||
ĵ: "j",
|
||
Ķ: "K",
|
||
ķ: "k",
|
||
ĸ: "k",
|
||
Ĺ: "L",
|
||
Ļ: "L",
|
||
Ľ: "L",
|
||
Ŀ: "L",
|
||
Ł: "L",
|
||
ĺ: "l",
|
||
ļ: "l",
|
||
ľ: "l",
|
||
ŀ: "l",
|
||
ł: "l",
|
||
Ń: "N",
|
||
Ņ: "N",
|
||
Ň: "N",
|
||
Ŋ: "N",
|
||
ń: "n",
|
||
ņ: "n",
|
||
ň: "n",
|
||
ŋ: "n",
|
||
Ō: "O",
|
||
Ŏ: "O",
|
||
Ő: "O",
|
||
ō: "o",
|
||
ŏ: "o",
|
||
ő: "o",
|
||
Ŕ: "R",
|
||
Ŗ: "R",
|
||
Ř: "R",
|
||
ŕ: "r",
|
||
ŗ: "r",
|
||
ř: "r",
|
||
Ś: "S",
|
||
Ŝ: "S",
|
||
Ş: "S",
|
||
Š: "S",
|
||
ś: "s",
|
||
ŝ: "s",
|
||
ş: "s",
|
||
š: "s",
|
||
Ţ: "T",
|
||
Ť: "T",
|
||
Ŧ: "T",
|
||
ţ: "t",
|
||
ť: "t",
|
||
ŧ: "t",
|
||
Ũ: "U",
|
||
Ū: "U",
|
||
Ŭ: "U",
|
||
Ů: "U",
|
||
Ű: "U",
|
||
Ų: "U",
|
||
ũ: "u",
|
||
ū: "u",
|
||
ŭ: "u",
|
||
ů: "u",
|
||
ű: "u",
|
||
ų: "u",
|
||
Ŵ: "W",
|
||
ŵ: "w",
|
||
Ŷ: "Y",
|
||
ŷ: "y",
|
||
Ÿ: "Y",
|
||
Ź: "Z",
|
||
Ż: "Z",
|
||
Ž: "Z",
|
||
ź: "z",
|
||
ż: "z",
|
||
ž: "z",
|
||
IJ: "IJ",
|
||
ij: "ij",
|
||
Œ: "Oe",
|
||
œ: "oe",
|
||
ʼn: "'n",
|
||
ſ: "s",
|
||
}),
|
||
nt = x({
|
||
"&": "&",
|
||
"<": "<",
|
||
">": ">",
|
||
'"': """,
|
||
"'": "'",
|
||
}),
|
||
tt = x({
|
||
"&": "&",
|
||
"<": "<",
|
||
">": ">",
|
||
""": '"',
|
||
"'": "'",
|
||
}),
|
||
rt = (function x(mn) {
|
||
function An(n) {
|
||
if (yu(n) && !ff(n) && !(n instanceof Un)) {
|
||
if (n instanceof On) return n
|
||
if (oi.call(n, "__wrapped__")) return Fe(n)
|
||
}
|
||
return new On(n)
|
||
}
|
||
function En() {}
|
||
function On(n, t) {
|
||
;(this.__wrapped__ = n),
|
||
(this.__actions__ = []),
|
||
(this.__chain__ = !!t),
|
||
(this.__index__ = 0),
|
||
(this.__values__ = T)
|
||
}
|
||
function Un(n) {
|
||
;(this.__wrapped__ = n),
|
||
(this.__actions__ = []),
|
||
(this.__dir__ = 1),
|
||
(this.__filtered__ = false),
|
||
(this.__iteratees__ = []),
|
||
(this.__takeCount__ = 4294967295),
|
||
(this.__views__ = [])
|
||
}
|
||
function Mn(n) {
|
||
var t = -1,
|
||
r = null == n ? 0 : n.length
|
||
for (this.clear(); ++t < r; ) {
|
||
var e = n[t]
|
||
this.set(e[0], e[1])
|
||
}
|
||
}
|
||
function Tn(n) {
|
||
var t = -1,
|
||
r = null == n ? 0 : n.length
|
||
for (this.clear(); ++t < r; ) {
|
||
var e = n[t]
|
||
this.set(e[0], e[1])
|
||
}
|
||
}
|
||
function Fn(n) {
|
||
var t = -1,
|
||
r = null == n ? 0 : n.length
|
||
for (this.clear(); ++t < r; ) {
|
||
var e = n[t]
|
||
this.set(e[0], e[1])
|
||
}
|
||
}
|
||
function Nn(n) {
|
||
var t = -1,
|
||
r = null == n ? 0 : n.length
|
||
for (this.__data__ = new Fn(); ++t < r; ) this.add(n[t])
|
||
}
|
||
function Zn(n) {
|
||
this.size = (this.__data__ = new Tn(n)).size
|
||
}
|
||
function qn(n, t) {
|
||
var r,
|
||
e = ff(n),
|
||
u = !e && of(n),
|
||
i = !e && !u && af(n),
|
||
o = !e && !u && !i && _f(n),
|
||
u = (e = e || u || i || o) ? A(n.length, ni) : [],
|
||
f = u.length
|
||
for (r in n)
|
||
(!t && !oi.call(n, r)) ||
|
||
(e &&
|
||
("length" == r ||
|
||
(i && ("offset" == r || "parent" == r)) ||
|
||
(o &&
|
||
("buffer" == r ||
|
||
"byteLength" == r ||
|
||
"byteOffset" == r)) ||
|
||
Se(r, f))) ||
|
||
u.push(r)
|
||
return u
|
||
}
|
||
function Qn(n) {
|
||
var t = n.length
|
||
return t ? n[ir(0, t - 1)] : T
|
||
}
|
||
function et(n, t) {
|
||
return De(Ur(n), pt(t, 0, n.length))
|
||
}
|
||
function ut(n) {
|
||
return De(Ur(n))
|
||
}
|
||
function it(n, t, r) {
|
||
;((r === T || lu(n[t], r)) && (r !== T || t in n)) || st(n, t, r)
|
||
}
|
||
function ot(n, t, r) {
|
||
var e = n[t]
|
||
;(oi.call(n, t) && lu(e, r) && (r !== T || t in n)) || st(n, t, r)
|
||
}
|
||
function ft(n, t) {
|
||
for (var r = n.length; r--; ) if (lu(n[r][0], t)) return r
|
||
return -1
|
||
}
|
||
function ct(n, t, r, e) {
|
||
return (
|
||
uo(n, function(n, u, i) {
|
||
t(e, n, r(n), i)
|
||
}),
|
||
e
|
||
)
|
||
}
|
||
function at(n, t) {
|
||
return n && Cr(t, Wu(t), n)
|
||
}
|
||
function lt(n, t) {
|
||
return n && Cr(t, Bu(t), n)
|
||
}
|
||
function st(n, t, r) {
|
||
"__proto__" == t && Ai
|
||
? Ai(n, t, {
|
||
configurable: true,
|
||
enumerable: true,
|
||
value: r,
|
||
writable: true,
|
||
})
|
||
: (n[t] = r)
|
||
}
|
||
function ht(n, t) {
|
||
for (var r = -1, e = t.length, u = Ku(e), i = null == n; ++r < e; )
|
||
u[r] = i ? T : Ru(n, t[r])
|
||
return u
|
||
}
|
||
function pt(n, t, r) {
|
||
return (
|
||
n === n &&
|
||
(r !== T && (n = n <= r ? n : r),
|
||
t !== T && (n = n >= t ? n : t)),
|
||
n
|
||
)
|
||
}
|
||
function _t(n, t, e, u, i, o) {
|
||
var f,
|
||
c = 1 & t,
|
||
a = 2 & t,
|
||
l = 4 & t
|
||
if ((e && (f = i ? e(n, u, i, o) : e(n)), f !== T)) return f
|
||
if (!du(n)) return n
|
||
if ((u = ff(n))) {
|
||
if (((f = me(n)), !c)) return Ur(n, f)
|
||
} else {
|
||
var s = vo(n),
|
||
h =
|
||
"[object Function]" == s || "[object GeneratorFunction]" == s
|
||
if (af(n)) return Ir(n, c)
|
||
if (
|
||
"[object Object]" == s ||
|
||
"[object Arguments]" == s ||
|
||
(h && !i)
|
||
) {
|
||
if (((f = a || h ? {} : Ae(n)), !c))
|
||
return a ? Mr(n, lt(f, n)) : Dr(n, at(f, n))
|
||
} else {
|
||
if (!Ln[s]) return i ? n : {}
|
||
f = Ee(n, s, c)
|
||
}
|
||
}
|
||
if ((o || (o = new Zn()), (i = o.get(n)))) return i
|
||
o.set(n, f),
|
||
pf(n)
|
||
? n.forEach(function(r) {
|
||
f.add(_t(r, t, e, r, n, o))
|
||
})
|
||
: sf(n) &&
|
||
n.forEach(function(r, u) {
|
||
f.set(u, _t(r, t, e, u, n, o))
|
||
})
|
||
var a = l ? (a ? ve : _e) : a ? Bu : Wu,
|
||
p = u ? T : a(n)
|
||
return (
|
||
r(p || n, function(r, u) {
|
||
p && ((u = r), (r = n[u])), ot(f, u, _t(r, t, e, u, n, o))
|
||
}),
|
||
f
|
||
)
|
||
}
|
||
function vt(n) {
|
||
var t = Wu(n)
|
||
return function(r) {
|
||
return gt(r, n, t)
|
||
}
|
||
}
|
||
function gt(n, t, r) {
|
||
var e = r.length
|
||
if (null == n) return !e
|
||
for (n = Qu(n); e--; ) {
|
||
var u = r[e],
|
||
i = t[u],
|
||
o = n[u]
|
||
if ((o === T && !(u in n)) || !i(o)) return false
|
||
}
|
||
return true
|
||
}
|
||
function dt(n, t, r) {
|
||
if (typeof n != "function") throw new ti("Expected a function")
|
||
return bo(function() {
|
||
n.apply(T, r)
|
||
}, t)
|
||
}
|
||
function yt(n, t, r, e) {
|
||
var u = -1,
|
||
i = o,
|
||
a = true,
|
||
l = n.length,
|
||
s = [],
|
||
h = t.length
|
||
if (!l) return s
|
||
r && (t = c(t, k(r))),
|
||
e
|
||
? ((i = f), (a = false))
|
||
: 200 <= t.length && ((i = O), (a = false), (t = new Nn(t)))
|
||
n: for (; ++u < l; ) {
|
||
var p = n[u],
|
||
_ = null == r ? p : r(p),
|
||
p = e || 0 !== p ? p : 0
|
||
if (a && _ === _) {
|
||
for (var v = h; v--; ) if (t[v] === _) continue n
|
||
s.push(p)
|
||
} else i(t, _, e) || s.push(p)
|
||
}
|
||
return s
|
||
}
|
||
function bt(n, t) {
|
||
var r = true
|
||
return (
|
||
uo(n, function(n, e, u) {
|
||
return (r = !!t(n, e, u))
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function xt(n, t, r) {
|
||
for (var e = -1, u = n.length; ++e < u; ) {
|
||
var i = n[e],
|
||
o = t(i)
|
||
if (null != o && (f === T ? o === o && !wu(o) : r(o, f)))
|
||
var f = o,
|
||
c = i
|
||
}
|
||
return c
|
||
}
|
||
function jt(n, t) {
|
||
var r = []
|
||
return (
|
||
uo(n, function(n, e, u) {
|
||
t(n, e, u) && r.push(n)
|
||
}),
|
||
r
|
||
)
|
||
}
|
||
function wt(n, t, r, e, u) {
|
||
var i = -1,
|
||
o = n.length
|
||
for (r || (r = ke), u || (u = []); ++i < o; ) {
|
||
var f = n[i]
|
||
0 < t && r(f)
|
||
? 1 < t
|
||
? wt(f, t - 1, r, e, u)
|
||
: a(u, f)
|
||
: e || (u[u.length] = f)
|
||
}
|
||
return u
|
||
}
|
||
function mt(n, t) {
|
||
return n && oo(n, t, Wu)
|
||
}
|
||
function At(n, t) {
|
||
return n && fo(n, t, Wu)
|
||
}
|
||
function Et(n, t) {
|
||
return i(t, function(t) {
|
||
return _u(n[t])
|
||
})
|
||
}
|
||
function kt(n, t) {
|
||
t = Sr(t, n)
|
||
for (var r = 0, e = t.length; null != n && r < e; )
|
||
n = n[Me(t[r++])]
|
||
return r && r == e ? n : T
|
||
}
|
||
function St(n, t, r) {
|
||
return (t = t(n)), ff(n) ? t : a(t, r(n))
|
||
}
|
||
function Ot(n) {
|
||
if (null == n) n = n === T ? "[object Undefined]" : "[object Null]"
|
||
else if (mi && mi in Qu(n)) {
|
||
var t = oi.call(n, mi),
|
||
r = n[mi]
|
||
try {
|
||
n[mi] = T
|
||
var e = true
|
||
} catch (n) {}
|
||
var u = ai.call(n)
|
||
e && (t ? (n[mi] = r) : delete n[mi]), (n = u)
|
||
} else n = ai.call(n)
|
||
return n
|
||
}
|
||
function It(n, t) {
|
||
return n > t
|
||
}
|
||
function Rt(n, t) {
|
||
return null != n && oi.call(n, t)
|
||
}
|
||
function zt(n, t) {
|
||
return null != n && t in Qu(n)
|
||
}
|
||
function Wt(n, t, r) {
|
||
for (
|
||
var e = r ? f : o,
|
||
u = n[0].length,
|
||
i = n.length,
|
||
a = i,
|
||
l = Ku(i),
|
||
s = 1 / 0,
|
||
h = [];
|
||
a--;
|
||
|
||
) {
|
||
var p = n[a]
|
||
a && t && (p = c(p, k(t))),
|
||
(s = Ci(p.length, s)),
|
||
(l[a] =
|
||
!r && (t || (120 <= u && 120 <= p.length))
|
||
? new Nn(a && p)
|
||
: T)
|
||
}
|
||
var p = n[0],
|
||
_ = -1,
|
||
v = l[0]
|
||
n: for (; ++_ < u && h.length < s; ) {
|
||
var g = p[_],
|
||
d = t ? t(g) : g,
|
||
g = r || 0 !== g ? g : 0
|
||
if (v ? !O(v, d) : !e(h, d, r)) {
|
||
for (a = i; --a; ) {
|
||
var y = l[a]
|
||
if (y ? !O(y, d) : !e(n[a], d, r)) continue n
|
||
}
|
||
v && v.push(d), h.push(g)
|
||
}
|
||
}
|
||
return h
|
||
}
|
||
function Bt(n, t, r) {
|
||
var e = {}
|
||
return (
|
||
mt(n, function(n, u, i) {
|
||
t(e, r(n), u, i)
|
||
}),
|
||
e
|
||
)
|
||
}
|
||
function Lt(t, r, e) {
|
||
return (
|
||
(r = Sr(r, t)),
|
||
(t = 2 > r.length ? t : kt(t, hr(r, 0, -1))),
|
||
(r = null == t ? t : t[Me(Ve(r))]),
|
||
null == r ? T : n(r, t, e)
|
||
)
|
||
}
|
||
function Ut(n) {
|
||
return yu(n) && "[object Arguments]" == Ot(n)
|
||
}
|
||
function Ct(n) {
|
||
return yu(n) && "[object ArrayBuffer]" == Ot(n)
|
||
}
|
||
function Dt(n) {
|
||
return yu(n) && "[object Date]" == Ot(n)
|
||
}
|
||
function Mt(n, t, r, e, u) {
|
||
if (n === t) t = true
|
||
else if (null == n || null == t || (!yu(n) && !yu(t)))
|
||
t = n !== n && t !== t
|
||
else
|
||
n: {
|
||
var i = ff(n),
|
||
o = ff(t),
|
||
f = i ? "[object Array]" : vo(n),
|
||
c = o ? "[object Array]" : vo(t),
|
||
f = "[object Arguments]" == f ? "[object Object]" : f,
|
||
c = "[object Arguments]" == c ? "[object Object]" : c,
|
||
a = "[object Object]" == f,
|
||
o = "[object Object]" == c
|
||
if ((c = f == c) && af(n)) {
|
||
if (!af(t)) {
|
||
t = false
|
||
break n
|
||
}
|
||
;(i = true), (a = false)
|
||
}
|
||
if (c && !a)
|
||
u || (u = new Zn()),
|
||
(t =
|
||
i || _f(n)
|
||
? se(n, t, r, e, Mt, u)
|
||
: he(n, t, f, r, e, Mt, u))
|
||
else {
|
||
if (
|
||
!(1 & r) &&
|
||
((i = a && oi.call(n, "__wrapped__")),
|
||
(f = o && oi.call(t, "__wrapped__")),
|
||
i || f)
|
||
) {
|
||
;(n = i ? n.value() : n),
|
||
(t = f ? t.value() : t),
|
||
u || (u = new Zn()),
|
||
(t = Mt(n, t, r, e, u))
|
||
break n
|
||
}
|
||
if (c)
|
||
t: if (
|
||
(u || (u = new Zn()),
|
||
(i = 1 & r),
|
||
(f = _e(n)),
|
||
(o = f.length),
|
||
(c = _e(t).length),
|
||
o == c || i)
|
||
) {
|
||
for (a = o; a--; ) {
|
||
var l = f[a]
|
||
if (!(i ? l in t : oi.call(t, l))) {
|
||
t = false
|
||
break t
|
||
}
|
||
}
|
||
if ((c = u.get(n)) && u.get(t)) t = c == t
|
||
else {
|
||
;(c = true), u.set(n, t), u.set(t, n)
|
||
for (var s = i; ++a < o; ) {
|
||
var l = f[a],
|
||
h = n[l],
|
||
p = t[l]
|
||
if (e)
|
||
var _ = i
|
||
? e(p, h, l, t, n, u)
|
||
: e(h, p, l, n, t, u)
|
||
if (_ === T ? h !== p && !Mt(h, p, r, e, u) : !_) {
|
||
c = false
|
||
break
|
||
}
|
||
s || (s = "constructor" == l)
|
||
}
|
||
c &&
|
||
!s &&
|
||
((r = n.constructor),
|
||
(e = t.constructor),
|
||
r != e &&
|
||
"constructor" in n &&
|
||
"constructor" in t &&
|
||
!(
|
||
typeof r == "function" &&
|
||
r instanceof r &&
|
||
typeof e == "function" &&
|
||
e instanceof e
|
||
) &&
|
||
(c = false)),
|
||
u.delete(n),
|
||
u.delete(t),
|
||
(t = c)
|
||
}
|
||
} else t = false
|
||
else t = false
|
||
}
|
||
}
|
||
return t
|
||
}
|
||
function Tt(n) {
|
||
return yu(n) && "[object Map]" == vo(n)
|
||
}
|
||
function $t(n, t, r, e) {
|
||
var u = r.length,
|
||
i = u,
|
||
o = !e
|
||
if (null == n) return !i
|
||
for (n = Qu(n); u--; ) {
|
||
var f = r[u]
|
||
if (o && f[2] ? f[1] !== n[f[0]] : !(f[0] in n)) return false
|
||
}
|
||
for (; ++u < i; ) {
|
||
var f = r[u],
|
||
c = f[0],
|
||
a = n[c],
|
||
l = f[1]
|
||
if (o && f[2]) {
|
||
if (a === T && !(c in n)) return false
|
||
} else {
|
||
if (((f = new Zn()), e)) var s = e(a, l, c, n, t, f)
|
||
if (s === T ? !Mt(l, a, 3, e, f) : !s) return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
function Ft(n) {
|
||
return !(!du(n) || (ci && ci in n)) && (_u(n) ? hi : dn).test(Te(n))
|
||
}
|
||
function Nt(n) {
|
||
return yu(n) && "[object RegExp]" == Ot(n)
|
||
}
|
||
function Pt(n) {
|
||
return yu(n) && "[object Set]" == vo(n)
|
||
}
|
||
function Zt(n) {
|
||
return yu(n) && gu(n.length) && !!Bn[Ot(n)]
|
||
}
|
||
function qt(n) {
|
||
return typeof n == "function"
|
||
? n
|
||
: null == n
|
||
? $u
|
||
: typeof n == "object"
|
||
? ff(n)
|
||
? Jt(n[0], n[1])
|
||
: Ht(n)
|
||
: Zu(n)
|
||
}
|
||
function Vt(n) {
|
||
if (!ze(n)) return Li(n)
|
||
var t,
|
||
r = []
|
||
for (t in Qu(n)) oi.call(n, t) && "constructor" != t && r.push(t)
|
||
return r
|
||
}
|
||
function Kt(n, t) {
|
||
return n < t
|
||
}
|
||
function Gt(n, t) {
|
||
var r = -1,
|
||
e = su(n) ? Ku(n.length) : []
|
||
return (
|
||
uo(n, function(n, u, i) {
|
||
e[++r] = t(n, u, i)
|
||
}),
|
||
e
|
||
)
|
||
}
|
||
function Ht(n) {
|
||
var t = xe(n)
|
||
return 1 == t.length && t[0][2]
|
||
? We(t[0][0], t[0][1])
|
||
: function(r) {
|
||
return r === n || $t(r, n, t)
|
||
}
|
||
}
|
||
function Jt(n, t) {
|
||
return Ie(n) && t === t && !du(t)
|
||
? We(Me(n), t)
|
||
: function(r) {
|
||
var e = Ru(r, n)
|
||
return e === T && e === t ? zu(r, n) : Mt(t, e, 3)
|
||
}
|
||
}
|
||
function Yt(n, t, r, e, u) {
|
||
n !== t &&
|
||
oo(
|
||
t,
|
||
function(i, o) {
|
||
if ((u || (u = new Zn()), du(i))) {
|
||
var f = u,
|
||
c = Le(n, o),
|
||
a = Le(t, o),
|
||
l = f.get(a)
|
||
if (l) it(n, o, l)
|
||
else {
|
||
var l = e ? e(c, a, o + "", n, t, f) : T,
|
||
s = l === T
|
||
if (s) {
|
||
var h = ff(a),
|
||
p = !h && af(a),
|
||
_ = !h && !p && _f(a),
|
||
l = a
|
||
h || p || _
|
||
? ff(c)
|
||
? (l = c)
|
||
: hu(c)
|
||
? (l = Ur(c))
|
||
: p
|
||
? ((s = false), (l = Ir(a, true)))
|
||
: _
|
||
? ((s = false), (l = zr(a, true)))
|
||
: (l = [])
|
||
: xu(a) || of(a)
|
||
? ((l = c),
|
||
of(c)
|
||
? (l = Ou(c))
|
||
: (du(c) && !_u(c)) || (l = Ae(a)))
|
||
: (s = false)
|
||
}
|
||
s && (f.set(a, l), Yt(l, a, r, e, f), f.delete(a)),
|
||
it(n, o, l)
|
||
}
|
||
} else
|
||
(f = e ? e(Le(n, o), i, o + "", n, t, u) : T),
|
||
f === T && (f = i),
|
||
it(n, o, f)
|
||
},
|
||
Bu
|
||
)
|
||
}
|
||
function Qt(n, t) {
|
||
var r = n.length
|
||
if (r) return (t += 0 > t ? r : 0), Se(t, r) ? n[t] : T
|
||
}
|
||
function Xt(n, t, r) {
|
||
var e = -1
|
||
return (
|
||
(t = c(t.length ? t : [$u], k(ye()))),
|
||
(n = Gt(n, function(n) {
|
||
return {
|
||
a: c(t, function(t) {
|
||
return t(n)
|
||
}),
|
||
b: ++e,
|
||
c: n,
|
||
}
|
||
})),
|
||
w(n, function(n, t) {
|
||
var e
|
||
n: {
|
||
e = -1
|
||
for (
|
||
var u = n.a, i = t.a, o = u.length, f = r.length;
|
||
++e < o;
|
||
|
||
) {
|
||
var c = Wr(u[e], i[e])
|
||
if (c) {
|
||
e = e >= f ? c : c * ("desc" == r[e] ? -1 : 1)
|
||
break n
|
||
}
|
||
}
|
||
e = n.b - t.b
|
||
}
|
||
return e
|
||
})
|
||
)
|
||
}
|
||
function nr(n, t) {
|
||
return tr(n, t, function(t, r) {
|
||
return zu(n, r)
|
||
})
|
||
}
|
||
function tr(n, t, r) {
|
||
for (var e = -1, u = t.length, i = {}; ++e < u; ) {
|
||
var o = t[e],
|
||
f = kt(n, o)
|
||
r(f, o) && lr(i, Sr(o, n), f)
|
||
}
|
||
return i
|
||
}
|
||
function rr(n) {
|
||
return function(t) {
|
||
return kt(t, n)
|
||
}
|
||
}
|
||
function er(n, t, r, e) {
|
||
var u = e ? g : v,
|
||
i = -1,
|
||
o = t.length,
|
||
f = n
|
||
for (n === t && (t = Ur(t)), r && (f = c(n, k(r))); ++i < o; )
|
||
for (
|
||
var a = 0, l = t[i], l = r ? r(l) : l;
|
||
-1 < (a = u(f, l, a, e));
|
||
|
||
)
|
||
f !== n && xi.call(f, a, 1), xi.call(n, a, 1)
|
||
return n
|
||
}
|
||
function ur(n, t) {
|
||
for (var r = n ? t.length : 0, e = r - 1; r--; ) {
|
||
var u = t[r]
|
||
if (r == e || u !== i) {
|
||
var i = u
|
||
Se(u) ? xi.call(n, u, 1) : xr(n, u)
|
||
}
|
||
}
|
||
}
|
||
function ir(n, t) {
|
||
return n + Ii(Ti() * (t - n + 1))
|
||
}
|
||
function or(n, t) {
|
||
var r = ""
|
||
if (!n || 1 > t || 9007199254740991 < t) return r
|
||
do t % 2 && (r += n), (t = Ii(t / 2)) && (n += n)
|
||
while (t)
|
||
return r
|
||
}
|
||
function fr(n, t) {
|
||
return xo(Be(n, t, $u), n + "")
|
||
}
|
||
function cr(n) {
|
||
return Qn(Uu(n))
|
||
}
|
||
function ar(n, t) {
|
||
var r = Uu(n)
|
||
return De(r, pt(t, 0, r.length))
|
||
}
|
||
function lr(n, t, r, e) {
|
||
if (!du(n)) return n
|
||
t = Sr(t, n)
|
||
for (
|
||
var u = -1, i = t.length, o = i - 1, f = n;
|
||
null != f && ++u < i;
|
||
|
||
) {
|
||
var c = Me(t[u]),
|
||
a = r
|
||
if (u != o) {
|
||
var l = f[c],
|
||
a = e ? e(l, c, f) : T
|
||
a === T && (a = du(l) ? l : Se(t[u + 1]) ? [] : {})
|
||
}
|
||
ot(f, c, a), (f = f[c])
|
||
}
|
||
return n
|
||
}
|
||
function sr(n) {
|
||
return De(Uu(n))
|
||
}
|
||
function hr(n, t, r) {
|
||
var e = -1,
|
||
u = n.length
|
||
for (
|
||
0 > t && (t = -t > u ? 0 : u + t),
|
||
r = r > u ? u : r,
|
||
0 > r && (r += u),
|
||
u = t > r ? 0 : (r - t) >>> 0,
|
||
t >>>= 0,
|
||
r = Ku(u);
|
||
++e < u;
|
||
|
||
)
|
||
r[e] = n[e + t]
|
||
return r
|
||
}
|
||
function pr(n, t) {
|
||
var r
|
||
return (
|
||
uo(n, function(n, e, u) {
|
||
return (r = t(n, e, u)), !r
|
||
}),
|
||
!!r
|
||
)
|
||
}
|
||
function _r(n, t, r) {
|
||
var e = 0,
|
||
u = null == n ? e : n.length
|
||
if (typeof t == "number" && t === t && 2147483647 >= u) {
|
||
for (; e < u; ) {
|
||
var i = (e + u) >>> 1,
|
||
o = n[i]
|
||
null !== o && !wu(o) && (r ? o <= t : o < t)
|
||
? (e = i + 1)
|
||
: (u = i)
|
||
}
|
||
return u
|
||
}
|
||
return vr(n, t, $u, r)
|
||
}
|
||
function vr(n, t, r, e) {
|
||
t = r(t)
|
||
for (
|
||
var u = 0,
|
||
i = null == n ? 0 : n.length,
|
||
o = t !== t,
|
||
f = null === t,
|
||
c = wu(t),
|
||
a = t === T;
|
||
u < i;
|
||
|
||
) {
|
||
var l = Ii((u + i) / 2),
|
||
s = r(n[l]),
|
||
h = s !== T,
|
||
p = null === s,
|
||
_ = s === s,
|
||
v = wu(s)
|
||
;(o
|
||
? e || _
|
||
: a
|
||
? _ && (e || h)
|
||
: f
|
||
? _ && h && (e || !p)
|
||
: c
|
||
? _ && h && !p && (e || !v)
|
||
: p || v
|
||
? 0
|
||
: e
|
||
? s <= t
|
||
: s < t)
|
||
? (u = l + 1)
|
||
: (i = l)
|
||
}
|
||
return Ci(i, 4294967294)
|
||
}
|
||
function gr(n, t) {
|
||
for (var r = -1, e = n.length, u = 0, i = []; ++r < e; ) {
|
||
var o = n[r],
|
||
f = t ? t(o) : o
|
||
if (!r || !lu(f, c)) {
|
||
var c = f
|
||
i[u++] = 0 === o ? 0 : o
|
||
}
|
||
}
|
||
return i
|
||
}
|
||
function dr(n) {
|
||
return typeof n == "number" ? n : wu(n) ? F : +n
|
||
}
|
||
function yr(n) {
|
||
if (typeof n == "string") return n
|
||
if (ff(n)) return c(n, yr) + ""
|
||
if (wu(n)) return ro ? ro.call(n) : ""
|
||
var t = n + ""
|
||
return "0" == t && 1 / n == -$ ? "-0" : t
|
||
}
|
||
function br(n, t, r) {
|
||
var e = -1,
|
||
u = o,
|
||
i = n.length,
|
||
c = true,
|
||
a = [],
|
||
l = a
|
||
if (r) (c = false), (u = f)
|
||
else if (200 <= i) {
|
||
if ((u = t ? null : so(n))) return U(u)
|
||
;(c = false), (u = O), (l = new Nn())
|
||
} else l = t ? [] : a
|
||
n: for (; ++e < i; ) {
|
||
var s = n[e],
|
||
h = t ? t(s) : s,
|
||
s = r || 0 !== s ? s : 0
|
||
if (c && h === h) {
|
||
for (var p = l.length; p--; ) if (l[p] === h) continue n
|
||
t && l.push(h), a.push(s)
|
||
} else u(l, h, r) || (l !== a && l.push(h), a.push(s))
|
||
}
|
||
return a
|
||
}
|
||
function xr(n, t) {
|
||
return (
|
||
(t = Sr(t, n)),
|
||
(n = 2 > t.length ? n : kt(n, hr(t, 0, -1))),
|
||
null == n || delete n[Me(Ve(t))]
|
||
)
|
||
}
|
||
function jr(n, t, r, e) {
|
||
for (
|
||
var u = n.length, i = e ? u : -1;
|
||
(e ? i-- : ++i < u) && t(n[i], i, n);
|
||
|
||
);
|
||
return r
|
||
? hr(n, e ? 0 : i, e ? i + 1 : u)
|
||
: hr(n, e ? i + 1 : 0, e ? u : i)
|
||
}
|
||
function wr(n, t) {
|
||
var r = n
|
||
return (
|
||
r instanceof Un && (r = r.value()),
|
||
l(
|
||
t,
|
||
function(n, t) {
|
||
return t.func.apply(t.thisArg, a([n], t.args))
|
||
},
|
||
r
|
||
)
|
||
)
|
||
}
|
||
function mr(n, t, r) {
|
||
var e = n.length
|
||
if (2 > e) return e ? br(n[0]) : []
|
||
for (var u = -1, i = Ku(e); ++u < e; )
|
||
for (var o = n[u], f = -1; ++f < e; )
|
||
f != u && (i[u] = yt(i[u] || o, n[f], t, r))
|
||
return br(wt(i, 1), t, r)
|
||
}
|
||
function Ar(n, t, r) {
|
||
for (var e = -1, u = n.length, i = t.length, o = {}; ++e < u; )
|
||
r(o, n[e], e < i ? t[e] : T)
|
||
return o
|
||
}
|
||
function Er(n) {
|
||
return hu(n) ? n : []
|
||
}
|
||
function kr(n) {
|
||
return typeof n == "function" ? n : $u
|
||
}
|
||
function Sr(n, t) {
|
||
return ff(n) ? n : Ie(n, t) ? [n] : jo(Iu(n))
|
||
}
|
||
function Or(n, t, r) {
|
||
var e = n.length
|
||
return (r = r === T ? e : r), !t && r >= e ? n : hr(n, t, r)
|
||
}
|
||
function Ir(n, t) {
|
||
if (t) return n.slice()
|
||
var r = n.length,
|
||
r = gi ? gi(r) : new n.constructor(r)
|
||
return n.copy(r), r
|
||
}
|
||
function Rr(n) {
|
||
var t = new n.constructor(n.byteLength)
|
||
return new vi(t).set(new vi(n)), t
|
||
}
|
||
function zr(n, t) {
|
||
return new n.constructor(
|
||
t ? Rr(n.buffer) : n.buffer,
|
||
n.byteOffset,
|
||
n.length
|
||
)
|
||
}
|
||
function Wr(n, t) {
|
||
if (n !== t) {
|
||
var r = n !== T,
|
||
e = null === n,
|
||
u = n === n,
|
||
i = wu(n),
|
||
o = t !== T,
|
||
f = null === t,
|
||
c = t === t,
|
||
a = wu(t)
|
||
if (
|
||
(!f && !a && !i && n > t) ||
|
||
(i && o && c && !f && !a) ||
|
||
(e && o && c) ||
|
||
(!r && c) ||
|
||
!u
|
||
)
|
||
return 1
|
||
if (
|
||
(!e && !i && !a && n < t) ||
|
||
(a && r && u && !e && !i) ||
|
||
(f && r && u) ||
|
||
(!o && u) ||
|
||
!c
|
||
)
|
||
return -1
|
||
}
|
||
return 0
|
||
}
|
||
function Br(n, t, r, e) {
|
||
var u = -1,
|
||
i = n.length,
|
||
o = r.length,
|
||
f = -1,
|
||
c = t.length,
|
||
a = Ui(i - o, 0),
|
||
l = Ku(c + a)
|
||
for (e = !e; ++f < c; ) l[f] = t[f]
|
||
for (; ++u < o; ) (e || u < i) && (l[r[u]] = n[u])
|
||
for (; a--; ) l[f++] = n[u++]
|
||
return l
|
||
}
|
||
function Lr(n, t, r, e) {
|
||
var u = -1,
|
||
i = n.length,
|
||
o = -1,
|
||
f = r.length,
|
||
c = -1,
|
||
a = t.length,
|
||
l = Ui(i - f, 0),
|
||
s = Ku(l + a)
|
||
for (e = !e; ++u < l; ) s[u] = n[u]
|
||
for (l = u; ++c < a; ) s[l + c] = t[c]
|
||
for (; ++o < f; ) (e || u < i) && (s[l + r[o]] = n[u++])
|
||
return s
|
||
}
|
||
function Ur(n, t) {
|
||
var r = -1,
|
||
e = n.length
|
||
for (t || (t = Ku(e)); ++r < e; ) t[r] = n[r]
|
||
return t
|
||
}
|
||
function Cr(n, t, r, e) {
|
||
var u = !r
|
||
r || (r = {})
|
||
for (var i = -1, o = t.length; ++i < o; ) {
|
||
var f = t[i],
|
||
c = e ? e(r[f], n[f], f, r, n) : T
|
||
c === T && (c = n[f]), u ? st(r, f, c) : ot(r, f, c)
|
||
}
|
||
return r
|
||
}
|
||
function Dr(n, t) {
|
||
return Cr(n, po(n), t)
|
||
}
|
||
function Mr(n, t) {
|
||
return Cr(n, _o(n), t)
|
||
}
|
||
function Tr(n, r) {
|
||
return function(e, u) {
|
||
var i = ff(e) ? t : ct,
|
||
o = r ? r() : {}
|
||
return i(e, n, ye(u, 2), o)
|
||
}
|
||
}
|
||
function $r(n) {
|
||
return fr(function(t, r) {
|
||
var e = -1,
|
||
u = r.length,
|
||
i = 1 < u ? r[u - 1] : T,
|
||
o = 2 < u ? r[2] : T,
|
||
i = 3 < n.length && typeof i == "function" ? (u--, i) : T
|
||
for (
|
||
o && Oe(r[0], r[1], o) && ((i = 3 > u ? T : i), (u = 1)),
|
||
t = Qu(t);
|
||
++e < u;
|
||
|
||
)
|
||
(o = r[e]) && n(t, o, e, i)
|
||
return t
|
||
})
|
||
}
|
||
function Fr(n, t) {
|
||
return function(r, e) {
|
||
if (null == r) return r
|
||
if (!su(r)) return n(r, e)
|
||
for (
|
||
var u = r.length, i = t ? u : -1, o = Qu(r);
|
||
(t ? i-- : ++i < u) && false !== e(o[i], i, o);
|
||
|
||
);
|
||
return r
|
||
}
|
||
}
|
||
function Nr(n) {
|
||
return function(t, r, e) {
|
||
var u = -1,
|
||
i = Qu(t)
|
||
e = e(t)
|
||
for (var o = e.length; o--; ) {
|
||
var f = e[n ? o : ++u]
|
||
if (false === r(i[f], f, i)) break
|
||
}
|
||
return t
|
||
}
|
||
}
|
||
function Pr(n, t, r) {
|
||
function e() {
|
||
return (this && this !== $n && this instanceof e ? i : n).apply(
|
||
u ? r : this,
|
||
arguments
|
||
)
|
||
}
|
||
var u = 1 & t,
|
||
i = Vr(n)
|
||
return e
|
||
}
|
||
function Zr(n) {
|
||
return function(t) {
|
||
t = Iu(t)
|
||
var r = Rn.test(t) ? M(t) : T,
|
||
e = r ? r[0] : t.charAt(0)
|
||
return (t = r ? Or(r, 1).join("") : t.slice(1)), e[n]() + t
|
||
}
|
||
}
|
||
function qr(n) {
|
||
return function(t) {
|
||
return l(Mu(Du(t).replace(kn, "")), n, "")
|
||
}
|
||
}
|
||
function Vr(n) {
|
||
return function() {
|
||
var t = arguments
|
||
switch (t.length) {
|
||
case 0:
|
||
return new n()
|
||
case 1:
|
||
return new n(t[0])
|
||
case 2:
|
||
return new n(t[0], t[1])
|
||
case 3:
|
||
return new n(t[0], t[1], t[2])
|
||
case 4:
|
||
return new n(t[0], t[1], t[2], t[3])
|
||
case 5:
|
||
return new n(t[0], t[1], t[2], t[3], t[4])
|
||
case 6:
|
||
return new n(t[0], t[1], t[2], t[3], t[4], t[5])
|
||
case 7:
|
||
return new n(t[0], t[1], t[2], t[3], t[4], t[5], t[6])
|
||
}
|
||
var r = eo(n.prototype),
|
||
t = n.apply(r, t)
|
||
return du(t) ? t : r
|
||
}
|
||
}
|
||
function Kr(t, r, e) {
|
||
function u() {
|
||
for (var o = arguments.length, f = Ku(o), c = o, a = de(u); c--; )
|
||
f[c] = arguments[c]
|
||
return (
|
||
(c = 3 > o && f[0] !== a && f[o - 1] !== a ? [] : L(f, a)),
|
||
(o -= c.length),
|
||
o < e
|
||
? ue(t, r, Jr, u.placeholder, T, f, c, T, T, e - o)
|
||
: n(this && this !== $n && this instanceof u ? i : t, this, f)
|
||
)
|
||
}
|
||
var i = Vr(t)
|
||
return u
|
||
}
|
||
function Gr(n) {
|
||
return function(t, r, e) {
|
||
var u = Qu(t)
|
||
if (!su(t)) {
|
||
var i = ye(r, 3)
|
||
;(t = Wu(t)),
|
||
(r = function(n) {
|
||
return i(u[n], n, u)
|
||
})
|
||
}
|
||
return (r = n(t, r, e)), -1 < r ? u[i ? t[r] : r] : T
|
||
}
|
||
}
|
||
function Hr(n) {
|
||
return pe(function(t) {
|
||
var r = t.length,
|
||
e = r,
|
||
u = On.prototype.thru
|
||
for (n && t.reverse(); e--; ) {
|
||
var i = t[e]
|
||
if (typeof i != "function") throw new ti("Expected a function")
|
||
if (u && !o && "wrapper" == ge(i)) var o = new On([], true)
|
||
}
|
||
for (e = o ? e : r; ++e < r; )
|
||
var i = t[e],
|
||
u = ge(i),
|
||
f = "wrapper" == u ? ho(i) : T,
|
||
o =
|
||
f && Re(f[0]) && 424 == f[1] && !f[4].length && 1 == f[9]
|
||
? o[ge(f[0])].apply(o, f[3])
|
||
: 1 == i.length && Re(i)
|
||
? o[u]()
|
||
: o.thru(i)
|
||
return function() {
|
||
var n = arguments,
|
||
e = n[0]
|
||
if (o && 1 == n.length && ff(e)) return o.plant(e).value()
|
||
for (var u = 0, n = r ? t[u].apply(this, n) : e; ++u < r; )
|
||
n = t[u].call(this, n)
|
||
return n
|
||
}
|
||
})
|
||
}
|
||
function Jr(n, t, r, e, u, i, o, f, c, a) {
|
||
function l() {
|
||
for (var d = arguments.length, y = Ku(d), b = d; b--; )
|
||
y[b] = arguments[b]
|
||
if (_) {
|
||
var x,
|
||
j = de(l),
|
||
b = y.length
|
||
for (x = 0; b--; ) y[b] === j && ++x
|
||
}
|
||
if (
|
||
(e && (y = Br(y, e, u, _)),
|
||
i && (y = Lr(y, i, o, _)),
|
||
(d -= x),
|
||
_ && d < a)
|
||
)
|
||
return (
|
||
(j = L(y, j)),
|
||
ue(n, t, Jr, l.placeholder, r, y, j, f, c, a - d)
|
||
)
|
||
if (((j = h ? r : this), (b = p ? j[n] : n), (d = y.length), f)) {
|
||
x = y.length
|
||
for (var w = Ci(f.length, x), m = Ur(y); w--; ) {
|
||
var A = f[w]
|
||
y[w] = Se(A, x) ? m[A] : T
|
||
}
|
||
} else v && 1 < d && y.reverse()
|
||
return (
|
||
s && c < d && (y.length = c),
|
||
this && this !== $n && this instanceof l && (b = g || Vr(b)),
|
||
b.apply(j, y)
|
||
)
|
||
}
|
||
var s = 128 & t,
|
||
h = 1 & t,
|
||
p = 2 & t,
|
||
_ = 24 & t,
|
||
v = 512 & t,
|
||
g = p ? T : Vr(n)
|
||
return l
|
||
}
|
||
function Yr(n, t) {
|
||
return function(r, e) {
|
||
return Bt(r, n, t(e))
|
||
}
|
||
}
|
||
function Qr(n, t) {
|
||
return function(r, e) {
|
||
var u
|
||
if (r === T && e === T) return t
|
||
if ((r !== T && (u = r), e !== T)) {
|
||
if (u === T) return e
|
||
typeof r == "string" || typeof e == "string"
|
||
? ((r = yr(r)), (e = yr(e)))
|
||
: ((r = dr(r)), (e = dr(e))),
|
||
(u = n(r, e))
|
||
}
|
||
return u
|
||
}
|
||
}
|
||
function Xr(t) {
|
||
return pe(function(r) {
|
||
return (
|
||
(r = c(r, k(ye()))),
|
||
fr(function(e) {
|
||
var u = this
|
||
return t(r, function(t) {
|
||
return n(t, u, e)
|
||
})
|
||
})
|
||
)
|
||
})
|
||
}
|
||
function ne(n, t) {
|
||
t = t === T ? " " : yr(t)
|
||
var r = t.length
|
||
return 2 > r
|
||
? r
|
||
? or(t, n)
|
||
: t
|
||
: ((r = or(t, Oi(n / D(t)))),
|
||
Rn.test(t) ? Or(M(r), 0, n).join("") : r.slice(0, n))
|
||
}
|
||
function te(t, r, e, u) {
|
||
function i() {
|
||
for (
|
||
var r = -1,
|
||
c = arguments.length,
|
||
a = -1,
|
||
l = u.length,
|
||
s = Ku(l + c),
|
||
h = this && this !== $n && this instanceof i ? f : t;
|
||
++a < l;
|
||
|
||
)
|
||
s[a] = u[a]
|
||
for (; c--; ) s[a++] = arguments[++r]
|
||
return n(h, o ? e : this, s)
|
||
}
|
||
var o = 1 & r,
|
||
f = Vr(t)
|
||
return i
|
||
}
|
||
function re(n) {
|
||
return function(t, r, e) {
|
||
e && typeof e != "number" && Oe(t, r, e) && (r = e = T),
|
||
(t = Au(t)),
|
||
r === T ? ((r = t), (t = 0)) : (r = Au(r)),
|
||
(e = e === T ? (t < r ? 1 : -1) : Au(e))
|
||
var u = -1
|
||
r = Ui(Oi((r - t) / (e || 1)), 0)
|
||
for (var i = Ku(r); r--; ) (i[n ? r : ++u] = t), (t += e)
|
||
return i
|
||
}
|
||
}
|
||
function ee(n) {
|
||
return function(t, r) {
|
||
return (
|
||
(typeof t == "string" && typeof r == "string") ||
|
||
((t = Su(t)), (r = Su(r))),
|
||
n(t, r)
|
||
)
|
||
}
|
||
}
|
||
function ue(n, t, r, e, u, i, o, f, c, a) {
|
||
var l = 8 & t,
|
||
s = l ? o : T
|
||
o = l ? T : o
|
||
var h = l ? i : T
|
||
return (
|
||
(i = l ? T : i),
|
||
(t = (t | (l ? 32 : 64)) & ~(l ? 64 : 32)),
|
||
4 & t || (t &= -4),
|
||
(u = [n, t, u, h, s, i, o, f, c, a]),
|
||
(r = r.apply(T, u)),
|
||
Re(n) && yo(r, u),
|
||
(r.placeholder = e),
|
||
Ue(r, n, t)
|
||
)
|
||
}
|
||
function ie(n) {
|
||
var t = Yu[n]
|
||
return function(n, r) {
|
||
if (
|
||
((n = Su(n)), (r = null == r ? 0 : Ci(Eu(r), 292)) && Wi(n))
|
||
) {
|
||
var e = (Iu(n) + "e").split("e"),
|
||
e = t(e[0] + "e" + (+e[1] + r)),
|
||
e = (Iu(e) + "e").split("e")
|
||
return +(e[0] + "e" + (+e[1] - r))
|
||
}
|
||
return t(n)
|
||
}
|
||
}
|
||
function oe(n) {
|
||
return function(t) {
|
||
var r = vo(t)
|
||
return "[object Map]" == r
|
||
? W(t)
|
||
: "[object Set]" == r
|
||
? C(t)
|
||
: E(t, n(t))
|
||
}
|
||
}
|
||
function fe(n, t, r, e, u, i, o, f) {
|
||
var c = 2 & t
|
||
if (!c && typeof n != "function")
|
||
throw new ti("Expected a function")
|
||
var a = e ? e.length : 0
|
||
if (
|
||
(a || ((t &= -97), (e = u = T)),
|
||
(o = o === T ? o : Ui(Eu(o), 0)),
|
||
(f = f === T ? f : Eu(f)),
|
||
(a -= u ? u.length : 0),
|
||
64 & t)
|
||
) {
|
||
var l = e,
|
||
s = u
|
||
e = u = T
|
||
}
|
||
var h = c ? T : ho(n)
|
||
return (
|
||
(i = [n, t, r, e, u, l, s, i, o, f]),
|
||
h &&
|
||
((r = i[1]),
|
||
(n = h[1]),
|
||
(t = r | n),
|
||
(e =
|
||
(128 == n && 8 == r) ||
|
||
(128 == n && 256 == r && i[7].length <= h[8]) ||
|
||
(384 == n && h[7].length <= h[8] && 8 == r)),
|
||
131 > t || e) &&
|
||
(1 & n && ((i[2] = h[2]), (t |= 1 & r ? 0 : 4)),
|
||
(r = h[3]) &&
|
||
((e = i[3]),
|
||
(i[3] = e ? Br(e, r, h[4]) : r),
|
||
(i[4] = e ? L(i[3], "__lodash_placeholder__") : h[4])),
|
||
(r = h[5]) &&
|
||
((e = i[5]),
|
||
(i[5] = e ? Lr(e, r, h[6]) : r),
|
||
(i[6] = e ? L(i[5], "__lodash_placeholder__") : h[6])),
|
||
(r = h[7]) && (i[7] = r),
|
||
128 & n && (i[8] = null == i[8] ? h[8] : Ci(i[8], h[8])),
|
||
null == i[9] && (i[9] = h[9]),
|
||
(i[0] = h[0]),
|
||
(i[1] = t)),
|
||
(n = i[0]),
|
||
(t = i[1]),
|
||
(r = i[2]),
|
||
(e = i[3]),
|
||
(u = i[4]),
|
||
(f = i[9] = i[9] === T ? (c ? 0 : n.length) : Ui(i[9] - a, 0)),
|
||
!f && 24 & t && (t &= -25),
|
||
Ue(
|
||
(h ? co : yo)(
|
||
t && 1 != t
|
||
? 8 == t || 16 == t
|
||
? Kr(n, t, f)
|
||
: (32 != t && 33 != t) || u.length
|
||
? Jr.apply(T, i)
|
||
: te(n, t, r, e)
|
||
: Pr(n, t, r),
|
||
i
|
||
),
|
||
n,
|
||
t
|
||
)
|
||
)
|
||
}
|
||
function ce(n, t, r, e) {
|
||
return n === T || (lu(n, ei[r]) && !oi.call(e, r)) ? t : n
|
||
}
|
||
function ae(n, t, r, e, u, i) {
|
||
return (
|
||
du(n) && du(t) && (i.set(t, n), Yt(n, t, T, ae, i), i.delete(t)),
|
||
n
|
||
)
|
||
}
|
||
function le(n) {
|
||
return xu(n) ? T : n
|
||
}
|
||
function se(n, t, r, e, u, i) {
|
||
var o = 1 & r,
|
||
f = n.length,
|
||
c = t.length
|
||
if (f != c && !(o && c > f)) return false
|
||
if ((c = i.get(n)) && i.get(t)) return c == t
|
||
var c = -1,
|
||
a = true,
|
||
l = 2 & r ? new Nn() : T
|
||
for (i.set(n, t), i.set(t, n); ++c < f; ) {
|
||
var s = n[c],
|
||
p = t[c]
|
||
if (e) var _ = o ? e(p, s, c, t, n, i) : e(s, p, c, n, t, i)
|
||
if (_ !== T) {
|
||
if (_) continue
|
||
a = false
|
||
break
|
||
}
|
||
if (l) {
|
||
if (
|
||
!h(t, function(n, t) {
|
||
if (!O(l, t) && (s === n || u(s, n, r, e, i)))
|
||
return l.push(t)
|
||
})
|
||
) {
|
||
a = false
|
||
break
|
||
}
|
||
} else if (s !== p && !u(s, p, r, e, i)) {
|
||
a = false
|
||
break
|
||
}
|
||
}
|
||
return i.delete(n), i.delete(t), a
|
||
}
|
||
function he(n, t, r, e, u, i, o) {
|
||
switch (r) {
|
||
case "[object DataView]":
|
||
if (
|
||
n.byteLength != t.byteLength ||
|
||
n.byteOffset != t.byteOffset
|
||
)
|
||
break
|
||
;(n = n.buffer), (t = t.buffer)
|
||
case "[object ArrayBuffer]":
|
||
if (n.byteLength != t.byteLength || !i(new vi(n), new vi(t)))
|
||
break
|
||
return true
|
||
case "[object Boolean]":
|
||
case "[object Date]":
|
||
case "[object Number]":
|
||
return lu(+n, +t)
|
||
case "[object Error]":
|
||
return n.name == t.name && n.message == t.message
|
||
case "[object RegExp]":
|
||
case "[object String]":
|
||
return n == t + ""
|
||
case "[object Map]":
|
||
var f = W
|
||
case "[object Set]":
|
||
if ((f || (f = U), n.size != t.size && !(1 & e))) break
|
||
return (r = o.get(n))
|
||
? r == t
|
||
: ((e |= 2),
|
||
o.set(n, t),
|
||
(t = se(f(n), f(t), e, u, i, o)),
|
||
o.delete(n),
|
||
t)
|
||
case "[object Symbol]":
|
||
if (to) return to.call(n) == to.call(t)
|
||
}
|
||
return false
|
||
}
|
||
function pe(n) {
|
||
return xo(Be(n, T, Ze), n + "")
|
||
}
|
||
function _e(n) {
|
||
return St(n, Wu, po)
|
||
}
|
||
function ve(n) {
|
||
return St(n, Bu, _o)
|
||
}
|
||
function ge(n) {
|
||
for (
|
||
var t = n.name + "", r = Gi[t], e = oi.call(Gi, t) ? r.length : 0;
|
||
e--;
|
||
|
||
) {
|
||
var u = r[e],
|
||
i = u.func
|
||
if (null == i || i == n) return u.name
|
||
}
|
||
return t
|
||
}
|
||
function de(n) {
|
||
return (oi.call(An, "placeholder") ? An : n).placeholder
|
||
}
|
||
function ye() {
|
||
var n = An.iteratee || Fu,
|
||
n = n === Fu ? qt : n
|
||
return arguments.length ? n(arguments[0], arguments[1]) : n
|
||
}
|
||
function be(n, t) {
|
||
var r = n.__data__,
|
||
e = typeof t
|
||
return ("string" == e ||
|
||
"number" == e ||
|
||
"symbol" == e ||
|
||
"boolean" == e
|
||
? "__proto__" !== t
|
||
: null === t)
|
||
? r[typeof t == "string" ? "string" : "hash"]
|
||
: r.map
|
||
}
|
||
function xe(n) {
|
||
for (var t = Wu(n), r = t.length; r--; ) {
|
||
var e = t[r],
|
||
u = n[e]
|
||
t[r] = [e, u, u === u && !du(u)]
|
||
}
|
||
return t
|
||
}
|
||
function je(n, t) {
|
||
var r = null == n ? T : n[t]
|
||
return Ft(r) ? r : T
|
||
}
|
||
function we(n, t, r) {
|
||
t = Sr(t, n)
|
||
for (var e = -1, u = t.length, i = false; ++e < u; ) {
|
||
var o = Me(t[e])
|
||
if (!(i = null != n && r(n, o))) break
|
||
n = n[o]
|
||
}
|
||
return i || ++e != u
|
||
? i
|
||
: ((u = null == n ? 0 : n.length),
|
||
!!u && gu(u) && Se(o, u) && (ff(n) || of(n)))
|
||
}
|
||
function me(n) {
|
||
var t = n.length,
|
||
r = new n.constructor(t)
|
||
return (
|
||
t &&
|
||
"string" == typeof n[0] &&
|
||
oi.call(n, "index") &&
|
||
((r.index = n.index), (r.input = n.input)),
|
||
r
|
||
)
|
||
}
|
||
function Ae(n) {
|
||
return typeof n.constructor != "function" || ze(n) ? {} : eo(di(n))
|
||
}
|
||
function Ee(n, t, r) {
|
||
var e = n.constructor
|
||
switch (t) {
|
||
case "[object ArrayBuffer]":
|
||
return Rr(n)
|
||
case "[object Boolean]":
|
||
case "[object Date]":
|
||
return new e(+n)
|
||
case "[object DataView]":
|
||
return (
|
||
(t = r ? Rr(n.buffer) : n.buffer),
|
||
new n.constructor(t, n.byteOffset, n.byteLength)
|
||
)
|
||
case "[object Float32Array]":
|
||
case "[object Float64Array]":
|
||
case "[object Int8Array]":
|
||
case "[object Int16Array]":
|
||
case "[object Int32Array]":
|
||
case "[object Uint8Array]":
|
||
case "[object Uint8ClampedArray]":
|
||
case "[object Uint16Array]":
|
||
case "[object Uint32Array]":
|
||
return zr(n, r)
|
||
case "[object Map]":
|
||
return new e()
|
||
case "[object Number]":
|
||
case "[object String]":
|
||
return new e(n)
|
||
case "[object RegExp]":
|
||
return (
|
||
(t = new n.constructor(n.source, _n.exec(n))),
|
||
(t.lastIndex = n.lastIndex),
|
||
t
|
||
)
|
||
case "[object Set]":
|
||
return new e()
|
||
case "[object Symbol]":
|
||
return to ? Qu(to.call(n)) : {}
|
||
}
|
||
}
|
||
function ke(n) {
|
||
return ff(n) || of(n) || !!(ji && n && n[ji])
|
||
}
|
||
function Se(n, t) {
|
||
var r = typeof n
|
||
return (
|
||
(t = null == t ? 9007199254740991 : t),
|
||
!!t &&
|
||
("number" == r || ("symbol" != r && bn.test(n))) &&
|
||
-1 < n &&
|
||
0 == n % 1 &&
|
||
n < t
|
||
)
|
||
}
|
||
function Oe(n, t, r) {
|
||
if (!du(r)) return false
|
||
var e = typeof t
|
||
return (
|
||
!!("number" == e
|
||
? su(r) && Se(t, r.length)
|
||
: "string" == e && t in r) && lu(r[t], n)
|
||
)
|
||
}
|
||
function Ie(n, t) {
|
||
if (ff(n)) return false
|
||
var r = typeof n
|
||
return (
|
||
!(
|
||
"number" != r &&
|
||
"symbol" != r &&
|
||
"boolean" != r &&
|
||
null != n &&
|
||
!wu(n)
|
||
) ||
|
||
nn.test(n) ||
|
||
!X.test(n) ||
|
||
(null != t && n in Qu(t))
|
||
)
|
||
}
|
||
function Re(n) {
|
||
var t = ge(n),
|
||
r = An[t]
|
||
return (
|
||
typeof r == "function" &&
|
||
t in Un.prototype &&
|
||
(n === r || ((t = ho(r)), !!t && n === t[0]))
|
||
)
|
||
}
|
||
function ze(n) {
|
||
var t = n && n.constructor
|
||
return n === ((typeof t == "function" && t.prototype) || ei)
|
||
}
|
||
function We(n, t) {
|
||
return function(r) {
|
||
return null != r && r[n] === t && (t !== T || n in Qu(r))
|
||
}
|
||
}
|
||
function Be(t, r, e) {
|
||
return (
|
||
(r = Ui(r === T ? t.length - 1 : r, 0)),
|
||
function() {
|
||
for (
|
||
var u = arguments, i = -1, o = Ui(u.length - r, 0), f = Ku(o);
|
||
++i < o;
|
||
|
||
)
|
||
f[i] = u[r + i]
|
||
for (i = -1, o = Ku(r + 1); ++i < r; ) o[i] = u[i]
|
||
return (o[r] = e(f)), n(t, this, o)
|
||
}
|
||
)
|
||
}
|
||
function Le(n, t) {
|
||
if (
|
||
("constructor" !== t || "function" != typeof n[t]) &&
|
||
"__proto__" != t
|
||
)
|
||
return n[t]
|
||
}
|
||
function Ue(n, t, r) {
|
||
var e = t + ""
|
||
t = xo
|
||
var u,
|
||
i = $e
|
||
return (
|
||
(u = (u = e.match(an)) ? u[1].split(ln) : []),
|
||
(r = i(u, r)),
|
||
(i = r.length) &&
|
||
((u = i - 1),
|
||
(r[u] = (1 < i ? "& " : "") + r[u]),
|
||
(r = r.join(2 < i ? ", " : " ")),
|
||
(e = e.replace(cn, "{\n/* [wrapped with " + r + "] */\n"))),
|
||
t(n, e)
|
||
)
|
||
}
|
||
function Ce(n) {
|
||
var t = 0,
|
||
r = 0
|
||
return function() {
|
||
var e = Di(),
|
||
u = 16 - (e - r)
|
||
if (((r = e), 0 < u)) {
|
||
if (800 <= ++t) return arguments[0]
|
||
} else t = 0
|
||
return n.apply(T, arguments)
|
||
}
|
||
}
|
||
function De(n, t) {
|
||
var r = -1,
|
||
e = n.length,
|
||
u = e - 1
|
||
for (t = t === T ? e : t; ++r < t; ) {
|
||
var e = ir(r, u),
|
||
i = n[e]
|
||
;(n[e] = n[r]), (n[r] = i)
|
||
}
|
||
return (n.length = t), n
|
||
}
|
||
function Me(n) {
|
||
if (typeof n == "string" || wu(n)) return n
|
||
var t = n + ""
|
||
return "0" == t && 1 / n == -$ ? "-0" : t
|
||
}
|
||
function Te(n) {
|
||
if (null != n) {
|
||
try {
|
||
return ii.call(n)
|
||
} catch (n) {}
|
||
return n + ""
|
||
}
|
||
return ""
|
||
}
|
||
function $e(n, t) {
|
||
return (
|
||
r(N, function(r) {
|
||
var e = "_." + r[0]
|
||
t & r[1] && !o(n, e) && n.push(e)
|
||
}),
|
||
n.sort()
|
||
)
|
||
}
|
||
function Fe(n) {
|
||
if (n instanceof Un) return n.clone()
|
||
var t = new On(n.__wrapped__, n.__chain__)
|
||
return (
|
||
(t.__actions__ = Ur(n.__actions__)),
|
||
(t.__index__ = n.__index__),
|
||
(t.__values__ = n.__values__),
|
||
t
|
||
)
|
||
}
|
||
function Ne(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? ((r = null == r ? 0 : Eu(r)),
|
||
0 > r && (r = Ui(e + r, 0)),
|
||
_(n, ye(t, 3), r))
|
||
: -1
|
||
}
|
||
function Pe(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
if (!e) return -1
|
||
var u = e - 1
|
||
return (
|
||
r !== T &&
|
||
((u = Eu(r)), (u = 0 > r ? Ui(e + u, 0) : Ci(u, e - 1))),
|
||
_(n, ye(t, 3), u, true)
|
||
)
|
||
}
|
||
function Ze(n) {
|
||
return (null == n ? 0 : n.length) ? wt(n, 1) : []
|
||
}
|
||
function qe(n) {
|
||
return n && n.length ? n[0] : T
|
||
}
|
||
function Ve(n) {
|
||
var t = null == n ? 0 : n.length
|
||
return t ? n[t - 1] : T
|
||
}
|
||
function Ke(n, t) {
|
||
return n && n.length && t && t.length ? er(n, t) : n
|
||
}
|
||
function Ge(n) {
|
||
return null == n ? n : $i.call(n)
|
||
}
|
||
function He(n) {
|
||
if (!n || !n.length) return []
|
||
var t = 0
|
||
return (
|
||
(n = i(n, function(n) {
|
||
if (hu(n)) return (t = Ui(n.length, t)), true
|
||
})),
|
||
A(t, function(t) {
|
||
return c(n, b(t))
|
||
})
|
||
)
|
||
}
|
||
function Je(t, r) {
|
||
if (!t || !t.length) return []
|
||
var e = He(t)
|
||
return null == r
|
||
? e
|
||
: c(e, function(t) {
|
||
return n(r, T, t)
|
||
})
|
||
}
|
||
function Ye(n) {
|
||
return (n = An(n)), (n.__chain__ = true), n
|
||
}
|
||
function Qe(n, t) {
|
||
return t(n)
|
||
}
|
||
function Xe() {
|
||
return this
|
||
}
|
||
function nu(n, t) {
|
||
return (ff(n) ? r : uo)(n, ye(t, 3))
|
||
}
|
||
function tu(n, t) {
|
||
return (ff(n) ? e : io)(n, ye(t, 3))
|
||
}
|
||
function ru(n, t) {
|
||
return (ff(n) ? c : Gt)(n, ye(t, 3))
|
||
}
|
||
function eu(n, t, r) {
|
||
return (
|
||
(t = r ? T : t),
|
||
(t = n && null == t ? n.length : t),
|
||
fe(n, 128, T, T, T, T, t)
|
||
)
|
||
}
|
||
function uu(n, t) {
|
||
var r
|
||
if (typeof t != "function") throw new ti("Expected a function")
|
||
return (
|
||
(n = Eu(n)),
|
||
function() {
|
||
return (
|
||
0 < --n && (r = t.apply(this, arguments)),
|
||
1 >= n && (t = T),
|
||
r
|
||
)
|
||
}
|
||
)
|
||
}
|
||
function iu(n, t, r) {
|
||
return (
|
||
(t = r ? T : t),
|
||
(n = fe(n, 8, T, T, T, T, T, t)),
|
||
(n.placeholder = iu.placeholder),
|
||
n
|
||
)
|
||
}
|
||
function ou(n, t, r) {
|
||
return (
|
||
(t = r ? T : t),
|
||
(n = fe(n, 16, T, T, T, T, T, t)),
|
||
(n.placeholder = ou.placeholder),
|
||
n
|
||
)
|
||
}
|
||
function fu(n, t, r) {
|
||
function e(t) {
|
||
var r = c,
|
||
e = a
|
||
return (c = a = T), (_ = t), (s = n.apply(e, r))
|
||
}
|
||
function u(n) {
|
||
var r = n - p
|
||
return (n -= _), p === T || r >= t || 0 > r || (g && n >= l)
|
||
}
|
||
function i() {
|
||
var n = Go()
|
||
if (u(n)) return o(n)
|
||
var r,
|
||
e = bo
|
||
;(r = n - _),
|
||
(n = t - (n - p)),
|
||
(r = g ? Ci(n, l - r) : n),
|
||
(h = e(i, r))
|
||
}
|
||
function o(n) {
|
||
return (h = T), d && c ? e(n) : ((c = a = T), s)
|
||
}
|
||
function f() {
|
||
var n = Go(),
|
||
r = u(n)
|
||
if (((c = arguments), (a = this), (p = n), r)) {
|
||
if (h === T) return (_ = n = p), (h = bo(i, t)), v ? e(n) : s
|
||
if (g) return lo(h), (h = bo(i, t)), e(p)
|
||
}
|
||
return h === T && (h = bo(i, t)), s
|
||
}
|
||
var c,
|
||
a,
|
||
l,
|
||
s,
|
||
h,
|
||
p,
|
||
_ = 0,
|
||
v = false,
|
||
g = false,
|
||
d = true
|
||
if (typeof n != "function") throw new ti("Expected a function")
|
||
return (
|
||
(t = Su(t) || 0),
|
||
du(r) &&
|
||
((v = !!r.leading),
|
||
(l = (g = "maxWait" in r) ? Ui(Su(r.maxWait) || 0, t) : l),
|
||
(d = "trailing" in r ? !!r.trailing : d)),
|
||
(f.cancel = function() {
|
||
h !== T && lo(h), (_ = 0), (c = p = a = h = T)
|
||
}),
|
||
(f.flush = function() {
|
||
return h === T ? s : o(Go())
|
||
}),
|
||
f
|
||
)
|
||
}
|
||
function cu(n, t) {
|
||
function r() {
|
||
var e = arguments,
|
||
u = t ? t.apply(this, e) : e[0],
|
||
i = r.cache
|
||
return i.has(u)
|
||
? i.get(u)
|
||
: ((e = n.apply(this, e)), (r.cache = i.set(u, e) || i), e)
|
||
}
|
||
if (typeof n != "function" || (null != t && typeof t != "function"))
|
||
throw new ti("Expected a function")
|
||
return (r.cache = new (cu.Cache || Fn)()), r
|
||
}
|
||
function au(n) {
|
||
if (typeof n != "function") throw new ti("Expected a function")
|
||
return function() {
|
||
var t = arguments
|
||
switch (t.length) {
|
||
case 0:
|
||
return !n.call(this)
|
||
case 1:
|
||
return !n.call(this, t[0])
|
||
case 2:
|
||
return !n.call(this, t[0], t[1])
|
||
case 3:
|
||
return !n.call(this, t[0], t[1], t[2])
|
||
}
|
||
return !n.apply(this, t)
|
||
}
|
||
}
|
||
function lu(n, t) {
|
||
return n === t || (n !== n && t !== t)
|
||
}
|
||
function su(n) {
|
||
return null != n && gu(n.length) && !_u(n)
|
||
}
|
||
function hu(n) {
|
||
return yu(n) && su(n)
|
||
}
|
||
function pu(n) {
|
||
if (!yu(n)) return false
|
||
var t = Ot(n)
|
||
return (
|
||
"[object Error]" == t ||
|
||
"[object DOMException]" == t ||
|
||
(typeof n.message == "string" &&
|
||
typeof n.name == "string" &&
|
||
!xu(n))
|
||
)
|
||
}
|
||
function _u(n) {
|
||
return (
|
||
!!du(n) &&
|
||
((n = Ot(n)),
|
||
"[object Function]" == n ||
|
||
"[object GeneratorFunction]" == n ||
|
||
"[object AsyncFunction]" == n ||
|
||
"[object Proxy]" == n)
|
||
)
|
||
}
|
||
function vu(n) {
|
||
return typeof n == "number" && n == Eu(n)
|
||
}
|
||
function gu(n) {
|
||
return (
|
||
typeof n == "number" &&
|
||
-1 < n &&
|
||
0 == n % 1 &&
|
||
9007199254740991 >= n
|
||
)
|
||
}
|
||
function du(n) {
|
||
var t = typeof n
|
||
return null != n && ("object" == t || "function" == t)
|
||
}
|
||
function yu(n) {
|
||
return null != n && typeof n == "object"
|
||
}
|
||
function bu(n) {
|
||
return typeof n == "number" || (yu(n) && "[object Number]" == Ot(n))
|
||
}
|
||
function xu(n) {
|
||
return (
|
||
!(!yu(n) || "[object Object]" != Ot(n)) &&
|
||
((n = di(n)),
|
||
null === n ||
|
||
((n = oi.call(n, "constructor") && n.constructor),
|
||
typeof n == "function" && n instanceof n && ii.call(n) == li))
|
||
)
|
||
}
|
||
function ju(n) {
|
||
return (
|
||
typeof n == "string" ||
|
||
(!ff(n) && yu(n) && "[object String]" == Ot(n))
|
||
)
|
||
}
|
||
function wu(n) {
|
||
return typeof n == "symbol" || (yu(n) && "[object Symbol]" == Ot(n))
|
||
}
|
||
function mu(n) {
|
||
if (!n) return []
|
||
if (su(n)) return ju(n) ? M(n) : Ur(n)
|
||
if (wi && n[wi]) {
|
||
n = n[wi]()
|
||
for (var t, r = []; !(t = n.next()).done; ) r.push(t.value)
|
||
return r
|
||
}
|
||
return (
|
||
(t = vo(n)),
|
||
("[object Map]" == t ? W : "[object Set]" == t ? U : Uu)(n)
|
||
)
|
||
}
|
||
function Au(n) {
|
||
return n
|
||
? ((n = Su(n)),
|
||
n === $ || n === -$
|
||
? 1.7976931348623157e308 * (0 > n ? -1 : 1)
|
||
: n === n
|
||
? n
|
||
: 0)
|
||
: 0 === n
|
||
? n
|
||
: 0
|
||
}
|
||
function Eu(n) {
|
||
n = Au(n)
|
||
var t = n % 1
|
||
return n === n ? (t ? n - t : n) : 0
|
||
}
|
||
function ku(n) {
|
||
return n ? pt(Eu(n), 0, 4294967295) : 0
|
||
}
|
||
function Su(n) {
|
||
if (typeof n == "number") return n
|
||
if (wu(n)) return F
|
||
if (
|
||
(du(n) &&
|
||
((n = typeof n.valueOf == "function" ? n.valueOf() : n),
|
||
(n = du(n) ? n + "" : n)),
|
||
typeof n != "string")
|
||
)
|
||
return 0 === n ? n : +n
|
||
n = n.replace(un, "")
|
||
var t = gn.test(n)
|
||
return t || yn.test(n)
|
||
? Dn(n.slice(2), t ? 2 : 8)
|
||
: vn.test(n)
|
||
? F
|
||
: +n
|
||
}
|
||
function Ou(n) {
|
||
return Cr(n, Bu(n))
|
||
}
|
||
function Iu(n) {
|
||
return null == n ? "" : yr(n)
|
||
}
|
||
function Ru(n, t, r) {
|
||
return (n = null == n ? T : kt(n, t)), n === T ? r : n
|
||
}
|
||
function zu(n, t) {
|
||
return null != n && we(n, t, zt)
|
||
}
|
||
function Wu(n) {
|
||
return su(n) ? qn(n) : Vt(n)
|
||
}
|
||
function Bu(n) {
|
||
if (su(n)) n = qn(n, true)
|
||
else if (du(n)) {
|
||
var t,
|
||
r = ze(n),
|
||
e = []
|
||
for (t in n)
|
||
("constructor" != t || (!r && oi.call(n, t))) && e.push(t)
|
||
n = e
|
||
} else {
|
||
if (((t = []), null != n)) for (r in Qu(n)) t.push(r)
|
||
n = t
|
||
}
|
||
return n
|
||
}
|
||
function Lu(n, t) {
|
||
if (null == n) return {}
|
||
var r = c(ve(n), function(n) {
|
||
return [n]
|
||
})
|
||
return (
|
||
(t = ye(t)),
|
||
tr(n, r, function(n, r) {
|
||
return t(n, r[0])
|
||
})
|
||
)
|
||
}
|
||
function Uu(n) {
|
||
return null == n ? [] : S(n, Wu(n))
|
||
}
|
||
function Cu(n) {
|
||
return $f(Iu(n).toLowerCase())
|
||
}
|
||
function Du(n) {
|
||
return (n = Iu(n)) && n.replace(xn, Xn).replace(Sn, "")
|
||
}
|
||
function Mu(n, t, r) {
|
||
return (
|
||
(n = Iu(n)),
|
||
(t = r ? T : t),
|
||
t === T
|
||
? zn.test(n)
|
||
? n.match(In) || []
|
||
: n.match(sn) || []
|
||
: n.match(t) || []
|
||
)
|
||
}
|
||
function Tu(n) {
|
||
return function() {
|
||
return n
|
||
}
|
||
}
|
||
function $u(n) {
|
||
return n
|
||
}
|
||
function Fu(n) {
|
||
return qt(typeof n == "function" ? n : _t(n, 1))
|
||
}
|
||
function Nu(n, t, e) {
|
||
var u = Wu(t),
|
||
i = Et(t, u)
|
||
null != e ||
|
||
(du(t) && (i.length || !u.length)) ||
|
||
((e = t), (t = n), (n = this), (i = Et(t, Wu(t))))
|
||
var o = !(du(e) && "chain" in e && !e.chain),
|
||
f = _u(n)
|
||
return (
|
||
r(i, function(r) {
|
||
var e = t[r]
|
||
;(n[r] = e),
|
||
f &&
|
||
(n.prototype[r] = function() {
|
||
var t = this.__chain__
|
||
if (o || t) {
|
||
var r = n(this.__wrapped__)
|
||
return (
|
||
(r.__actions__ = Ur(this.__actions__)).push({
|
||
func: e,
|
||
args: arguments,
|
||
thisArg: n,
|
||
}),
|
||
(r.__chain__ = t),
|
||
r
|
||
)
|
||
}
|
||
return e.apply(n, a([this.value()], arguments))
|
||
})
|
||
}),
|
||
n
|
||
)
|
||
}
|
||
function Pu() {}
|
||
function Zu(n) {
|
||
return Ie(n) ? b(Me(n)) : rr(n)
|
||
}
|
||
function qu() {
|
||
return []
|
||
}
|
||
function Vu() {
|
||
return false
|
||
}
|
||
mn = null == mn ? $n : rt.defaults($n.Object(), mn, rt.pick($n, Wn))
|
||
var Ku = mn.Array,
|
||
Gu = mn.Date,
|
||
Hu = mn.Error,
|
||
Ju = mn.Function,
|
||
Yu = mn.Math,
|
||
Qu = mn.Object,
|
||
Xu = mn.RegExp,
|
||
ni = mn.String,
|
||
ti = mn.TypeError,
|
||
ri = Ku.prototype,
|
||
ei = Qu.prototype,
|
||
ui = mn["__core-js_shared__"],
|
||
ii = Ju.prototype.toString,
|
||
oi = ei.hasOwnProperty,
|
||
fi = 0,
|
||
ci = (function() {
|
||
var n = /[^.]+$/.exec((ui && ui.keys && ui.keys.IE_PROTO) || "")
|
||
return n ? "Symbol(src)_1." + n : ""
|
||
})(),
|
||
ai = ei.toString,
|
||
li = ii.call(Qu),
|
||
si = $n._,
|
||
hi = Xu(
|
||
"^" +
|
||
ii
|
||
.call(oi)
|
||
.replace(rn, "\\$&")
|
||
.replace(
|
||
/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
|
||
"$1.*?"
|
||
) +
|
||
"$"
|
||
),
|
||
pi = Pn ? mn.Buffer : T,
|
||
_i = mn.Symbol,
|
||
vi = mn.Uint8Array,
|
||
gi = pi ? pi.g : T,
|
||
di = B(Qu.getPrototypeOf, Qu),
|
||
yi = Qu.create,
|
||
bi = ei.propertyIsEnumerable,
|
||
xi = ri.splice,
|
||
ji = _i ? _i.isConcatSpreadable : T,
|
||
wi = _i ? _i.iterator : T,
|
||
mi = _i ? _i.toStringTag : T,
|
||
Ai = (function() {
|
||
try {
|
||
var n = je(Qu, "defineProperty")
|
||
return n({}, "", {}), n
|
||
} catch (n) {}
|
||
})(),
|
||
Ei = mn.clearTimeout !== $n.clearTimeout && mn.clearTimeout,
|
||
ki = Gu && Gu.now !== $n.Date.now && Gu.now,
|
||
Si = mn.setTimeout !== $n.setTimeout && mn.setTimeout,
|
||
Oi = Yu.ceil,
|
||
Ii = Yu.floor,
|
||
Ri = Qu.getOwnPropertySymbols,
|
||
zi = pi ? pi.isBuffer : T,
|
||
Wi = mn.isFinite,
|
||
Bi = ri.join,
|
||
Li = B(Qu.keys, Qu),
|
||
Ui = Yu.max,
|
||
Ci = Yu.min,
|
||
Di = Gu.now,
|
||
Mi = mn.parseInt,
|
||
Ti = Yu.random,
|
||
$i = ri.reverse,
|
||
Fi = je(mn, "DataView"),
|
||
Ni = je(mn, "Map"),
|
||
Pi = je(mn, "Promise"),
|
||
Zi = je(mn, "Set"),
|
||
qi = je(mn, "WeakMap"),
|
||
Vi = je(Qu, "create"),
|
||
Ki = qi && new qi(),
|
||
Gi = {},
|
||
Hi = Te(Fi),
|
||
Ji = Te(Ni),
|
||
Yi = Te(Pi),
|
||
Qi = Te(Zi),
|
||
Xi = Te(qi),
|
||
no = _i ? _i.prototype : T,
|
||
to = no ? no.valueOf : T,
|
||
ro = no ? no.toString : T,
|
||
eo = (function() {
|
||
function n() {}
|
||
return function(t) {
|
||
return du(t)
|
||
? yi
|
||
? yi(t)
|
||
: ((n.prototype = t), (t = new n()), (n.prototype = T), t)
|
||
: {}
|
||
}
|
||
})()
|
||
;(An.templateSettings = {
|
||
escape: J,
|
||
evaluate: Y,
|
||
interpolate: Q,
|
||
variable: "",
|
||
imports: { _: An },
|
||
}),
|
||
(An.prototype = En.prototype),
|
||
(An.prototype.constructor = An),
|
||
(On.prototype = eo(En.prototype)),
|
||
(On.prototype.constructor = On),
|
||
(Un.prototype = eo(En.prototype)),
|
||
(Un.prototype.constructor = Un),
|
||
(Mn.prototype.clear = function() {
|
||
;(this.__data__ = Vi ? Vi(null) : {}), (this.size = 0)
|
||
}),
|
||
(Mn.prototype.delete = function(n) {
|
||
return (
|
||
(n = this.has(n) && delete this.__data__[n]),
|
||
(this.size -= n ? 1 : 0),
|
||
n
|
||
)
|
||
}),
|
||
(Mn.prototype.get = function(n) {
|
||
var t = this.__data__
|
||
return Vi
|
||
? ((n = t[n]), "__lodash_hash_undefined__" === n ? T : n)
|
||
: oi.call(t, n)
|
||
? t[n]
|
||
: T
|
||
}),
|
||
(Mn.prototype.has = function(n) {
|
||
var t = this.__data__
|
||
return Vi ? t[n] !== T : oi.call(t, n)
|
||
}),
|
||
(Mn.prototype.set = function(n, t) {
|
||
var r = this.__data__
|
||
return (
|
||
(this.size += this.has(n) ? 0 : 1),
|
||
(r[n] = Vi && t === T ? "__lodash_hash_undefined__" : t),
|
||
this
|
||
)
|
||
}),
|
||
(Tn.prototype.clear = function() {
|
||
;(this.__data__ = []), (this.size = 0)
|
||
}),
|
||
(Tn.prototype.delete = function(n) {
|
||
var t = this.__data__
|
||
return (
|
||
(n = ft(t, n)),
|
||
!(0 > n) &&
|
||
(n == t.length - 1 ? t.pop() : xi.call(t, n, 1),
|
||
--this.size,
|
||
true)
|
||
)
|
||
}),
|
||
(Tn.prototype.get = function(n) {
|
||
var t = this.__data__
|
||
return (n = ft(t, n)), 0 > n ? T : t[n][1]
|
||
}),
|
||
(Tn.prototype.has = function(n) {
|
||
return -1 < ft(this.__data__, n)
|
||
}),
|
||
(Tn.prototype.set = function(n, t) {
|
||
var r = this.__data__,
|
||
e = ft(r, n)
|
||
return 0 > e ? (++this.size, r.push([n, t])) : (r[e][1] = t), this
|
||
}),
|
||
(Fn.prototype.clear = function() {
|
||
;(this.size = 0),
|
||
(this.__data__ = {
|
||
hash: new Mn(),
|
||
map: new (Ni || Tn)(),
|
||
string: new Mn(),
|
||
})
|
||
}),
|
||
(Fn.prototype.delete = function(n) {
|
||
return (n = be(this, n).delete(n)), (this.size -= n ? 1 : 0), n
|
||
}),
|
||
(Fn.prototype.get = function(n) {
|
||
return be(this, n).get(n)
|
||
}),
|
||
(Fn.prototype.has = function(n) {
|
||
return be(this, n).has(n)
|
||
}),
|
||
(Fn.prototype.set = function(n, t) {
|
||
var r = be(this, n),
|
||
e = r.size
|
||
return r.set(n, t), (this.size += r.size == e ? 0 : 1), this
|
||
}),
|
||
(Nn.prototype.add = Nn.prototype.push = function(n) {
|
||
return this.__data__.set(n, "__lodash_hash_undefined__"), this
|
||
}),
|
||
(Nn.prototype.has = function(n) {
|
||
return this.__data__.has(n)
|
||
}),
|
||
(Zn.prototype.clear = function() {
|
||
;(this.__data__ = new Tn()), (this.size = 0)
|
||
}),
|
||
(Zn.prototype.delete = function(n) {
|
||
var t = this.__data__
|
||
return (n = t.delete(n)), (this.size = t.size), n
|
||
}),
|
||
(Zn.prototype.get = function(n) {
|
||
return this.__data__.get(n)
|
||
}),
|
||
(Zn.prototype.has = function(n) {
|
||
return this.__data__.has(n)
|
||
}),
|
||
(Zn.prototype.set = function(n, t) {
|
||
var r = this.__data__
|
||
if (r instanceof Tn) {
|
||
var e = r.__data__
|
||
if (!Ni || 199 > e.length)
|
||
return e.push([n, t]), (this.size = ++r.size), this
|
||
r = this.__data__ = new Fn(e)
|
||
}
|
||
return r.set(n, t), (this.size = r.size), this
|
||
})
|
||
var uo = Fr(mt),
|
||
io = Fr(At, true),
|
||
oo = Nr(),
|
||
fo = Nr(true),
|
||
co = Ki
|
||
? function(n, t) {
|
||
return Ki.set(n, t), n
|
||
}
|
||
: $u,
|
||
ao = Ai
|
||
? function(n, t) {
|
||
return Ai(n, "toString", {
|
||
configurable: true,
|
||
enumerable: false,
|
||
value: Tu(t),
|
||
writable: true,
|
||
})
|
||
}
|
||
: $u,
|
||
lo =
|
||
Ei ||
|
||
function(n) {
|
||
return $n.clearTimeout(n)
|
||
},
|
||
so =
|
||
Zi && 1 / U(new Zi([, -0]))[1] == $
|
||
? function(n) {
|
||
return new Zi(n)
|
||
}
|
||
: Pu,
|
||
ho = Ki
|
||
? function(n) {
|
||
return Ki.get(n)
|
||
}
|
||
: Pu,
|
||
po = Ri
|
||
? function(n) {
|
||
return null == n
|
||
? []
|
||
: ((n = Qu(n)),
|
||
i(Ri(n), function(t) {
|
||
return bi.call(n, t)
|
||
}))
|
||
}
|
||
: qu,
|
||
_o = Ri
|
||
? function(n) {
|
||
for (var t = []; n; ) a(t, po(n)), (n = di(n))
|
||
return t
|
||
}
|
||
: qu,
|
||
vo = Ot
|
||
;((Fi && "[object DataView]" != vo(new Fi(new ArrayBuffer(1)))) ||
|
||
(Ni && "[object Map]" != vo(new Ni())) ||
|
||
(Pi && "[object Promise]" != vo(Pi.resolve())) ||
|
||
(Zi && "[object Set]" != vo(new Zi())) ||
|
||
(qi && "[object WeakMap]" != vo(new qi()))) &&
|
||
(vo = function(n) {
|
||
var t = Ot(n)
|
||
if (
|
||
(n = (n = "[object Object]" == t ? n.constructor : T)
|
||
? Te(n)
|
||
: "")
|
||
)
|
||
switch (n) {
|
||
case Hi:
|
||
return "[object DataView]"
|
||
case Ji:
|
||
return "[object Map]"
|
||
case Yi:
|
||
return "[object Promise]"
|
||
case Qi:
|
||
return "[object Set]"
|
||
case Xi:
|
||
return "[object WeakMap]"
|
||
}
|
||
return t
|
||
})
|
||
var go = ui ? _u : Vu,
|
||
yo = Ce(co),
|
||
bo =
|
||
Si ||
|
||
function(n, t) {
|
||
return $n.setTimeout(n, t)
|
||
},
|
||
xo = Ce(ao),
|
||
jo = (function(n) {
|
||
n = cu(n, function(n) {
|
||
return 500 === t.size && t.clear(), n
|
||
})
|
||
var t = n.cache
|
||
return n
|
||
})(function(n) {
|
||
var t = []
|
||
return (
|
||
46 === n.charCodeAt(0) && t.push(""),
|
||
n.replace(tn, function(n, r, e, u) {
|
||
t.push(e ? u.replace(hn, "$1") : r || n)
|
||
}),
|
||
t
|
||
)
|
||
}),
|
||
wo = fr(function(n, t) {
|
||
return hu(n) ? yt(n, wt(t, 1, hu, true)) : []
|
||
}),
|
||
mo = fr(function(n, t) {
|
||
var r = Ve(t)
|
||
return (
|
||
hu(r) && (r = T),
|
||
hu(n) ? yt(n, wt(t, 1, hu, true), ye(r, 2)) : []
|
||
)
|
||
}),
|
||
Ao = fr(function(n, t) {
|
||
var r = Ve(t)
|
||
return (
|
||
hu(r) && (r = T), hu(n) ? yt(n, wt(t, 1, hu, true), T, r) : []
|
||
)
|
||
}),
|
||
Eo = fr(function(n) {
|
||
var t = c(n, Er)
|
||
return t.length && t[0] === n[0] ? Wt(t) : []
|
||
}),
|
||
ko = fr(function(n) {
|
||
var t = Ve(n),
|
||
r = c(n, Er)
|
||
return (
|
||
t === Ve(r) ? (t = T) : r.pop(),
|
||
r.length && r[0] === n[0] ? Wt(r, ye(t, 2)) : []
|
||
)
|
||
}),
|
||
So = fr(function(n) {
|
||
var t = Ve(n),
|
||
r = c(n, Er)
|
||
return (
|
||
(t = typeof t == "function" ? t : T) && r.pop(),
|
||
r.length && r[0] === n[0] ? Wt(r, T, t) : []
|
||
)
|
||
}),
|
||
Oo = fr(Ke),
|
||
Io = pe(function(n, t) {
|
||
var r = null == n ? 0 : n.length,
|
||
e = ht(n, t)
|
||
return (
|
||
ur(
|
||
n,
|
||
c(t, function(n) {
|
||
return Se(n, r) ? +n : n
|
||
}).sort(Wr)
|
||
),
|
||
e
|
||
)
|
||
}),
|
||
Ro = fr(function(n) {
|
||
return br(wt(n, 1, hu, true))
|
||
}),
|
||
zo = fr(function(n) {
|
||
var t = Ve(n)
|
||
return hu(t) && (t = T), br(wt(n, 1, hu, true), ye(t, 2))
|
||
}),
|
||
Wo = fr(function(n) {
|
||
var t = Ve(n),
|
||
t = typeof t == "function" ? t : T
|
||
return br(wt(n, 1, hu, true), T, t)
|
||
}),
|
||
Bo = fr(function(n, t) {
|
||
return hu(n) ? yt(n, t) : []
|
||
}),
|
||
Lo = fr(function(n) {
|
||
return mr(i(n, hu))
|
||
}),
|
||
Uo = fr(function(n) {
|
||
var t = Ve(n)
|
||
return hu(t) && (t = T), mr(i(n, hu), ye(t, 2))
|
||
}),
|
||
Co = fr(function(n) {
|
||
var t = Ve(n),
|
||
t = typeof t == "function" ? t : T
|
||
return mr(i(n, hu), T, t)
|
||
}),
|
||
Do = fr(He),
|
||
Mo = fr(function(n) {
|
||
var t = n.length,
|
||
t = 1 < t ? n[t - 1] : T,
|
||
t = typeof t == "function" ? (n.pop(), t) : T
|
||
return Je(n, t)
|
||
}),
|
||
To = pe(function(n) {
|
||
function t(t) {
|
||
return ht(t, n)
|
||
}
|
||
var r = n.length,
|
||
e = r ? n[0] : 0,
|
||
u = this.__wrapped__
|
||
return !(1 < r || this.__actions__.length) &&
|
||
u instanceof Un &&
|
||
Se(e)
|
||
? ((u = u.slice(e, +e + (r ? 1 : 0))),
|
||
u.__actions__.push({ func: Qe, args: [t], thisArg: T }),
|
||
new On(u, this.__chain__).thru(function(n) {
|
||
return r && !n.length && n.push(T), n
|
||
}))
|
||
: this.thru(t)
|
||
}),
|
||
$o = Tr(function(n, t, r) {
|
||
oi.call(n, r) ? ++n[r] : st(n, r, 1)
|
||
}),
|
||
Fo = Gr(Ne),
|
||
No = Gr(Pe),
|
||
Po = Tr(function(n, t, r) {
|
||
oi.call(n, r) ? n[r].push(t) : st(n, r, [t])
|
||
}),
|
||
Zo = fr(function(t, r, e) {
|
||
var u = -1,
|
||
i = typeof r == "function",
|
||
o = su(t) ? Ku(t.length) : []
|
||
return (
|
||
uo(t, function(t) {
|
||
o[++u] = i ? n(r, t, e) : Lt(t, r, e)
|
||
}),
|
||
o
|
||
)
|
||
}),
|
||
qo = Tr(function(n, t, r) {
|
||
st(n, r, t)
|
||
}),
|
||
Vo = Tr(
|
||
function(n, t, r) {
|
||
n[r ? 0 : 1].push(t)
|
||
},
|
||
function() {
|
||
return [[], []]
|
||
}
|
||
),
|
||
Ko = fr(function(n, t) {
|
||
if (null == n) return []
|
||
var r = t.length
|
||
return (
|
||
1 < r && Oe(n, t[0], t[1])
|
||
? (t = [])
|
||
: 2 < r && Oe(t[0], t[1], t[2]) && (t = [t[0]]),
|
||
Xt(n, wt(t, 1), [])
|
||
)
|
||
}),
|
||
Go =
|
||
ki ||
|
||
function() {
|
||
return $n.Date.now()
|
||
},
|
||
Ho = fr(function(n, t, r) {
|
||
var e = 1
|
||
if (r.length)
|
||
var u = L(r, de(Ho)),
|
||
e = 32 | e
|
||
return fe(n, e, t, r, u)
|
||
}),
|
||
Jo = fr(function(n, t, r) {
|
||
var e = 3
|
||
if (r.length)
|
||
var u = L(r, de(Jo)),
|
||
e = 32 | e
|
||
return fe(t, e, n, r, u)
|
||
}),
|
||
Yo = fr(function(n, t) {
|
||
return dt(n, 1, t)
|
||
}),
|
||
Qo = fr(function(n, t, r) {
|
||
return dt(n, Su(t) || 0, r)
|
||
})
|
||
cu.Cache = Fn
|
||
var Xo = fr(function(t, r) {
|
||
r =
|
||
1 == r.length && ff(r[0])
|
||
? c(r[0], k(ye()))
|
||
: c(wt(r, 1), k(ye()))
|
||
var e = r.length
|
||
return fr(function(u) {
|
||
for (var i = -1, o = Ci(u.length, e); ++i < o; )
|
||
u[i] = r[i].call(this, u[i])
|
||
return n(t, this, u)
|
||
})
|
||
}),
|
||
nf = fr(function(n, t) {
|
||
return fe(n, 32, T, t, L(t, de(nf)))
|
||
}),
|
||
tf = fr(function(n, t) {
|
||
return fe(n, 64, T, t, L(t, de(tf)))
|
||
}),
|
||
rf = pe(function(n, t) {
|
||
return fe(n, 256, T, T, T, t)
|
||
}),
|
||
ef = ee(It),
|
||
uf = ee(function(n, t) {
|
||
return n >= t
|
||
}),
|
||
of = Ut(
|
||
(function() {
|
||
return arguments
|
||
})()
|
||
)
|
||
? Ut
|
||
: function(n) {
|
||
return yu(n) && oi.call(n, "callee") && !bi.call(n, "callee")
|
||
},
|
||
ff = Ku.isArray,
|
||
cf = Vn ? k(Vn) : Ct,
|
||
af = zi || Vu,
|
||
lf = Kn ? k(Kn) : Dt,
|
||
sf = Gn ? k(Gn) : Tt,
|
||
hf = Hn ? k(Hn) : Nt,
|
||
pf = Jn ? k(Jn) : Pt,
|
||
_f = Yn ? k(Yn) : Zt,
|
||
vf = ee(Kt),
|
||
gf = ee(function(n, t) {
|
||
return n <= t
|
||
}),
|
||
df = $r(function(n, t) {
|
||
if (ze(t) || su(t)) Cr(t, Wu(t), n)
|
||
else for (var r in t) oi.call(t, r) && ot(n, r, t[r])
|
||
}),
|
||
yf = $r(function(n, t) {
|
||
Cr(t, Bu(t), n)
|
||
}),
|
||
bf = $r(function(n, t, r, e) {
|
||
Cr(t, Bu(t), n, e)
|
||
}),
|
||
xf = $r(function(n, t, r, e) {
|
||
Cr(t, Wu(t), n, e)
|
||
}),
|
||
jf = pe(ht),
|
||
wf = fr(function(n, t) {
|
||
n = Qu(n)
|
||
var r = -1,
|
||
e = t.length,
|
||
u = 2 < e ? t[2] : T
|
||
for (u && Oe(t[0], t[1], u) && (e = 1); ++r < e; )
|
||
for (var u = t[r], i = Bu(u), o = -1, f = i.length; ++o < f; ) {
|
||
var c = i[o],
|
||
a = n[c]
|
||
;(a === T || (lu(a, ei[c]) && !oi.call(n, c))) &&
|
||
(n[c] = u[c])
|
||
}
|
||
return n
|
||
}),
|
||
mf = fr(function(t) {
|
||
return t.push(T, ae), n(Of, T, t)
|
||
}),
|
||
Af = Yr(function(n, t, r) {
|
||
null != t && typeof t.toString != "function" && (t = ai.call(t)),
|
||
(n[t] = r)
|
||
}, Tu($u)),
|
||
Ef = Yr(function(n, t, r) {
|
||
null != t && typeof t.toString != "function" && (t = ai.call(t)),
|
||
oi.call(n, t) ? n[t].push(r) : (n[t] = [r])
|
||
}, ye),
|
||
kf = fr(Lt),
|
||
Sf = $r(function(n, t, r) {
|
||
Yt(n, t, r)
|
||
}),
|
||
Of = $r(function(n, t, r, e) {
|
||
Yt(n, t, r, e)
|
||
}),
|
||
If = pe(function(n, t) {
|
||
var r = {}
|
||
if (null == n) return r
|
||
var e = false
|
||
;(t = c(t, function(t) {
|
||
return (t = Sr(t, n)), e || (e = 1 < t.length), t
|
||
})),
|
||
Cr(n, ve(n), r),
|
||
e && (r = _t(r, 7, le))
|
||
for (var u = t.length; u--; ) xr(r, t[u])
|
||
return r
|
||
}),
|
||
Rf = pe(function(n, t) {
|
||
return null == n ? {} : nr(n, t)
|
||
}),
|
||
zf = oe(Wu),
|
||
Wf = oe(Bu),
|
||
Bf = qr(function(n, t, r) {
|
||
return (t = t.toLowerCase()), n + (r ? Cu(t) : t)
|
||
}),
|
||
Lf = qr(function(n, t, r) {
|
||
return n + (r ? "-" : "") + t.toLowerCase()
|
||
}),
|
||
Uf = qr(function(n, t, r) {
|
||
return n + (r ? " " : "") + t.toLowerCase()
|
||
}),
|
||
Cf = Zr("toLowerCase"),
|
||
Df = qr(function(n, t, r) {
|
||
return n + (r ? "_" : "") + t.toLowerCase()
|
||
}),
|
||
Mf = qr(function(n, t, r) {
|
||
return n + (r ? " " : "") + $f(t)
|
||
}),
|
||
Tf = qr(function(n, t, r) {
|
||
return n + (r ? " " : "") + t.toUpperCase()
|
||
}),
|
||
$f = Zr("toUpperCase"),
|
||
Ff = fr(function(t, r) {
|
||
try {
|
||
return n(t, T, r)
|
||
} catch (n) {
|
||
return pu(n) ? n : new Hu(n)
|
||
}
|
||
}),
|
||
Nf = pe(function(n, t) {
|
||
return (
|
||
r(t, function(t) {
|
||
;(t = Me(t)), st(n, t, Ho(n[t], n))
|
||
}),
|
||
n
|
||
)
|
||
}),
|
||
Pf = Hr(),
|
||
Zf = Hr(true),
|
||
qf = fr(function(n, t) {
|
||
return function(r) {
|
||
return Lt(r, n, t)
|
||
}
|
||
}),
|
||
Vf = fr(function(n, t) {
|
||
return function(r) {
|
||
return Lt(n, r, t)
|
||
}
|
||
}),
|
||
Kf = Xr(c),
|
||
Gf = Xr(u),
|
||
Hf = Xr(h),
|
||
Jf = re(),
|
||
Yf = re(true),
|
||
Qf = Qr(function(n, t) {
|
||
return n + t
|
||
}, 0),
|
||
Xf = ie("ceil"),
|
||
nc = Qr(function(n, t) {
|
||
return n / t
|
||
}, 1),
|
||
tc = ie("floor"),
|
||
rc = Qr(function(n, t) {
|
||
return n * t
|
||
}, 1),
|
||
ec = ie("round"),
|
||
uc = Qr(function(n, t) {
|
||
return n - t
|
||
}, 0)
|
||
return (
|
||
(An.after = function(n, t) {
|
||
if (typeof t != "function") throw new ti("Expected a function")
|
||
return (
|
||
(n = Eu(n)),
|
||
function() {
|
||
if (1 > --n) return t.apply(this, arguments)
|
||
}
|
||
)
|
||
}),
|
||
(An.ary = eu),
|
||
(An.assign = df),
|
||
(An.assignIn = yf),
|
||
(An.assignInWith = bf),
|
||
(An.assignWith = xf),
|
||
(An.at = jf),
|
||
(An.before = uu),
|
||
(An.bind = Ho),
|
||
(An.bindAll = Nf),
|
||
(An.bindKey = Jo),
|
||
(An.castArray = function() {
|
||
if (!arguments.length) return []
|
||
var n = arguments[0]
|
||
return ff(n) ? n : [n]
|
||
}),
|
||
(An.chain = Ye),
|
||
(An.chunk = function(n, t, r) {
|
||
if (
|
||
((t = (r ? Oe(n, t, r) : t === T) ? 1 : Ui(Eu(t), 0)),
|
||
(r = null == n ? 0 : n.length),
|
||
!r || 1 > t)
|
||
)
|
||
return []
|
||
for (var e = 0, u = 0, i = Ku(Oi(r / t)); e < r; )
|
||
i[u++] = hr(n, e, (e += t))
|
||
return i
|
||
}),
|
||
(An.compact = function(n) {
|
||
for (
|
||
var t = -1, r = null == n ? 0 : n.length, e = 0, u = [];
|
||
++t < r;
|
||
|
||
) {
|
||
var i = n[t]
|
||
i && (u[e++] = i)
|
||
}
|
||
return u
|
||
}),
|
||
(An.concat = function() {
|
||
var n = arguments.length
|
||
if (!n) return []
|
||
for (var t = Ku(n - 1), r = arguments[0]; n--; )
|
||
t[n - 1] = arguments[n]
|
||
return a(ff(r) ? Ur(r) : [r], wt(t, 1))
|
||
}),
|
||
(An.cond = function(t) {
|
||
var r = null == t ? 0 : t.length,
|
||
e = ye()
|
||
return (
|
||
(t = r
|
||
? c(t, function(n) {
|
||
if ("function" != typeof n[1])
|
||
throw new ti("Expected a function")
|
||
return [e(n[0]), n[1]]
|
||
})
|
||
: []),
|
||
fr(function(e) {
|
||
for (var u = -1; ++u < r; ) {
|
||
var i = t[u]
|
||
if (n(i[0], this, e)) return n(i[1], this, e)
|
||
}
|
||
})
|
||
)
|
||
}),
|
||
(An.conforms = function(n) {
|
||
return vt(_t(n, 1))
|
||
}),
|
||
(An.constant = Tu),
|
||
(An.countBy = $o),
|
||
(An.create = function(n, t) {
|
||
var r = eo(n)
|
||
return null == t ? r : at(r, t)
|
||
}),
|
||
(An.curry = iu),
|
||
(An.curryRight = ou),
|
||
(An.debounce = fu),
|
||
(An.defaults = wf),
|
||
(An.defaultsDeep = mf),
|
||
(An.defer = Yo),
|
||
(An.delay = Qo),
|
||
(An.difference = wo),
|
||
(An.differenceBy = mo),
|
||
(An.differenceWith = Ao),
|
||
(An.drop = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? ((t = r || t === T ? 1 : Eu(t)), hr(n, 0 > t ? 0 : t, e))
|
||
: []
|
||
}),
|
||
(An.dropRight = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? ((t = r || t === T ? 1 : Eu(t)),
|
||
(t = e - t),
|
||
hr(n, 0, 0 > t ? 0 : t))
|
||
: []
|
||
}),
|
||
(An.dropRightWhile = function(n, t) {
|
||
return n && n.length ? jr(n, ye(t, 3), true, true) : []
|
||
}),
|
||
(An.dropWhile = function(n, t) {
|
||
return n && n.length ? jr(n, ye(t, 3), true) : []
|
||
}),
|
||
(An.fill = function(n, t, r, e) {
|
||
var u = null == n ? 0 : n.length
|
||
if (!u) return []
|
||
for (
|
||
r && typeof r != "number" && Oe(n, t, r) && ((r = 0), (e = u)),
|
||
u = n.length,
|
||
r = Eu(r),
|
||
0 > r && (r = -r > u ? 0 : u + r),
|
||
e = e === T || e > u ? u : Eu(e),
|
||
0 > e && (e += u),
|
||
e = r > e ? 0 : ku(e);
|
||
r < e;
|
||
|
||
)
|
||
n[r++] = t
|
||
return n
|
||
}),
|
||
(An.filter = function(n, t) {
|
||
return (ff(n) ? i : jt)(n, ye(t, 3))
|
||
}),
|
||
(An.flatMap = function(n, t) {
|
||
return wt(ru(n, t), 1)
|
||
}),
|
||
(An.flatMapDeep = function(n, t) {
|
||
return wt(ru(n, t), $)
|
||
}),
|
||
(An.flatMapDepth = function(n, t, r) {
|
||
return (r = r === T ? 1 : Eu(r)), wt(ru(n, t), r)
|
||
}),
|
||
(An.flatten = Ze),
|
||
(An.flattenDeep = function(n) {
|
||
return (null == n ? 0 : n.length) ? wt(n, $) : []
|
||
}),
|
||
(An.flattenDepth = function(n, t) {
|
||
return null != n && n.length
|
||
? ((t = t === T ? 1 : Eu(t)), wt(n, t))
|
||
: []
|
||
}),
|
||
(An.flip = function(n) {
|
||
return fe(n, 512)
|
||
}),
|
||
(An.flow = Pf),
|
||
(An.flowRight = Zf),
|
||
(An.fromPairs = function(n) {
|
||
for (
|
||
var t = -1, r = null == n ? 0 : n.length, e = {};
|
||
++t < r;
|
||
|
||
) {
|
||
var u = n[t]
|
||
e[u[0]] = u[1]
|
||
}
|
||
return e
|
||
}),
|
||
(An.functions = function(n) {
|
||
return null == n ? [] : Et(n, Wu(n))
|
||
}),
|
||
(An.functionsIn = function(n) {
|
||
return null == n ? [] : Et(n, Bu(n))
|
||
}),
|
||
(An.groupBy = Po),
|
||
(An.initial = function(n) {
|
||
return (null == n ? 0 : n.length) ? hr(n, 0, -1) : []
|
||
}),
|
||
(An.intersection = Eo),
|
||
(An.intersectionBy = ko),
|
||
(An.intersectionWith = So),
|
||
(An.invert = Af),
|
||
(An.invertBy = Ef),
|
||
(An.invokeMap = Zo),
|
||
(An.iteratee = Fu),
|
||
(An.keyBy = qo),
|
||
(An.keys = Wu),
|
||
(An.keysIn = Bu),
|
||
(An.map = ru),
|
||
(An.mapKeys = function(n, t) {
|
||
var r = {}
|
||
return (
|
||
(t = ye(t, 3)),
|
||
mt(n, function(n, e, u) {
|
||
st(r, t(n, e, u), n)
|
||
}),
|
||
r
|
||
)
|
||
}),
|
||
(An.mapValues = function(n, t) {
|
||
var r = {}
|
||
return (
|
||
(t = ye(t, 3)),
|
||
mt(n, function(n, e, u) {
|
||
st(r, e, t(n, e, u))
|
||
}),
|
||
r
|
||
)
|
||
}),
|
||
(An.matches = function(n) {
|
||
return Ht(_t(n, 1))
|
||
}),
|
||
(An.matchesProperty = function(n, t) {
|
||
return Jt(n, _t(t, 1))
|
||
}),
|
||
(An.memoize = cu),
|
||
(An.merge = Sf),
|
||
(An.mergeWith = Of),
|
||
(An.method = qf),
|
||
(An.methodOf = Vf),
|
||
(An.mixin = Nu),
|
||
(An.negate = au),
|
||
(An.nthArg = function(n) {
|
||
return (
|
||
(n = Eu(n)),
|
||
fr(function(t) {
|
||
return Qt(t, n)
|
||
})
|
||
)
|
||
}),
|
||
(An.omit = If),
|
||
(An.omitBy = function(n, t) {
|
||
return Lu(n, au(ye(t)))
|
||
}),
|
||
(An.once = function(n) {
|
||
return uu(2, n)
|
||
}),
|
||
(An.orderBy = function(n, t, r, e) {
|
||
return null == n
|
||
? []
|
||
: (ff(t) || (t = null == t ? [] : [t]),
|
||
(r = e ? T : r),
|
||
ff(r) || (r = null == r ? [] : [r]),
|
||
Xt(n, t, r))
|
||
}),
|
||
(An.over = Kf),
|
||
(An.overArgs = Xo),
|
||
(An.overEvery = Gf),
|
||
(An.overSome = Hf),
|
||
(An.partial = nf),
|
||
(An.partialRight = tf),
|
||
(An.partition = Vo),
|
||
(An.pick = Rf),
|
||
(An.pickBy = Lu),
|
||
(An.property = Zu),
|
||
(An.propertyOf = function(n) {
|
||
return function(t) {
|
||
return null == n ? T : kt(n, t)
|
||
}
|
||
}),
|
||
(An.pull = Oo),
|
||
(An.pullAll = Ke),
|
||
(An.pullAllBy = function(n, t, r) {
|
||
return n && n.length && t && t.length ? er(n, t, ye(r, 2)) : n
|
||
}),
|
||
(An.pullAllWith = function(n, t, r) {
|
||
return n && n.length && t && t.length ? er(n, t, T, r) : n
|
||
}),
|
||
(An.pullAt = Io),
|
||
(An.range = Jf),
|
||
(An.rangeRight = Yf),
|
||
(An.rearg = rf),
|
||
(An.reject = function(n, t) {
|
||
return (ff(n) ? i : jt)(n, au(ye(t, 3)))
|
||
}),
|
||
(An.remove = function(n, t) {
|
||
var r = []
|
||
if (!n || !n.length) return r
|
||
var e = -1,
|
||
u = [],
|
||
i = n.length
|
||
for (t = ye(t, 3); ++e < i; ) {
|
||
var o = n[e]
|
||
t(o, e, n) && (r.push(o), u.push(e))
|
||
}
|
||
return ur(n, u), r
|
||
}),
|
||
(An.rest = function(n, t) {
|
||
if (typeof n != "function") throw new ti("Expected a function")
|
||
return (t = t === T ? t : Eu(t)), fr(n, t)
|
||
}),
|
||
(An.reverse = Ge),
|
||
(An.sampleSize = function(n, t, r) {
|
||
return (
|
||
(t = (r ? Oe(n, t, r) : t === T) ? 1 : Eu(t)),
|
||
(ff(n) ? et : ar)(n, t)
|
||
)
|
||
}),
|
||
(An.set = function(n, t, r) {
|
||
return null == n ? n : lr(n, t, r)
|
||
}),
|
||
(An.setWith = function(n, t, r, e) {
|
||
return (
|
||
(e = typeof e == "function" ? e : T),
|
||
null == n ? n : lr(n, t, r, e)
|
||
)
|
||
}),
|
||
(An.shuffle = function(n) {
|
||
return (ff(n) ? ut : sr)(n)
|
||
}),
|
||
(An.slice = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? (r && typeof r != "number" && Oe(n, t, r)
|
||
? ((t = 0), (r = e))
|
||
: ((t = null == t ? 0 : Eu(t)), (r = r === T ? e : Eu(r))),
|
||
hr(n, t, r))
|
||
: []
|
||
}),
|
||
(An.sortBy = Ko),
|
||
(An.sortedUniq = function(n) {
|
||
return n && n.length ? gr(n) : []
|
||
}),
|
||
(An.sortedUniqBy = function(n, t) {
|
||
return n && n.length ? gr(n, ye(t, 2)) : []
|
||
}),
|
||
(An.split = function(n, t, r) {
|
||
return (
|
||
r && typeof r != "number" && Oe(n, t, r) && (t = r = T),
|
||
(r = r === T ? 4294967295 : r >>> 0),
|
||
r
|
||
? (n = Iu(n)) &&
|
||
(typeof t == "string" || (null != t && !hf(t))) &&
|
||
((t = yr(t)), !t && Rn.test(n))
|
||
? Or(M(n), 0, r)
|
||
: n.split(t, r)
|
||
: []
|
||
)
|
||
}),
|
||
(An.spread = function(t, r) {
|
||
if (typeof t != "function") throw new ti("Expected a function")
|
||
return (
|
||
(r = null == r ? 0 : Ui(Eu(r), 0)),
|
||
fr(function(e) {
|
||
var u = e[r]
|
||
return (e = Or(e, 0, r)), u && a(e, u), n(t, this, e)
|
||
})
|
||
)
|
||
}),
|
||
(An.tail = function(n) {
|
||
var t = null == n ? 0 : n.length
|
||
return t ? hr(n, 1, t) : []
|
||
}),
|
||
(An.take = function(n, t, r) {
|
||
return n && n.length
|
||
? ((t = r || t === T ? 1 : Eu(t)), hr(n, 0, 0 > t ? 0 : t))
|
||
: []
|
||
}),
|
||
(An.takeRight = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? ((t = r || t === T ? 1 : Eu(t)),
|
||
(t = e - t),
|
||
hr(n, 0 > t ? 0 : t, e))
|
||
: []
|
||
}),
|
||
(An.takeRightWhile = function(n, t) {
|
||
return n && n.length ? jr(n, ye(t, 3), false, true) : []
|
||
}),
|
||
(An.takeWhile = function(n, t) {
|
||
return n && n.length ? jr(n, ye(t, 3)) : []
|
||
}),
|
||
(An.tap = function(n, t) {
|
||
return t(n), n
|
||
}),
|
||
(An.throttle = function(n, t, r) {
|
||
var e = true,
|
||
u = true
|
||
if (typeof n != "function") throw new ti("Expected a function")
|
||
return (
|
||
du(r) &&
|
||
((e = "leading" in r ? !!r.leading : e),
|
||
(u = "trailing" in r ? !!r.trailing : u)),
|
||
fu(n, t, { leading: e, maxWait: t, trailing: u })
|
||
)
|
||
}),
|
||
(An.thru = Qe),
|
||
(An.toArray = mu),
|
||
(An.toPairs = zf),
|
||
(An.toPairsIn = Wf),
|
||
(An.toPath = function(n) {
|
||
return ff(n) ? c(n, Me) : wu(n) ? [n] : Ur(jo(Iu(n)))
|
||
}),
|
||
(An.toPlainObject = Ou),
|
||
(An.transform = function(n, t, e) {
|
||
var u = ff(n),
|
||
i = u || af(n) || _f(n)
|
||
if (((t = ye(t, 4)), null == e)) {
|
||
var o = n && n.constructor
|
||
e = i ? (u ? new o() : []) : du(n) && _u(o) ? eo(di(n)) : {}
|
||
}
|
||
return (
|
||
(i ? r : mt)(n, function(n, r, u) {
|
||
return t(e, n, r, u)
|
||
}),
|
||
e
|
||
)
|
||
}),
|
||
(An.unary = function(n) {
|
||
return eu(n, 1)
|
||
}),
|
||
(An.union = Ro),
|
||
(An.unionBy = zo),
|
||
(An.unionWith = Wo),
|
||
(An.uniq = function(n) {
|
||
return n && n.length ? br(n) : []
|
||
}),
|
||
(An.uniqBy = function(n, t) {
|
||
return n && n.length ? br(n, ye(t, 2)) : []
|
||
}),
|
||
(An.uniqWith = function(n, t) {
|
||
return (
|
||
(t = typeof t == "function" ? t : T),
|
||
n && n.length ? br(n, T, t) : []
|
||
)
|
||
}),
|
||
(An.unset = function(n, t) {
|
||
return null == n || xr(n, t)
|
||
}),
|
||
(An.unzip = He),
|
||
(An.unzipWith = Je),
|
||
(An.update = function(n, t, r) {
|
||
return null == n ? n : lr(n, t, kr(r)(kt(n, t)), void 0)
|
||
}),
|
||
(An.updateWith = function(n, t, r, e) {
|
||
return (
|
||
(e = typeof e == "function" ? e : T),
|
||
null != n && (n = lr(n, t, kr(r)(kt(n, t)), e)),
|
||
n
|
||
)
|
||
}),
|
||
(An.values = Uu),
|
||
(An.valuesIn = function(n) {
|
||
return null == n ? [] : S(n, Bu(n))
|
||
}),
|
||
(An.without = Bo),
|
||
(An.words = Mu),
|
||
(An.wrap = function(n, t) {
|
||
return nf(kr(t), n)
|
||
}),
|
||
(An.xor = Lo),
|
||
(An.xorBy = Uo),
|
||
(An.xorWith = Co),
|
||
(An.zip = Do),
|
||
(An.zipObject = function(n, t) {
|
||
return Ar(n || [], t || [], ot)
|
||
}),
|
||
(An.zipObjectDeep = function(n, t) {
|
||
return Ar(n || [], t || [], lr)
|
||
}),
|
||
(An.zipWith = Mo),
|
||
(An.entries = zf),
|
||
(An.entriesIn = Wf),
|
||
(An.extend = yf),
|
||
(An.extendWith = bf),
|
||
Nu(An, An),
|
||
(An.add = Qf),
|
||
(An.attempt = Ff),
|
||
(An.camelCase = Bf),
|
||
(An.capitalize = Cu),
|
||
(An.ceil = Xf),
|
||
(An.clamp = function(n, t, r) {
|
||
return (
|
||
r === T && ((r = t), (t = T)),
|
||
r !== T && ((r = Su(r)), (r = r === r ? r : 0)),
|
||
t !== T && ((t = Su(t)), (t = t === t ? t : 0)),
|
||
pt(Su(n), t, r)
|
||
)
|
||
}),
|
||
(An.clone = function(n) {
|
||
return _t(n, 4)
|
||
}),
|
||
(An.cloneDeep = function(n) {
|
||
return _t(n, 5)
|
||
}),
|
||
(An.cloneDeepWith = function(n, t) {
|
||
return (t = typeof t == "function" ? t : T), _t(n, 5, t)
|
||
}),
|
||
(An.cloneWith = function(n, t) {
|
||
return (t = typeof t == "function" ? t : T), _t(n, 4, t)
|
||
}),
|
||
(An.conformsTo = function(n, t) {
|
||
return null == t || gt(n, t, Wu(t))
|
||
}),
|
||
(An.deburr = Du),
|
||
(An.defaultTo = function(n, t) {
|
||
return null == n || n !== n ? t : n
|
||
}),
|
||
(An.divide = nc),
|
||
(An.endsWith = function(n, t, r) {
|
||
;(n = Iu(n)), (t = yr(t))
|
||
var e = n.length,
|
||
e = (r = r === T ? e : pt(Eu(r), 0, e))
|
||
return (r -= t.length), 0 <= r && n.slice(r, e) == t
|
||
}),
|
||
(An.eq = lu),
|
||
(An.escape = function(n) {
|
||
return (n = Iu(n)) && H.test(n) ? n.replace(K, nt) : n
|
||
}),
|
||
(An.escapeRegExp = function(n) {
|
||
return (n = Iu(n)) && en.test(n) ? n.replace(rn, "\\$&") : n
|
||
}),
|
||
(An.every = function(n, t, r) {
|
||
var e = ff(n) ? u : bt
|
||
return r && Oe(n, t, r) && (t = T), e(n, ye(t, 3))
|
||
}),
|
||
(An.find = Fo),
|
||
(An.findIndex = Ne),
|
||
(An.findKey = function(n, t) {
|
||
return p(n, ye(t, 3), mt)
|
||
}),
|
||
(An.findLast = No),
|
||
(An.findLastIndex = Pe),
|
||
(An.findLastKey = function(n, t) {
|
||
return p(n, ye(t, 3), At)
|
||
}),
|
||
(An.floor = tc),
|
||
(An.forEach = nu),
|
||
(An.forEachRight = tu),
|
||
(An.forIn = function(n, t) {
|
||
return null == n ? n : oo(n, ye(t, 3), Bu)
|
||
}),
|
||
(An.forInRight = function(n, t) {
|
||
return null == n ? n : fo(n, ye(t, 3), Bu)
|
||
}),
|
||
(An.forOwn = function(n, t) {
|
||
return n && mt(n, ye(t, 3))
|
||
}),
|
||
(An.forOwnRight = function(n, t) {
|
||
return n && At(n, ye(t, 3))
|
||
}),
|
||
(An.get = Ru),
|
||
(An.gt = ef),
|
||
(An.gte = uf),
|
||
(An.has = function(n, t) {
|
||
return null != n && we(n, t, Rt)
|
||
}),
|
||
(An.hasIn = zu),
|
||
(An.head = qe),
|
||
(An.identity = $u),
|
||
(An.includes = function(n, t, r, e) {
|
||
return (
|
||
(n = su(n) ? n : Uu(n)),
|
||
(r = r && !e ? Eu(r) : 0),
|
||
(e = n.length),
|
||
0 > r && (r = Ui(e + r, 0)),
|
||
ju(n) ? r <= e && -1 < n.indexOf(t, r) : !!e && -1 < v(n, t, r)
|
||
)
|
||
}),
|
||
(An.indexOf = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
return e
|
||
? ((r = null == r ? 0 : Eu(r)),
|
||
0 > r && (r = Ui(e + r, 0)),
|
||
v(n, t, r))
|
||
: -1
|
||
}),
|
||
(An.inRange = function(n, t, r) {
|
||
return (
|
||
(t = Au(t)),
|
||
r === T ? ((r = t), (t = 0)) : (r = Au(r)),
|
||
(n = Su(n)),
|
||
n >= Ci(t, r) && n < Ui(t, r)
|
||
)
|
||
}),
|
||
(An.invoke = kf),
|
||
(An.isArguments = of),
|
||
(An.isArray = ff),
|
||
(An.isArrayBuffer = cf),
|
||
(An.isArrayLike = su),
|
||
(An.isArrayLikeObject = hu),
|
||
(An.isBoolean = function(n) {
|
||
return (
|
||
true === n ||
|
||
false === n ||
|
||
(yu(n) && "[object Boolean]" == Ot(n))
|
||
)
|
||
}),
|
||
(An.isBuffer = af),
|
||
(An.isDate = lf),
|
||
(An.isElement = function(n) {
|
||
return yu(n) && 1 === n.nodeType && !xu(n)
|
||
}),
|
||
(An.isEmpty = function(n) {
|
||
if (null == n) return true
|
||
if (
|
||
su(n) &&
|
||
(ff(n) ||
|
||
typeof n == "string" ||
|
||
typeof n.splice == "function" ||
|
||
af(n) ||
|
||
_f(n) ||
|
||
of(n))
|
||
)
|
||
return !n.length
|
||
var t = vo(n)
|
||
if ("[object Map]" == t || "[object Set]" == t) return !n.size
|
||
if (ze(n)) return !Vt(n).length
|
||
for (var r in n) if (oi.call(n, r)) return false
|
||
return true
|
||
}),
|
||
(An.isEqual = function(n, t) {
|
||
return Mt(n, t)
|
||
}),
|
||
(An.isEqualWith = function(n, t, r) {
|
||
var e = (r = typeof r == "function" ? r : T) ? r(n, t) : T
|
||
return e === T ? Mt(n, t, T, r) : !!e
|
||
}),
|
||
(An.isError = pu),
|
||
(An.isFinite = function(n) {
|
||
return typeof n == "number" && Wi(n)
|
||
}),
|
||
(An.isFunction = _u),
|
||
(An.isInteger = vu),
|
||
(An.isLength = gu),
|
||
(An.isMap = sf),
|
||
(An.isMatch = function(n, t) {
|
||
return n === t || $t(n, t, xe(t))
|
||
}),
|
||
(An.isMatchWith = function(n, t, r) {
|
||
return (r = typeof r == "function" ? r : T), $t(n, t, xe(t), r)
|
||
}),
|
||
(An.isNaN = function(n) {
|
||
return bu(n) && n != +n
|
||
}),
|
||
(An.isNative = function(n) {
|
||
if (go(n))
|
||
throw new Hu(
|
||
"Unsupported core-js use. Try https://npms.io/search?q=ponyfill."
|
||
)
|
||
return Ft(n)
|
||
}),
|
||
(An.isNil = function(n) {
|
||
return null == n
|
||
}),
|
||
(An.isNull = function(n) {
|
||
return null === n
|
||
}),
|
||
(An.isNumber = bu),
|
||
(An.isObject = du),
|
||
(An.isObjectLike = yu),
|
||
(An.isPlainObject = xu),
|
||
(An.isRegExp = hf),
|
||
(An.isSafeInteger = function(n) {
|
||
return vu(n) && -9007199254740991 <= n && 9007199254740991 >= n
|
||
}),
|
||
(An.isSet = pf),
|
||
(An.isString = ju),
|
||
(An.isSymbol = wu),
|
||
(An.isTypedArray = _f),
|
||
(An.isUndefined = function(n) {
|
||
return n === T
|
||
}),
|
||
(An.isWeakMap = function(n) {
|
||
return yu(n) && "[object WeakMap]" == vo(n)
|
||
}),
|
||
(An.isWeakSet = function(n) {
|
||
return yu(n) && "[object WeakSet]" == Ot(n)
|
||
}),
|
||
(An.join = function(n, t) {
|
||
return null == n ? "" : Bi.call(n, t)
|
||
}),
|
||
(An.kebabCase = Lf),
|
||
(An.last = Ve),
|
||
(An.lastIndexOf = function(n, t, r) {
|
||
var e = null == n ? 0 : n.length
|
||
if (!e) return -1
|
||
var u = e
|
||
if (
|
||
(r !== T &&
|
||
((u = Eu(r)), (u = 0 > u ? Ui(e + u, 0) : Ci(u, e - 1))),
|
||
t === t)
|
||
) {
|
||
for (r = u + 1; r-- && n[r] !== t; );
|
||
n = r
|
||
} else n = _(n, d, u, true)
|
||
return n
|
||
}),
|
||
(An.lowerCase = Uf),
|
||
(An.lowerFirst = Cf),
|
||
(An.lt = vf),
|
||
(An.lte = gf),
|
||
(An.max = function(n) {
|
||
return n && n.length ? xt(n, $u, It) : T
|
||
}),
|
||
(An.maxBy = function(n, t) {
|
||
return n && n.length ? xt(n, ye(t, 2), It) : T
|
||
}),
|
||
(An.mean = function(n) {
|
||
return y(n, $u)
|
||
}),
|
||
(An.meanBy = function(n, t) {
|
||
return y(n, ye(t, 2))
|
||
}),
|
||
(An.min = function(n) {
|
||
return n && n.length ? xt(n, $u, Kt) : T
|
||
}),
|
||
(An.minBy = function(n, t) {
|
||
return n && n.length ? xt(n, ye(t, 2), Kt) : T
|
||
}),
|
||
(An.stubArray = qu),
|
||
(An.stubFalse = Vu),
|
||
(An.stubObject = function() {
|
||
return {}
|
||
}),
|
||
(An.stubString = function() {
|
||
return ""
|
||
}),
|
||
(An.stubTrue = function() {
|
||
return true
|
||
}),
|
||
(An.multiply = rc),
|
||
(An.nth = function(n, t) {
|
||
return n && n.length ? Qt(n, Eu(t)) : T
|
||
}),
|
||
(An.noConflict = function() {
|
||
return $n._ === this && ($n._ = si), this
|
||
}),
|
||
(An.noop = Pu),
|
||
(An.now = Go),
|
||
(An.pad = function(n, t, r) {
|
||
n = Iu(n)
|
||
var e = (t = Eu(t)) ? D(n) : 0
|
||
return !t || e >= t
|
||
? n
|
||
: ((t = (t - e) / 2), ne(Ii(t), r) + n + ne(Oi(t), r))
|
||
}),
|
||
(An.padEnd = function(n, t, r) {
|
||
n = Iu(n)
|
||
var e = (t = Eu(t)) ? D(n) : 0
|
||
return t && e < t ? n + ne(t - e, r) : n
|
||
}),
|
||
(An.padStart = function(n, t, r) {
|
||
n = Iu(n)
|
||
var e = (t = Eu(t)) ? D(n) : 0
|
||
return t && e < t ? ne(t - e, r) + n : n
|
||
}),
|
||
(An.parseInt = function(n, t, r) {
|
||
return (
|
||
r || null == t ? (t = 0) : t && (t = +t),
|
||
Mi(Iu(n).replace(on, ""), t || 0)
|
||
)
|
||
}),
|
||
(An.random = function(n, t, r) {
|
||
if (
|
||
(r && typeof r != "boolean" && Oe(n, t, r) && (t = r = T),
|
||
r === T &&
|
||
(typeof t == "boolean"
|
||
? ((r = t), (t = T))
|
||
: typeof n == "boolean" && ((r = n), (n = T))),
|
||
n === T && t === T
|
||
? ((n = 0), (t = 1))
|
||
: ((n = Au(n)), t === T ? ((t = n), (n = 0)) : (t = Au(t))),
|
||
n > t)
|
||
) {
|
||
var e = n
|
||
;(n = t), (t = e)
|
||
}
|
||
return r || n % 1 || t % 1
|
||
? ((r = Ti()),
|
||
Ci(n + r * (t - n + Cn("1e-" + ((r + "").length - 1))), t))
|
||
: ir(n, t)
|
||
}),
|
||
(An.reduce = function(n, t, r) {
|
||
var e = ff(n) ? l : j,
|
||
u = 3 > arguments.length
|
||
return e(n, ye(t, 4), r, u, uo)
|
||
}),
|
||
(An.reduceRight = function(n, t, r) {
|
||
var e = ff(n) ? s : j,
|
||
u = 3 > arguments.length
|
||
return e(n, ye(t, 4), r, u, io)
|
||
}),
|
||
(An.repeat = function(n, t, r) {
|
||
return (t = (r ? Oe(n, t, r) : t === T) ? 1 : Eu(t)), or(Iu(n), t)
|
||
}),
|
||
(An.replace = function() {
|
||
var n = arguments,
|
||
t = Iu(n[0])
|
||
return 3 > n.length ? t : t.replace(n[1], n[2])
|
||
}),
|
||
(An.result = function(n, t, r) {
|
||
t = Sr(t, n)
|
||
var e = -1,
|
||
u = t.length
|
||
for (u || ((u = 1), (n = T)); ++e < u; ) {
|
||
var i = null == n ? T : n[Me(t[e])]
|
||
i === T && ((e = u), (i = r)), (n = _u(i) ? i.call(n) : i)
|
||
}
|
||
return n
|
||
}),
|
||
(An.round = ec),
|
||
(An.runInContext = x),
|
||
(An.sample = function(n) {
|
||
return (ff(n) ? Qn : cr)(n)
|
||
}),
|
||
(An.size = function(n) {
|
||
if (null == n) return 0
|
||
if (su(n)) return ju(n) ? D(n) : n.length
|
||
var t = vo(n)
|
||
return "[object Map]" == t || "[object Set]" == t
|
||
? n.size
|
||
: Vt(n).length
|
||
}),
|
||
(An.snakeCase = Df),
|
||
(An.some = function(n, t, r) {
|
||
var e = ff(n) ? h : pr
|
||
return r && Oe(n, t, r) && (t = T), e(n, ye(t, 3))
|
||
}),
|
||
(An.sortedIndex = function(n, t) {
|
||
return _r(n, t)
|
||
}),
|
||
(An.sortedIndexBy = function(n, t, r) {
|
||
return vr(n, t, ye(r, 2))
|
||
}),
|
||
(An.sortedIndexOf = function(n, t) {
|
||
var r = null == n ? 0 : n.length
|
||
if (r) {
|
||
var e = _r(n, t)
|
||
if (e < r && lu(n[e], t)) return e
|
||
}
|
||
return -1
|
||
}),
|
||
(An.sortedLastIndex = function(n, t) {
|
||
return _r(n, t, true)
|
||
}),
|
||
(An.sortedLastIndexBy = function(n, t, r) {
|
||
return vr(n, t, ye(r, 2), true)
|
||
}),
|
||
(An.sortedLastIndexOf = function(n, t) {
|
||
if (null == n ? 0 : n.length) {
|
||
var r = _r(n, t, true) - 1
|
||
if (lu(n[r], t)) return r
|
||
}
|
||
return -1
|
||
}),
|
||
(An.startCase = Mf),
|
||
(An.startsWith = function(n, t, r) {
|
||
return (
|
||
(n = Iu(n)),
|
||
(r = null == r ? 0 : pt(Eu(r), 0, n.length)),
|
||
(t = yr(t)),
|
||
n.slice(r, r + t.length) == t
|
||
)
|
||
}),
|
||
(An.subtract = uc),
|
||
(An.sum = function(n) {
|
||
return n && n.length ? m(n, $u) : 0
|
||
}),
|
||
(An.sumBy = function(n, t) {
|
||
return n && n.length ? m(n, ye(t, 2)) : 0
|
||
}),
|
||
(An.template = function(n, t, r) {
|
||
var e = An.templateSettings
|
||
r && Oe(n, t, r) && (t = T),
|
||
(n = Iu(n)),
|
||
(t = bf({}, t, e, ce)),
|
||
(r = bf({}, t.imports, e.imports, ce))
|
||
var u,
|
||
i,
|
||
o = Wu(r),
|
||
f = S(r, o),
|
||
c = 0
|
||
r = t.interpolate || jn
|
||
var a = "__p+='"
|
||
r = Xu(
|
||
(t.escape || jn).source +
|
||
"|" +
|
||
r.source +
|
||
"|" +
|
||
(r === Q ? pn : jn).source +
|
||
"|" +
|
||
(t.evaluate || jn).source +
|
||
"|$",
|
||
"g"
|
||
)
|
||
var l = oi.call(t, "sourceURL")
|
||
? "//# sourceURL=" +
|
||
(t.sourceURL + "").replace(/[\r\n]/g, " ") +
|
||
"\n"
|
||
: ""
|
||
if (
|
||
(n.replace(r, function(t, r, e, o, f, l) {
|
||
return (
|
||
e || (e = o),
|
||
(a += n.slice(c, l).replace(wn, z)),
|
||
r && ((u = true), (a += "'+__e(" + r + ")+'")),
|
||
f && ((i = true), (a += "';" + f + ";\n__p+='")),
|
||
e && (a += "'+((__t=(" + e + "))==null?'':__t)+'"),
|
||
(c = l + t.length),
|
||
t
|
||
)
|
||
}),
|
||
(a += "';"),
|
||
(t = oi.call(t, "variable") && t.variable) ||
|
||
(a = "with(obj){" + a + "}"),
|
||
(a = (i ? a.replace(P, "") : a)
|
||
.replace(Z, "$1")
|
||
.replace(q, "$1;")),
|
||
(a =
|
||
"function(" +
|
||
(t || "obj") +
|
||
"){" +
|
||
(t ? "" : "obj||(obj={});") +
|
||
"var __t,__p=''" +
|
||
(u ? ",__e=_.escape" : "") +
|
||
(i
|
||
? ",__j=Array.prototype.join;function print(){__p+=__j.call(arguments,'')}"
|
||
: ";") +
|
||
a +
|
||
"return __p}"),
|
||
(t = Ff(function() {
|
||
return Ju(o, l + "return " + a).apply(T, f)
|
||
})),
|
||
(t.source = a),
|
||
pu(t))
|
||
)
|
||
throw t
|
||
return t
|
||
}),
|
||
(An.times = function(n, t) {
|
||
if (((n = Eu(n)), 1 > n || 9007199254740991 < n)) return []
|
||
var r = 4294967295,
|
||
e = Ci(n, 4294967295)
|
||
for (t = ye(t), n -= 4294967295, e = A(e, t); ++r < n; ) t(r)
|
||
return e
|
||
}),
|
||
(An.toFinite = Au),
|
||
(An.toInteger = Eu),
|
||
(An.toLength = ku),
|
||
(An.toLower = function(n) {
|
||
return Iu(n).toLowerCase()
|
||
}),
|
||
(An.toNumber = Su),
|
||
(An.toSafeInteger = function(n) {
|
||
return n
|
||
? pt(Eu(n), -9007199254740991, 9007199254740991)
|
||
: 0 === n
|
||
? n
|
||
: 0
|
||
}),
|
||
(An.toString = Iu),
|
||
(An.toUpper = function(n) {
|
||
return Iu(n).toUpperCase()
|
||
}),
|
||
(An.trim = function(n, t, r) {
|
||
return (n = Iu(n)) && (r || t === T)
|
||
? n.replace(un, "")
|
||
: n && (t = yr(t))
|
||
? ((n = M(n)),
|
||
(r = M(t)),
|
||
(t = I(n, r)),
|
||
(r = R(n, r) + 1),
|
||
Or(n, t, r).join(""))
|
||
: n
|
||
}),
|
||
(An.trimEnd = function(n, t, r) {
|
||
return (n = Iu(n)) && (r || t === T)
|
||
? n.replace(fn, "")
|
||
: n && (t = yr(t))
|
||
? ((n = M(n)), (t = R(n, M(t)) + 1), Or(n, 0, t).join(""))
|
||
: n
|
||
}),
|
||
(An.trimStart = function(n, t, r) {
|
||
return (n = Iu(n)) && (r || t === T)
|
||
? n.replace(on, "")
|
||
: n && (t = yr(t))
|
||
? ((n = M(n)), (t = I(n, M(t))), Or(n, t).join(""))
|
||
: n
|
||
}),
|
||
(An.truncate = function(n, t) {
|
||
var r = 30,
|
||
e = "..."
|
||
if (du(t))
|
||
var u = "separator" in t ? t.separator : u,
|
||
r = "length" in t ? Eu(t.length) : r,
|
||
e = "omission" in t ? yr(t.omission) : e
|
||
n = Iu(n)
|
||
var i = n.length
|
||
if (Rn.test(n))
|
||
var o = M(n),
|
||
i = o.length
|
||
if (r >= i) return n
|
||
if (((i = r - D(e)), 1 > i)) return e
|
||
if (((r = o ? Or(o, 0, i).join("") : n.slice(0, i)), u === T))
|
||
return r + e
|
||
if ((o && (i += r.length - i), hf(u))) {
|
||
if (n.slice(i).search(u)) {
|
||
var f = r
|
||
for (
|
||
u.global || (u = Xu(u.source, Iu(_n.exec(u)) + "g")),
|
||
u.lastIndex = 0;
|
||
(o = u.exec(f));
|
||
|
||
)
|
||
var c = o.index
|
||
r = r.slice(0, c === T ? i : c)
|
||
}
|
||
} else
|
||
n.indexOf(yr(u), i) != i &&
|
||
((u = r.lastIndexOf(u)), -1 < u && (r = r.slice(0, u)))
|
||
return r + e
|
||
}),
|
||
(An.unescape = function(n) {
|
||
return (n = Iu(n)) && G.test(n) ? n.replace(V, tt) : n
|
||
}),
|
||
(An.uniqueId = function(n) {
|
||
var t = ++fi
|
||
return Iu(n) + t
|
||
}),
|
||
(An.upperCase = Tf),
|
||
(An.upperFirst = $f),
|
||
(An.each = nu),
|
||
(An.eachRight = tu),
|
||
(An.first = qe),
|
||
Nu(
|
||
An,
|
||
(function() {
|
||
var n = {}
|
||
return (
|
||
mt(An, function(t, r) {
|
||
oi.call(An.prototype, r) || (n[r] = t)
|
||
}),
|
||
n
|
||
)
|
||
})(),
|
||
{ chain: false }
|
||
),
|
||
(An.VERSION = "4.17.15"),
|
||
r(
|
||
"bind bindKey curry curryRight partial partialRight".split(" "),
|
||
function(n) {
|
||
An[n].placeholder = An
|
||
}
|
||
),
|
||
r(["drop", "take"], function(n, t) {
|
||
;(Un.prototype[n] = function(r) {
|
||
r = r === T ? 1 : Ui(Eu(r), 0)
|
||
var e = this.__filtered__ && !t ? new Un(this) : this.clone()
|
||
return (
|
||
e.__filtered__
|
||
? (e.__takeCount__ = Ci(r, e.__takeCount__))
|
||
: e.__views__.push({
|
||
size: Ci(r, 4294967295),
|
||
type: n + (0 > e.__dir__ ? "Right" : ""),
|
||
}),
|
||
e
|
||
)
|
||
}),
|
||
(Un.prototype[n + "Right"] = function(t) {
|
||
return this.reverse()
|
||
[n](t)
|
||
.reverse()
|
||
})
|
||
}),
|
||
r(["filter", "map", "takeWhile"], function(n, t) {
|
||
var r = t + 1,
|
||
e = 1 == r || 3 == r
|
||
Un.prototype[n] = function(n) {
|
||
var t = this.clone()
|
||
return (
|
||
t.__iteratees__.push({ iteratee: ye(n, 3), type: r }),
|
||
(t.__filtered__ = t.__filtered__ || e),
|
||
t
|
||
)
|
||
}
|
||
}),
|
||
r(["head", "last"], function(n, t) {
|
||
var r = "take" + (t ? "Right" : "")
|
||
Un.prototype[n] = function() {
|
||
return this[r](1).value()[0]
|
||
}
|
||
}),
|
||
r(["initial", "tail"], function(n, t) {
|
||
var r = "drop" + (t ? "" : "Right")
|
||
Un.prototype[n] = function() {
|
||
return this.__filtered__ ? new Un(this) : this[r](1)
|
||
}
|
||
}),
|
||
(Un.prototype.compact = function() {
|
||
return this.filter($u)
|
||
}),
|
||
(Un.prototype.find = function(n) {
|
||
return this.filter(n).head()
|
||
}),
|
||
(Un.prototype.findLast = function(n) {
|
||
return this.reverse().find(n)
|
||
}),
|
||
(Un.prototype.invokeMap = fr(function(n, t) {
|
||
return typeof n == "function"
|
||
? new Un(this)
|
||
: this.map(function(r) {
|
||
return Lt(r, n, t)
|
||
})
|
||
})),
|
||
(Un.prototype.reject = function(n) {
|
||
return this.filter(au(ye(n)))
|
||
}),
|
||
(Un.prototype.slice = function(n, t) {
|
||
n = Eu(n)
|
||
var r = this
|
||
return r.__filtered__ && (0 < n || 0 > t)
|
||
? new Un(r)
|
||
: (0 > n ? (r = r.takeRight(-n)) : n && (r = r.drop(n)),
|
||
t !== T &&
|
||
((t = Eu(t)),
|
||
(r = 0 > t ? r.dropRight(-t) : r.take(t - n))),
|
||
r)
|
||
}),
|
||
(Un.prototype.takeRightWhile = function(n) {
|
||
return this.reverse()
|
||
.takeWhile(n)
|
||
.reverse()
|
||
}),
|
||
(Un.prototype.toArray = function() {
|
||
return this.take(4294967295)
|
||
}),
|
||
mt(Un.prototype, function(n, t) {
|
||
var r = /^(?:filter|find|map|reject)|While$/.test(t),
|
||
e = /^(?:head|last)$/.test(t),
|
||
u = An[e ? "take" + ("last" == t ? "Right" : "") : t],
|
||
i = e || /^find/.test(t)
|
||
u &&
|
||
(An.prototype[t] = function() {
|
||
function t(n) {
|
||
return (n = u.apply(An, a([n], f))), e && h ? n[0] : n
|
||
}
|
||
var o = this.__wrapped__,
|
||
f = e ? [1] : arguments,
|
||
c = o instanceof Un,
|
||
l = f[0],
|
||
s = c || ff(o)
|
||
s &&
|
||
r &&
|
||
typeof l == "function" &&
|
||
1 != l.length &&
|
||
(c = s = false)
|
||
var h = this.__chain__,
|
||
p = !!this.__actions__.length,
|
||
l = i && !h,
|
||
c = c && !p
|
||
return !i && s
|
||
? ((o = c ? o : new Un(this)),
|
||
(o = n.apply(o, f)),
|
||
o.__actions__.push({ func: Qe, args: [t], thisArg: T }),
|
||
new On(o, h))
|
||
: l && c
|
||
? n.apply(this, f)
|
||
: ((o = this.thru(t)),
|
||
l ? (e ? o.value()[0] : o.value()) : o)
|
||
})
|
||
}),
|
||
r("pop push shift sort splice unshift".split(" "), function(n) {
|
||
var t = ri[n],
|
||
r = /^(?:push|sort|unshift)$/.test(n) ? "tap" : "thru",
|
||
e = /^(?:pop|shift)$/.test(n)
|
||
An.prototype[n] = function() {
|
||
var n = arguments
|
||
if (e && !this.__chain__) {
|
||
var u = this.value()
|
||
return t.apply(ff(u) ? u : [], n)
|
||
}
|
||
return this[r](function(r) {
|
||
return t.apply(ff(r) ? r : [], n)
|
||
})
|
||
}
|
||
}),
|
||
mt(Un.prototype, function(n, t) {
|
||
var r = An[t]
|
||
if (r) {
|
||
var e = r.name + ""
|
||
oi.call(Gi, e) || (Gi[e] = []), Gi[e].push({ name: t, func: r })
|
||
}
|
||
}),
|
||
(Gi[Jr(T, 2).name] = [{ name: "wrapper", func: T }]),
|
||
(Un.prototype.clone = function() {
|
||
var n = new Un(this.__wrapped__)
|
||
return (
|
||
(n.__actions__ = Ur(this.__actions__)),
|
||
(n.__dir__ = this.__dir__),
|
||
(n.__filtered__ = this.__filtered__),
|
||
(n.__iteratees__ = Ur(this.__iteratees__)),
|
||
(n.__takeCount__ = this.__takeCount__),
|
||
(n.__views__ = Ur(this.__views__)),
|
||
n
|
||
)
|
||
}),
|
||
(Un.prototype.reverse = function() {
|
||
if (this.__filtered__) {
|
||
var n = new Un(this)
|
||
;(n.__dir__ = -1), (n.__filtered__ = true)
|
||
} else (n = this.clone()), (n.__dir__ *= -1)
|
||
return n
|
||
}),
|
||
(Un.prototype.value = function() {
|
||
var n,
|
||
t = this.__wrapped__.value(),
|
||
r = this.__dir__,
|
||
e = ff(t),
|
||
u = 0 > r,
|
||
i = e ? t.length : 0
|
||
n = i
|
||
for (
|
||
var o = this.__views__, f = 0, c = -1, a = o.length;
|
||
++c < a;
|
||
|
||
) {
|
||
var l = o[c],
|
||
s = l.size
|
||
switch (l.type) {
|
||
case "drop":
|
||
f += s
|
||
break
|
||
case "dropRight":
|
||
n -= s
|
||
break
|
||
case "take":
|
||
n = Ci(n, f + s)
|
||
break
|
||
case "takeRight":
|
||
f = Ui(f, n - s)
|
||
}
|
||
}
|
||
if (
|
||
((n = { start: f, end: n }),
|
||
(o = n.start),
|
||
(f = n.end),
|
||
(n = f - o),
|
||
(o = u ? f : o - 1),
|
||
(f = this.__iteratees__),
|
||
(c = f.length),
|
||
(a = 0),
|
||
(l = Ci(n, this.__takeCount__)),
|
||
!e || (!u && i == n && l == n))
|
||
)
|
||
return wr(t, this.__actions__)
|
||
e = []
|
||
n: for (; n-- && a < l; ) {
|
||
for (o += r, u = -1, i = t[o]; ++u < c; ) {
|
||
var h = f[u],
|
||
s = h.type,
|
||
h = (0, h.iteratee)(i)
|
||
if (2 == s) i = h
|
||
else if (!h) {
|
||
if (1 == s) continue n
|
||
break n
|
||
}
|
||
}
|
||
e[a++] = i
|
||
}
|
||
return e
|
||
}),
|
||
(An.prototype.at = To),
|
||
(An.prototype.chain = function() {
|
||
return Ye(this)
|
||
}),
|
||
(An.prototype.commit = function() {
|
||
return new On(this.value(), this.__chain__)
|
||
}),
|
||
(An.prototype.next = function() {
|
||
this.__values__ === T && (this.__values__ = mu(this.value()))
|
||
var n = this.__index__ >= this.__values__.length
|
||
return {
|
||
done: n,
|
||
value: n ? T : this.__values__[this.__index__++],
|
||
}
|
||
}),
|
||
(An.prototype.plant = function(n) {
|
||
for (var t, r = this; r instanceof En; ) {
|
||
var e = Fe(r)
|
||
;(e.__index__ = 0),
|
||
(e.__values__ = T),
|
||
t ? (u.__wrapped__ = e) : (t = e)
|
||
var u = e,
|
||
r = r.__wrapped__
|
||
}
|
||
return (u.__wrapped__ = n), t
|
||
}),
|
||
(An.prototype.reverse = function() {
|
||
var n = this.__wrapped__
|
||
return n instanceof Un
|
||
? (this.__actions__.length && (n = new Un(this)),
|
||
(n = n.reverse()),
|
||
n.__actions__.push({ func: Qe, args: [Ge], thisArg: T }),
|
||
new On(n, this.__chain__))
|
||
: this.thru(Ge)
|
||
}),
|
||
(An.prototype.toJSON = An.prototype.valueOf = An.prototype.value = function() {
|
||
return wr(this.__wrapped__, this.__actions__)
|
||
}),
|
||
(An.prototype.first = An.prototype.head),
|
||
wi && (An.prototype[wi] = Xe),
|
||
An
|
||
)
|
||
})()
|
||
Nn ? (((Nn.exports = rt)._ = rt), (Fn._ = rt)) : ($n._ = rt)
|
||
}.call(commonjsGlobal))
|
||
})
|
||
|
||
var _mapping = createCommonjsModule(function(module, exports) {
|
||
/** Used to map aliases to their real names. */
|
||
exports.aliasToReal = {
|
||
// Lodash aliases.
|
||
each: "forEach",
|
||
eachRight: "forEachRight",
|
||
entries: "toPairs",
|
||
entriesIn: "toPairsIn",
|
||
extend: "assignIn",
|
||
extendAll: "assignInAll",
|
||
extendAllWith: "assignInAllWith",
|
||
extendWith: "assignInWith",
|
||
first: "head",
|
||
|
||
// Methods that are curried variants of others.
|
||
conforms: "conformsTo",
|
||
matches: "isMatch",
|
||
property: "get",
|
||
|
||
// Ramda aliases.
|
||
__: "placeholder",
|
||
F: "stubFalse",
|
||
T: "stubTrue",
|
||
all: "every",
|
||
allPass: "overEvery",
|
||
always: "constant",
|
||
any: "some",
|
||
anyPass: "overSome",
|
||
apply: "spread",
|
||
assoc: "set",
|
||
assocPath: "set",
|
||
complement: "negate",
|
||
compose: "flowRight",
|
||
contains: "includes",
|
||
dissoc: "unset",
|
||
dissocPath: "unset",
|
||
dropLast: "dropRight",
|
||
dropLastWhile: "dropRightWhile",
|
||
equals: "isEqual",
|
||
identical: "eq",
|
||
indexBy: "keyBy",
|
||
init: "initial",
|
||
invertObj: "invert",
|
||
juxt: "over",
|
||
omitAll: "omit",
|
||
nAry: "ary",
|
||
path: "get",
|
||
pathEq: "matchesProperty",
|
||
pathOr: "getOr",
|
||
paths: "at",
|
||
pickAll: "pick",
|
||
pipe: "flow",
|
||
pluck: "map",
|
||
prop: "get",
|
||
propEq: "matchesProperty",
|
||
propOr: "getOr",
|
||
props: "at",
|
||
symmetricDifference: "xor",
|
||
symmetricDifferenceBy: "xorBy",
|
||
symmetricDifferenceWith: "xorWith",
|
||
takeLast: "takeRight",
|
||
takeLastWhile: "takeRightWhile",
|
||
unapply: "rest",
|
||
unnest: "flatten",
|
||
useWith: "overArgs",
|
||
where: "conformsTo",
|
||
whereEq: "isMatch",
|
||
zipObj: "zipObject",
|
||
}
|
||
|
||
/** Used to map ary to method names. */
|
||
exports.aryMethod = {
|
||
"1": [
|
||
"assignAll",
|
||
"assignInAll",
|
||
"attempt",
|
||
"castArray",
|
||
"ceil",
|
||
"create",
|
||
"curry",
|
||
"curryRight",
|
||
"defaultsAll",
|
||
"defaultsDeepAll",
|
||
"floor",
|
||
"flow",
|
||
"flowRight",
|
||
"fromPairs",
|
||
"invert",
|
||
"iteratee",
|
||
"memoize",
|
||
"method",
|
||
"mergeAll",
|
||
"methodOf",
|
||
"mixin",
|
||
"nthArg",
|
||
"over",
|
||
"overEvery",
|
||
"overSome",
|
||
"rest",
|
||
"reverse",
|
||
"round",
|
||
"runInContext",
|
||
"spread",
|
||
"template",
|
||
"trim",
|
||
"trimEnd",
|
||
"trimStart",
|
||
"uniqueId",
|
||
"words",
|
||
"zipAll",
|
||
],
|
||
"2": [
|
||
"add",
|
||
"after",
|
||
"ary",
|
||
"assign",
|
||
"assignAllWith",
|
||
"assignIn",
|
||
"assignInAllWith",
|
||
"at",
|
||
"before",
|
||
"bind",
|
||
"bindAll",
|
||
"bindKey",
|
||
"chunk",
|
||
"cloneDeepWith",
|
||
"cloneWith",
|
||
"concat",
|
||
"conformsTo",
|
||
"countBy",
|
||
"curryN",
|
||
"curryRightN",
|
||
"debounce",
|
||
"defaults",
|
||
"defaultsDeep",
|
||
"defaultTo",
|
||
"delay",
|
||
"difference",
|
||
"divide",
|
||
"drop",
|
||
"dropRight",
|
||
"dropRightWhile",
|
||
"dropWhile",
|
||
"endsWith",
|
||
"eq",
|
||
"every",
|
||
"filter",
|
||
"find",
|
||
"findIndex",
|
||
"findKey",
|
||
"findLast",
|
||
"findLastIndex",
|
||
"findLastKey",
|
||
"flatMap",
|
||
"flatMapDeep",
|
||
"flattenDepth",
|
||
"forEach",
|
||
"forEachRight",
|
||
"forIn",
|
||
"forInRight",
|
||
"forOwn",
|
||
"forOwnRight",
|
||
"get",
|
||
"groupBy",
|
||
"gt",
|
||
"gte",
|
||
"has",
|
||
"hasIn",
|
||
"includes",
|
||
"indexOf",
|
||
"intersection",
|
||
"invertBy",
|
||
"invoke",
|
||
"invokeMap",
|
||
"isEqual",
|
||
"isMatch",
|
||
"join",
|
||
"keyBy",
|
||
"lastIndexOf",
|
||
"lt",
|
||
"lte",
|
||
"map",
|
||
"mapKeys",
|
||
"mapValues",
|
||
"matchesProperty",
|
||
"maxBy",
|
||
"meanBy",
|
||
"merge",
|
||
"mergeAllWith",
|
||
"minBy",
|
||
"multiply",
|
||
"nth",
|
||
"omit",
|
||
"omitBy",
|
||
"overArgs",
|
||
"pad",
|
||
"padEnd",
|
||
"padStart",
|
||
"parseInt",
|
||
"partial",
|
||
"partialRight",
|
||
"partition",
|
||
"pick",
|
||
"pickBy",
|
||
"propertyOf",
|
||
"pull",
|
||
"pullAll",
|
||
"pullAt",
|
||
"random",
|
||
"range",
|
||
"rangeRight",
|
||
"rearg",
|
||
"reject",
|
||
"remove",
|
||
"repeat",
|
||
"restFrom",
|
||
"result",
|
||
"sampleSize",
|
||
"some",
|
||
"sortBy",
|
||
"sortedIndex",
|
||
"sortedIndexOf",
|
||
"sortedLastIndex",
|
||
"sortedLastIndexOf",
|
||
"sortedUniqBy",
|
||
"split",
|
||
"spreadFrom",
|
||
"startsWith",
|
||
"subtract",
|
||
"sumBy",
|
||
"take",
|
||
"takeRight",
|
||
"takeRightWhile",
|
||
"takeWhile",
|
||
"tap",
|
||
"throttle",
|
||
"thru",
|
||
"times",
|
||
"trimChars",
|
||
"trimCharsEnd",
|
||
"trimCharsStart",
|
||
"truncate",
|
||
"union",
|
||
"uniqBy",
|
||
"uniqWith",
|
||
"unset",
|
||
"unzipWith",
|
||
"without",
|
||
"wrap",
|
||
"xor",
|
||
"zip",
|
||
"zipObject",
|
||
"zipObjectDeep",
|
||
],
|
||
"3": [
|
||
"assignInWith",
|
||
"assignWith",
|
||
"clamp",
|
||
"differenceBy",
|
||
"differenceWith",
|
||
"findFrom",
|
||
"findIndexFrom",
|
||
"findLastFrom",
|
||
"findLastIndexFrom",
|
||
"getOr",
|
||
"includesFrom",
|
||
"indexOfFrom",
|
||
"inRange",
|
||
"intersectionBy",
|
||
"intersectionWith",
|
||
"invokeArgs",
|
||
"invokeArgsMap",
|
||
"isEqualWith",
|
||
"isMatchWith",
|
||
"flatMapDepth",
|
||
"lastIndexOfFrom",
|
||
"mergeWith",
|
||
"orderBy",
|
||
"padChars",
|
||
"padCharsEnd",
|
||
"padCharsStart",
|
||
"pullAllBy",
|
||
"pullAllWith",
|
||
"rangeStep",
|
||
"rangeStepRight",
|
||
"reduce",
|
||
"reduceRight",
|
||
"replace",
|
||
"set",
|
||
"slice",
|
||
"sortedIndexBy",
|
||
"sortedLastIndexBy",
|
||
"transform",
|
||
"unionBy",
|
||
"unionWith",
|
||
"update",
|
||
"xorBy",
|
||
"xorWith",
|
||
"zipWith",
|
||
],
|
||
"4": ["fill", "setWith", "updateWith"],
|
||
}
|
||
|
||
/** Used to map ary to rearg configs. */
|
||
exports.aryRearg = {
|
||
"2": [1, 0],
|
||
"3": [2, 0, 1],
|
||
"4": [3, 2, 0, 1],
|
||
}
|
||
|
||
/** Used to map method names to their iteratee ary. */
|
||
exports.iterateeAry = {
|
||
dropRightWhile: 1,
|
||
dropWhile: 1,
|
||
every: 1,
|
||
filter: 1,
|
||
find: 1,
|
||
findFrom: 1,
|
||
findIndex: 1,
|
||
findIndexFrom: 1,
|
||
findKey: 1,
|
||
findLast: 1,
|
||
findLastFrom: 1,
|
||
findLastIndex: 1,
|
||
findLastIndexFrom: 1,
|
||
findLastKey: 1,
|
||
flatMap: 1,
|
||
flatMapDeep: 1,
|
||
flatMapDepth: 1,
|
||
forEach: 1,
|
||
forEachRight: 1,
|
||
forIn: 1,
|
||
forInRight: 1,
|
||
forOwn: 1,
|
||
forOwnRight: 1,
|
||
map: 1,
|
||
mapKeys: 1,
|
||
mapValues: 1,
|
||
partition: 1,
|
||
reduce: 2,
|
||
reduceRight: 2,
|
||
reject: 1,
|
||
remove: 1,
|
||
some: 1,
|
||
takeRightWhile: 1,
|
||
takeWhile: 1,
|
||
times: 1,
|
||
transform: 2,
|
||
}
|
||
|
||
/** Used to map method names to iteratee rearg configs. */
|
||
exports.iterateeRearg = {
|
||
mapKeys: [1],
|
||
reduceRight: [1, 0],
|
||
}
|
||
|
||
/** Used to map method names to rearg configs. */
|
||
exports.methodRearg = {
|
||
assignInAllWith: [1, 0],
|
||
assignInWith: [1, 2, 0],
|
||
assignAllWith: [1, 0],
|
||
assignWith: [1, 2, 0],
|
||
differenceBy: [1, 2, 0],
|
||
differenceWith: [1, 2, 0],
|
||
getOr: [2, 1, 0],
|
||
intersectionBy: [1, 2, 0],
|
||
intersectionWith: [1, 2, 0],
|
||
isEqualWith: [1, 2, 0],
|
||
isMatchWith: [2, 1, 0],
|
||
mergeAllWith: [1, 0],
|
||
mergeWith: [1, 2, 0],
|
||
padChars: [2, 1, 0],
|
||
padCharsEnd: [2, 1, 0],
|
||
padCharsStart: [2, 1, 0],
|
||
pullAllBy: [2, 1, 0],
|
||
pullAllWith: [2, 1, 0],
|
||
rangeStep: [1, 2, 0],
|
||
rangeStepRight: [1, 2, 0],
|
||
setWith: [3, 1, 2, 0],
|
||
sortedIndexBy: [2, 1, 0],
|
||
sortedLastIndexBy: [2, 1, 0],
|
||
unionBy: [1, 2, 0],
|
||
unionWith: [1, 2, 0],
|
||
updateWith: [3, 1, 2, 0],
|
||
xorBy: [1, 2, 0],
|
||
xorWith: [1, 2, 0],
|
||
zipWith: [1, 2, 0],
|
||
}
|
||
|
||
/** Used to map method names to spread configs. */
|
||
exports.methodSpread = {
|
||
assignAll: { start: 0 },
|
||
assignAllWith: { start: 0 },
|
||
assignInAll: { start: 0 },
|
||
assignInAllWith: { start: 0 },
|
||
defaultsAll: { start: 0 },
|
||
defaultsDeepAll: { start: 0 },
|
||
invokeArgs: { start: 2 },
|
||
invokeArgsMap: { start: 2 },
|
||
mergeAll: { start: 0 },
|
||
mergeAllWith: { start: 0 },
|
||
partial: { start: 1 },
|
||
partialRight: { start: 1 },
|
||
without: { start: 1 },
|
||
zipAll: { start: 0 },
|
||
}
|
||
|
||
/** Used to identify methods which mutate arrays or objects. */
|
||
exports.mutate = {
|
||
array: {
|
||
fill: true,
|
||
pull: true,
|
||
pullAll: true,
|
||
pullAllBy: true,
|
||
pullAllWith: true,
|
||
pullAt: true,
|
||
remove: true,
|
||
reverse: true,
|
||
},
|
||
object: {
|
||
assign: true,
|
||
assignAll: true,
|
||
assignAllWith: true,
|
||
assignIn: true,
|
||
assignInAll: true,
|
||
assignInAllWith: true,
|
||
assignInWith: true,
|
||
assignWith: true,
|
||
defaults: true,
|
||
defaultsAll: true,
|
||
defaultsDeep: true,
|
||
defaultsDeepAll: true,
|
||
merge: true,
|
||
mergeAll: true,
|
||
mergeAllWith: true,
|
||
mergeWith: true,
|
||
},
|
||
set: {
|
||
set: true,
|
||
setWith: true,
|
||
unset: true,
|
||
update: true,
|
||
updateWith: true,
|
||
},
|
||
}
|
||
|
||
/** Used to map real names to their aliases. */
|
||
exports.realToAlias = (function() {
|
||
var hasOwnProperty = Object.prototype.hasOwnProperty,
|
||
object = exports.aliasToReal,
|
||
result = {}
|
||
|
||
for (var key in object) {
|
||
var value = object[key]
|
||
if (hasOwnProperty.call(result, value)) {
|
||
result[value].push(key)
|
||
} else {
|
||
result[value] = [key]
|
||
}
|
||
}
|
||
return result
|
||
})()
|
||
|
||
/** Used to map method names to other names. */
|
||
exports.remap = {
|
||
assignAll: "assign",
|
||
assignAllWith: "assignWith",
|
||
assignInAll: "assignIn",
|
||
assignInAllWith: "assignInWith",
|
||
curryN: "curry",
|
||
curryRightN: "curryRight",
|
||
defaultsAll: "defaults",
|
||
defaultsDeepAll: "defaultsDeep",
|
||
findFrom: "find",
|
||
findIndexFrom: "findIndex",
|
||
findLastFrom: "findLast",
|
||
findLastIndexFrom: "findLastIndex",
|
||
getOr: "get",
|
||
includesFrom: "includes",
|
||
indexOfFrom: "indexOf",
|
||
invokeArgs: "invoke",
|
||
invokeArgsMap: "invokeMap",
|
||
lastIndexOfFrom: "lastIndexOf",
|
||
mergeAll: "merge",
|
||
mergeAllWith: "mergeWith",
|
||
padChars: "pad",
|
||
padCharsEnd: "padEnd",
|
||
padCharsStart: "padStart",
|
||
propertyOf: "get",
|
||
rangeStep: "range",
|
||
rangeStepRight: "rangeRight",
|
||
restFrom: "rest",
|
||
spreadFrom: "spread",
|
||
trimChars: "trim",
|
||
trimCharsEnd: "trimEnd",
|
||
trimCharsStart: "trimStart",
|
||
zipAll: "zip",
|
||
}
|
||
|
||
/** Used to track methods that skip fixing their arity. */
|
||
exports.skipFixed = {
|
||
castArray: true,
|
||
flow: true,
|
||
flowRight: true,
|
||
iteratee: true,
|
||
mixin: true,
|
||
rearg: true,
|
||
runInContext: true,
|
||
}
|
||
|
||
/** Used to track methods that skip rearranging arguments. */
|
||
exports.skipRearg = {
|
||
add: true,
|
||
assign: true,
|
||
assignIn: true,
|
||
bind: true,
|
||
bindKey: true,
|
||
concat: true,
|
||
difference: true,
|
||
divide: true,
|
||
eq: true,
|
||
gt: true,
|
||
gte: true,
|
||
isEqual: true,
|
||
lt: true,
|
||
lte: true,
|
||
matchesProperty: true,
|
||
merge: true,
|
||
multiply: true,
|
||
overArgs: true,
|
||
partial: true,
|
||
partialRight: true,
|
||
propertyOf: true,
|
||
random: true,
|
||
range: true,
|
||
rangeRight: true,
|
||
subtract: true,
|
||
zip: true,
|
||
zipObject: true,
|
||
zipObjectDeep: true,
|
||
}
|
||
})
|
||
var _mapping_1 = _mapping.aliasToReal
|
||
var _mapping_2 = _mapping.aryMethod
|
||
var _mapping_3 = _mapping.aryRearg
|
||
var _mapping_4 = _mapping.iterateeAry
|
||
var _mapping_5 = _mapping.iterateeRearg
|
||
var _mapping_6 = _mapping.methodRearg
|
||
var _mapping_7 = _mapping.methodSpread
|
||
var _mapping_8 = _mapping.mutate
|
||
var _mapping_9 = _mapping.realToAlias
|
||
var _mapping_10 = _mapping.remap
|
||
var _mapping_11 = _mapping.skipFixed
|
||
var _mapping_12 = _mapping.skipRearg
|
||
|
||
/**
|
||
* The default argument placeholder value for methods.
|
||
*
|
||
* @type {Object}
|
||
*/
|
||
var placeholder = {}
|
||
|
||
/** Built-in value reference. */
|
||
var push = Array.prototype.push
|
||
|
||
/**
|
||
* Creates a function, with an arity of `n`, that invokes `func` with the
|
||
* arguments it receives.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to wrap.
|
||
* @param {number} n The arity of the new function.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseArity(func, n) {
|
||
return n == 2
|
||
? function(a, b) {
|
||
return func.apply(undefined, arguments)
|
||
}
|
||
: function(a) {
|
||
return func.apply(undefined, arguments)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes `func`, with up to `n` arguments, ignoring
|
||
* any additional arguments.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to cap arguments for.
|
||
* @param {number} n The arity cap.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseAry(func, n) {
|
||
return n == 2
|
||
? function(a, b) {
|
||
return func(a, b)
|
||
}
|
||
: function(a) {
|
||
return func(a)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates a clone of `array`.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to clone.
|
||
* @returns {Array} Returns the cloned array.
|
||
*/
|
||
function cloneArray(array) {
|
||
var length = array ? array.length : 0,
|
||
result = Array(length)
|
||
|
||
while (length--) {
|
||
result[length] = array[length]
|
||
}
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* Creates a function that clones a given object using the assignment `func`.
|
||
*
|
||
* @private
|
||
* @param {Function} func The assignment function.
|
||
* @returns {Function} Returns the new cloner function.
|
||
*/
|
||
function createCloner(func) {
|
||
return function(object) {
|
||
return func({}, object)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A specialized version of `_.spread` which flattens the spread array into
|
||
* the arguments of the invoked `func`.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to spread arguments over.
|
||
* @param {number} start The start position of the spread.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function flatSpread(func, start) {
|
||
return function() {
|
||
var length = arguments.length,
|
||
lastIndex = length - 1,
|
||
args = Array(length)
|
||
|
||
while (length--) {
|
||
args[length] = arguments[length]
|
||
}
|
||
var array = args[start],
|
||
otherArgs = args.slice(0, start)
|
||
|
||
if (array) {
|
||
push.apply(otherArgs, array)
|
||
}
|
||
if (start != lastIndex) {
|
||
push.apply(otherArgs, args.slice(start + 1))
|
||
}
|
||
return func.apply(this, otherArgs)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates a function that wraps `func` and uses `cloner` to clone the first
|
||
* argument it receives.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to wrap.
|
||
* @param {Function} cloner The function to clone arguments.
|
||
* @returns {Function} Returns the new immutable function.
|
||
*/
|
||
function wrapImmutable(func, cloner) {
|
||
return function() {
|
||
var length = arguments.length
|
||
if (!length) {
|
||
return
|
||
}
|
||
var args = Array(length)
|
||
while (length--) {
|
||
args[length] = arguments[length]
|
||
}
|
||
var result = (args[0] = cloner.apply(undefined, args))
|
||
func.apply(undefined, args)
|
||
return result
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The base implementation of `convert` which accepts a `util` object of methods
|
||
* required to perform conversions.
|
||
*
|
||
* @param {Object} util The util object.
|
||
* @param {string} name The name of the function to convert.
|
||
* @param {Function} func The function to convert.
|
||
* @param {Object} [options] The options object.
|
||
* @param {boolean} [options.cap=true] Specify capping iteratee arguments.
|
||
* @param {boolean} [options.curry=true] Specify currying.
|
||
* @param {boolean} [options.fixed=true] Specify fixed arity.
|
||
* @param {boolean} [options.immutable=true] Specify immutable operations.
|
||
* @param {boolean} [options.rearg=true] Specify rearranging arguments.
|
||
* @returns {Function|Object} Returns the converted function or object.
|
||
*/
|
||
function baseConvert(util, name, func, options) {
|
||
var isLib = typeof name == "function",
|
||
isObj = name === Object(name)
|
||
|
||
if (isObj) {
|
||
options = func
|
||
func = name
|
||
name = undefined
|
||
}
|
||
if (func == null) {
|
||
throw new TypeError()
|
||
}
|
||
options || (options = {})
|
||
|
||
var config = {
|
||
cap: "cap" in options ? options.cap : true,
|
||
curry: "curry" in options ? options.curry : true,
|
||
fixed: "fixed" in options ? options.fixed : true,
|
||
immutable: "immutable" in options ? options.immutable : true,
|
||
rearg: "rearg" in options ? options.rearg : true,
|
||
}
|
||
|
||
var defaultHolder = isLib ? func : placeholder,
|
||
forceCurry = "curry" in options && options.curry,
|
||
forceFixed = "fixed" in options && options.fixed,
|
||
forceRearg = "rearg" in options && options.rearg,
|
||
pristine = isLib ? func.runInContext() : undefined
|
||
|
||
var helpers = isLib
|
||
? func
|
||
: {
|
||
ary: util.ary,
|
||
assign: util.assign,
|
||
clone: util.clone,
|
||
curry: util.curry,
|
||
forEach: util.forEach,
|
||
isArray: util.isArray,
|
||
isError: util.isError,
|
||
isFunction: util.isFunction,
|
||
isWeakMap: util.isWeakMap,
|
||
iteratee: util.iteratee,
|
||
keys: util.keys,
|
||
rearg: util.rearg,
|
||
toInteger: util.toInteger,
|
||
toPath: util.toPath,
|
||
}
|
||
|
||
var ary = helpers.ary,
|
||
assign = helpers.assign,
|
||
clone = helpers.clone,
|
||
curry = helpers.curry,
|
||
each = helpers.forEach,
|
||
isArray = helpers.isArray,
|
||
isError = helpers.isError,
|
||
isFunction = helpers.isFunction,
|
||
isWeakMap = helpers.isWeakMap,
|
||
keys = helpers.keys,
|
||
rearg = helpers.rearg,
|
||
toInteger = helpers.toInteger,
|
||
toPath = helpers.toPath
|
||
|
||
var aryMethodKeys = keys(_mapping.aryMethod)
|
||
|
||
var wrappers = {
|
||
castArray: function(castArray) {
|
||
return function() {
|
||
var value = arguments[0]
|
||
return isArray(value)
|
||
? castArray(cloneArray(value))
|
||
: castArray.apply(undefined, arguments)
|
||
}
|
||
},
|
||
iteratee: function(iteratee) {
|
||
return function() {
|
||
var func = arguments[0],
|
||
arity = arguments[1],
|
||
result = iteratee(func, arity),
|
||
length = result.length
|
||
|
||
if (config.cap && typeof arity == "number") {
|
||
arity = arity > 2 ? arity - 2 : 1
|
||
return length && length <= arity ? result : baseAry(result, arity)
|
||
}
|
||
return result
|
||
}
|
||
},
|
||
mixin: function(mixin) {
|
||
return function(source) {
|
||
var func = this
|
||
if (!isFunction(func)) {
|
||
return mixin(func, Object(source))
|
||
}
|
||
var pairs = []
|
||
each(keys(source), function(key) {
|
||
if (isFunction(source[key])) {
|
||
pairs.push([key, func.prototype[key]])
|
||
}
|
||
})
|
||
|
||
mixin(func, Object(source))
|
||
|
||
each(pairs, function(pair) {
|
||
var value = pair[1]
|
||
if (isFunction(value)) {
|
||
func.prototype[pair[0]] = value
|
||
} else {
|
||
delete func.prototype[pair[0]]
|
||
}
|
||
})
|
||
return func
|
||
}
|
||
},
|
||
nthArg: function(nthArg) {
|
||
return function(n) {
|
||
var arity = n < 0 ? 1 : toInteger(n) + 1
|
||
return curry(nthArg(n), arity)
|
||
}
|
||
},
|
||
rearg: function(rearg) {
|
||
return function(func, indexes) {
|
||
var arity = indexes ? indexes.length : 0
|
||
return curry(rearg(func, indexes), arity)
|
||
}
|
||
},
|
||
runInContext: function(runInContext) {
|
||
return function(context) {
|
||
return baseConvert(util, runInContext(context), options)
|
||
}
|
||
},
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* Casts `func` to a function with an arity capped iteratee if needed.
|
||
*
|
||
* @private
|
||
* @param {string} name The name of the function to inspect.
|
||
* @param {Function} func The function to inspect.
|
||
* @returns {Function} Returns the cast function.
|
||
*/
|
||
function castCap(name, func) {
|
||
if (config.cap) {
|
||
var indexes = _mapping.iterateeRearg[name]
|
||
if (indexes) {
|
||
return iterateeRearg(func, indexes)
|
||
}
|
||
var n = !isLib && _mapping.iterateeAry[name]
|
||
if (n) {
|
||
return iterateeAry(func, n)
|
||
}
|
||
}
|
||
return func
|
||
}
|
||
|
||
/**
|
||
* Casts `func` to a curried function if needed.
|
||
*
|
||
* @private
|
||
* @param {string} name The name of the function to inspect.
|
||
* @param {Function} func The function to inspect.
|
||
* @param {number} n The arity of `func`.
|
||
* @returns {Function} Returns the cast function.
|
||
*/
|
||
function castCurry(name, func, n) {
|
||
return forceCurry || (config.curry && n > 1) ? curry(func, n) : func
|
||
}
|
||
|
||
/**
|
||
* Casts `func` to a fixed arity function if needed.
|
||
*
|
||
* @private
|
||
* @param {string} name The name of the function to inspect.
|
||
* @param {Function} func The function to inspect.
|
||
* @param {number} n The arity cap.
|
||
* @returns {Function} Returns the cast function.
|
||
*/
|
||
function castFixed(name, func, n) {
|
||
if (config.fixed && (forceFixed || !_mapping.skipFixed[name])) {
|
||
var data = _mapping.methodSpread[name],
|
||
start = data && data.start
|
||
|
||
return start === undefined ? ary(func, n) : flatSpread(func, start)
|
||
}
|
||
return func
|
||
}
|
||
|
||
/**
|
||
* Casts `func` to an rearged function if needed.
|
||
*
|
||
* @private
|
||
* @param {string} name The name of the function to inspect.
|
||
* @param {Function} func The function to inspect.
|
||
* @param {number} n The arity of `func`.
|
||
* @returns {Function} Returns the cast function.
|
||
*/
|
||
function castRearg(name, func, n) {
|
||
return config.rearg && n > 1 && (forceRearg || !_mapping.skipRearg[name])
|
||
? rearg(func, _mapping.methodRearg[name] || _mapping.aryRearg[n])
|
||
: func
|
||
}
|
||
|
||
/**
|
||
* Creates a clone of `object` by `path`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to clone.
|
||
* @param {Array|string} path The path to clone by.
|
||
* @returns {Object} Returns the cloned object.
|
||
*/
|
||
function cloneByPath(object, path) {
|
||
path = toPath(path)
|
||
|
||
var index = -1,
|
||
length = path.length,
|
||
lastIndex = length - 1,
|
||
result = clone(Object(object)),
|
||
nested = result
|
||
|
||
while (nested != null && ++index < length) {
|
||
var key = path[index],
|
||
value = nested[key]
|
||
|
||
if (
|
||
value != null &&
|
||
!(isFunction(value) || isError(value) || isWeakMap(value))
|
||
) {
|
||
nested[key] = clone(index == lastIndex ? value : Object(value))
|
||
}
|
||
nested = nested[key]
|
||
}
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* Converts `lodash` to an immutable auto-curried iteratee-first data-last
|
||
* version with conversion `options` applied.
|
||
*
|
||
* @param {Object} [options] The options object. See `baseConvert` for more details.
|
||
* @returns {Function} Returns the converted `lodash`.
|
||
*/
|
||
function convertLib(options) {
|
||
return _.runInContext.convert(options)(undefined)
|
||
}
|
||
|
||
/**
|
||
* Create a converter function for `func` of `name`.
|
||
*
|
||
* @param {string} name The name of the function to convert.
|
||
* @param {Function} func The function to convert.
|
||
* @returns {Function} Returns the new converter function.
|
||
*/
|
||
function createConverter(name, func) {
|
||
var realName = _mapping.aliasToReal[name] || name,
|
||
methodName = _mapping.remap[realName] || realName,
|
||
oldOptions = options
|
||
|
||
return function(options) {
|
||
var newUtil = isLib ? pristine : helpers,
|
||
newFunc = isLib ? pristine[methodName] : func,
|
||
newOptions = assign(assign({}, oldOptions), options)
|
||
|
||
return baseConvert(newUtil, realName, newFunc, newOptions)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates a function that wraps `func` to invoke its iteratee, with up to `n`
|
||
* arguments, ignoring any additional arguments.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to cap iteratee arguments for.
|
||
* @param {number} n The arity cap.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function iterateeAry(func, n) {
|
||
return overArg(func, function(func) {
|
||
return typeof func == "function" ? baseAry(func, n) : func
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Creates a function that wraps `func` to invoke its iteratee 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.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to rearrange iteratee arguments for.
|
||
* @param {number[]} indexes The arranged argument indexes.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function iterateeRearg(func, indexes) {
|
||
return overArg(func, function(func) {
|
||
var n = indexes.length
|
||
return baseArity(rearg(baseAry(func, n), indexes), n)
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes `func` with its first 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() {
|
||
var length = arguments.length
|
||
if (!length) {
|
||
return func()
|
||
}
|
||
var args = Array(length)
|
||
while (length--) {
|
||
args[length] = arguments[length]
|
||
}
|
||
var index = config.rearg ? 0 : length - 1
|
||
args[index] = transform(args[index])
|
||
return func.apply(undefined, args)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates a function that wraps `func` and applys the conversions
|
||
* rules by `name`.
|
||
*
|
||
* @private
|
||
* @param {string} name The name of the function to wrap.
|
||
* @param {Function} func The function to wrap.
|
||
* @returns {Function} Returns the converted function.
|
||
*/
|
||
function wrap(name, func, placeholder) {
|
||
var result,
|
||
realName = _mapping.aliasToReal[name] || name,
|
||
wrapped = func,
|
||
wrapper = wrappers[realName]
|
||
|
||
if (wrapper) {
|
||
wrapped = wrapper(func)
|
||
} else if (config.immutable) {
|
||
if (_mapping.mutate.array[realName]) {
|
||
wrapped = wrapImmutable(func, cloneArray)
|
||
} else if (_mapping.mutate.object[realName]) {
|
||
wrapped = wrapImmutable(func, createCloner(func))
|
||
} else if (_mapping.mutate.set[realName]) {
|
||
wrapped = wrapImmutable(func, cloneByPath)
|
||
}
|
||
}
|
||
each(aryMethodKeys, function(aryKey) {
|
||
each(_mapping.aryMethod[aryKey], function(otherName) {
|
||
if (realName == otherName) {
|
||
var data = _mapping.methodSpread[realName],
|
||
afterRearg = data && data.afterRearg
|
||
|
||
result = afterRearg
|
||
? castFixed(
|
||
realName,
|
||
castRearg(realName, wrapped, aryKey),
|
||
aryKey
|
||
)
|
||
: castRearg(
|
||
realName,
|
||
castFixed(realName, wrapped, aryKey),
|
||
aryKey
|
||
)
|
||
|
||
result = castCap(realName, result)
|
||
result = castCurry(realName, result, aryKey)
|
||
return false
|
||
}
|
||
})
|
||
return !result
|
||
})
|
||
|
||
result || (result = wrapped)
|
||
if (result == func) {
|
||
result = forceCurry
|
||
? curry(result, 1)
|
||
: function() {
|
||
return func.apply(this, arguments)
|
||
}
|
||
}
|
||
result.convert = createConverter(realName, func)
|
||
result.placeholder = func.placeholder = placeholder
|
||
|
||
return result
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
if (!isObj) {
|
||
return wrap(name, func, defaultHolder)
|
||
}
|
||
var _ = func
|
||
|
||
// Convert methods by ary cap.
|
||
var pairs = []
|
||
each(aryMethodKeys, function(aryKey) {
|
||
each(_mapping.aryMethod[aryKey], function(key) {
|
||
var func = _[_mapping.remap[key] || key]
|
||
if (func) {
|
||
pairs.push([key, wrap(key, func, _)])
|
||
}
|
||
})
|
||
})
|
||
|
||
// Convert remaining methods.
|
||
each(keys(_), function(key) {
|
||
var func = _[key]
|
||
if (typeof func == "function") {
|
||
var length = pairs.length
|
||
while (length--) {
|
||
if (pairs[length][0] == key) {
|
||
return
|
||
}
|
||
}
|
||
func.convert = createConverter(key, func)
|
||
pairs.push([key, func])
|
||
}
|
||
})
|
||
|
||
// Assign to `_` leaving `_.prototype` unchanged to allow chaining.
|
||
each(pairs, function(pair) {
|
||
_[pair[0]] = pair[1]
|
||
})
|
||
|
||
_.convert = convertLib
|
||
_.placeholder = _
|
||
|
||
// Assign aliases.
|
||
each(keys(_), function(key) {
|
||
each(_mapping.realToAlias[key] || [], function(alias) {
|
||
_[alias] = _[key]
|
||
})
|
||
})
|
||
|
||
return _
|
||
}
|
||
|
||
var _baseConvert = baseConvert
|
||
|
||
var _ = lodash_min.runInContext()
|
||
var fp = _baseConvert(_, _)
|
||
var fp_1 = fp.find
|
||
var fp_2 = fp.isUndefined
|
||
var fp_3 = fp.split
|
||
var fp_4 = fp.last
|
||
var fp_5 = fp.union
|
||
var fp_6 = fp.reduce
|
||
var fp_7 = fp.isObject
|
||
var fp_8 = fp.cloneDeep
|
||
var fp_9 = fp.some
|
||
var fp_10 = fp.isArray
|
||
var fp_11 = fp.map
|
||
var fp_12 = fp.filter
|
||
var fp_13 = fp.keys
|
||
var fp_14 = fp.isFunction
|
||
var fp_15 = fp.isEmpty
|
||
var fp_16 = fp.countBy
|
||
var fp_17 = fp.join
|
||
var fp_18 = fp.includes
|
||
var fp_19 = fp.flatten
|
||
var fp_20 = fp.constant
|
||
var fp_21 = fp.first
|
||
var fp_22 = fp.intersection
|
||
var fp_23 = fp.take
|
||
var fp_24 = fp.has
|
||
var fp_25 = fp.mapValues
|
||
var fp_26 = fp.isString
|
||
var fp_27 = fp.isBoolean
|
||
var fp_28 = fp.isNull
|
||
var fp_29 = fp.isNumber
|
||
var fp_30 = fp.isObjectLike
|
||
var fp_31 = fp.isDate
|
||
var fp_32 = fp.clone
|
||
var fp_33 = fp.values
|
||
var fp_34 = fp.keyBy
|
||
var fp_35 = fp.isNaN
|
||
var fp_36 = fp.isInteger
|
||
var fp_37 = fp.toNumber
|
||
|
||
var lodash = createCommonjsModule(function(module, exports) {
|
||
;(function() {
|
||
/** Used as a safe reference for `undefined` in pre-ES5 environments. */
|
||
var undefined$1
|
||
|
||
/** Used as the semantic version number. */
|
||
var VERSION = "4.17.15"
|
||
|
||
/** 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"
|
||
|
||
/** 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.7976931348623157e308,
|
||
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 and trailing whitespace. */
|
||
var reTrim = /^\s+|\s+$/g,
|
||
reTrimStart = /^\s+/,
|
||
reTrimEnd = /\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 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.
|
||
À: "A",
|
||
Á: "A",
|
||
Â: "A",
|
||
Ã: "A",
|
||
Ä: "A",
|
||
Å: "A",
|
||
à: "a",
|
||
á: "a",
|
||
â: "a",
|
||
ã: "a",
|
||
ä: "a",
|
||
å: "a",
|
||
Ç: "C",
|
||
ç: "c",
|
||
Ð: "D",
|
||
ð: "d",
|
||
È: "E",
|
||
É: "E",
|
||
Ê: "E",
|
||
Ë: "E",
|
||
è: "e",
|
||
é: "e",
|
||
ê: "e",
|
||
ë: "e",
|
||
Ì: "I",
|
||
Í: "I",
|
||
Î: "I",
|
||
Ï: "I",
|
||
ì: "i",
|
||
í: "i",
|
||
î: "i",
|
||
ï: "i",
|
||
Ñ: "N",
|
||
ñ: "n",
|
||
Ò: "O",
|
||
Ó: "O",
|
||
Ô: "O",
|
||
Õ: "O",
|
||
Ö: "O",
|
||
Ø: "O",
|
||
ò: "o",
|
||
ó: "o",
|
||
ô: "o",
|
||
õ: "o",
|
||
ö: "o",
|
||
ø: "o",
|
||
Ù: "U",
|
||
Ú: "U",
|
||
Û: "U",
|
||
Ü: "U",
|
||
ù: "u",
|
||
ú: "u",
|
||
û: "u",
|
||
ü: "u",
|
||
Ý: "Y",
|
||
ý: "y",
|
||
ÿ: "y",
|
||
Æ: "Ae",
|
||
æ: "ae",
|
||
Þ: "Th",
|
||
þ: "th",
|
||
ß: "ss",
|
||
// Latin Extended-A block.
|
||
Ā: "A",
|
||
Ă: "A",
|
||
Ą: "A",
|
||
ā: "a",
|
||
ă: "a",
|
||
ą: "a",
|
||
Ć: "C",
|
||
Ĉ: "C",
|
||
Ċ: "C",
|
||
Č: "C",
|
||
ć: "c",
|
||
ĉ: "c",
|
||
ċ: "c",
|
||
č: "c",
|
||
Ď: "D",
|
||
Đ: "D",
|
||
ď: "d",
|
||
đ: "d",
|
||
Ē: "E",
|
||
Ĕ: "E",
|
||
Ė: "E",
|
||
Ę: "E",
|
||
Ě: "E",
|
||
ē: "e",
|
||
ĕ: "e",
|
||
ė: "e",
|
||
ę: "e",
|
||
ě: "e",
|
||
Ĝ: "G",
|
||
Ğ: "G",
|
||
Ġ: "G",
|
||
Ģ: "G",
|
||
ĝ: "g",
|
||
ğ: "g",
|
||
ġ: "g",
|
||
ģ: "g",
|
||
Ĥ: "H",
|
||
Ħ: "H",
|
||
ĥ: "h",
|
||
ħ: "h",
|
||
Ĩ: "I",
|
||
Ī: "I",
|
||
Ĭ: "I",
|
||
Į: "I",
|
||
İ: "I",
|
||
ĩ: "i",
|
||
ī: "i",
|
||
ĭ: "i",
|
||
į: "i",
|
||
ı: "i",
|
||
Ĵ: "J",
|
||
ĵ: "j",
|
||
Ķ: "K",
|
||
ķ: "k",
|
||
ĸ: "k",
|
||
Ĺ: "L",
|
||
Ļ: "L",
|
||
Ľ: "L",
|
||
Ŀ: "L",
|
||
Ł: "L",
|
||
ĺ: "l",
|
||
ļ: "l",
|
||
ľ: "l",
|
||
ŀ: "l",
|
||
ł: "l",
|
||
Ń: "N",
|
||
Ņ: "N",
|
||
Ň: "N",
|
||
Ŋ: "N",
|
||
ń: "n",
|
||
ņ: "n",
|
||
ň: "n",
|
||
ŋ: "n",
|
||
Ō: "O",
|
||
Ŏ: "O",
|
||
Ő: "O",
|
||
ō: "o",
|
||
ŏ: "o",
|
||
ő: "o",
|
||
Ŕ: "R",
|
||
Ŗ: "R",
|
||
Ř: "R",
|
||
ŕ: "r",
|
||
ŗ: "r",
|
||
ř: "r",
|
||
Ś: "S",
|
||
Ŝ: "S",
|
||
Ş: "S",
|
||
Š: "S",
|
||
ś: "s",
|
||
ŝ: "s",
|
||
ş: "s",
|
||
š: "s",
|
||
Ţ: "T",
|
||
Ť: "T",
|
||
Ŧ: "T",
|
||
ţ: "t",
|
||
ť: "t",
|
||
ŧ: "t",
|
||
Ũ: "U",
|
||
Ū: "U",
|
||
Ŭ: "U",
|
||
Ů: "U",
|
||
Ű: "U",
|
||
Ų: "U",
|
||
ũ: "u",
|
||
ū: "u",
|
||
ŭ: "u",
|
||
ů: "u",
|
||
ű: "u",
|
||
ų: "u",
|
||
Ŵ: "W",
|
||
ŵ: "w",
|
||
Ŷ: "Y",
|
||
ŷ: "y",
|
||
Ÿ: "Y",
|
||
Ź: "Z",
|
||
Ż: "Z",
|
||
Ž: "Z",
|
||
ź: "z",
|
||
ż: "z",
|
||
ž: "z",
|
||
IJ: "IJ",
|
||
ij: "ij",
|
||
Œ: "Oe",
|
||
œ: "oe",
|
||
ʼn: "'n",
|
||
ſ: "s",
|
||
}
|
||
|
||
/** Used to map characters to HTML entities. */
|
||
var htmlEscapes = {
|
||
"&": "&",
|
||
"<": "<",
|
||
">": ">",
|
||
'"': """,
|
||
"'": "'",
|
||
}
|
||
|
||
/** Used to map HTML entities to characters. */
|
||
var htmlUnescapes = {
|
||
"&": "&",
|
||
"<": "<",
|
||
">": ">",
|
||
""": '"',
|
||
"'": "'",
|
||
}
|
||
|
||
/** Used to escape characters for inclusion in compiled string literals. */
|
||
var stringEscapes = {
|
||
"\\": "\\",
|
||
"'": "'",
|
||
"\n": "n",
|
||
"\r": "r",
|
||
"\u2028": "u2028",
|
||
"\u2029": "u2029",
|
||
}
|
||
|
||
/** Built-in method references without a dependency on `root`. */
|
||
var freeParseFloat = parseFloat,
|
||
freeParseInt = parseInt
|
||
|
||
/** Detect free variable `global` from Node.js. */
|
||
var freeGlobal =
|
||
typeof commonjsGlobal == "object" &&
|
||
commonjsGlobal &&
|
||
commonjsGlobal.Object === Object &&
|
||
commonjsGlobal
|
||
|
||
/** Detect free variable `self`. */
|
||
var freeSelf =
|
||
typeof self == "object" && self && self.Object === Object && self
|
||
|
||
/** Used as a reference to the global object. */
|
||
var root = freeGlobal || freeSelf || Function("return this")()
|
||
|
||
/** Detect free variable `exports`. */
|
||
var freeExports = exports && !exports.nodeType && exports
|
||
|
||
/** Detect free variable `module`. */
|
||
var freeModule =
|
||
freeExports &&
|
||
"object" == "object" &&
|
||
module &&
|
||
!module.nodeType &&
|
||
module
|
||
|
||
/** Detect the popular CommonJS extension `module.exports`. */
|
||
var moduleExports = freeModule && freeModule.exports === freeExports
|
||
|
||
/** Detect free variable `process` from Node.js. */
|
||
var freeProcess = moduleExports && freeGlobal.process
|
||
|
||
/** Used to access faster Node.js helpers. */
|
||
var nodeUtil = (function() {
|
||
try {
|
||
// Use `util.types` for Node.js 10+.
|
||
var types =
|
||
freeModule && freeModule.require && freeModule.require("util").types
|
||
|
||
if (types) {
|
||
return types
|
||
}
|
||
|
||
// Legacy `process.binding('util')` for Node.js < 10.
|
||
return (
|
||
freeProcess && freeProcess.binding && freeProcess.binding("util")
|
||
)
|
||
} catch (e) {}
|
||
})()
|
||
|
||
/* Node.js helper references. */
|
||
var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
|
||
nodeIsDate = nodeUtil && nodeUtil.isDate,
|
||
nodeIsMap = nodeUtil && nodeUtil.isMap,
|
||
nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
|
||
nodeIsSet = nodeUtil && nodeUtil.isSet,
|
||
nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* A faster alternative to `Function#apply`, this function invokes `func`
|
||
* with the `this` binding of `thisArg` and the arguments of `args`.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to invoke.
|
||
* @param {*} thisArg The `this` binding of `func`.
|
||
* @param {Array} args The arguments to invoke `func` with.
|
||
* @returns {*} Returns the result of `func`.
|
||
*/
|
||
function apply(func, thisArg, args) {
|
||
switch (args.length) {
|
||
case 0:
|
||
return func.call(thisArg)
|
||
case 1:
|
||
return func.call(thisArg, args[0])
|
||
case 2:
|
||
return func.call(thisArg, args[0], args[1])
|
||
case 3:
|
||
return func.call(thisArg, args[0], args[1], args[2])
|
||
}
|
||
return func.apply(thisArg, args)
|
||
}
|
||
|
||
/**
|
||
* A specialized version of `baseAggregator` for arrays.
|
||
*
|
||
* @private
|
||
* @param {Array} [array] The array to iterate over.
|
||
* @param {Function} setter The function to set `accumulator` values.
|
||
* @param {Function} iteratee The iteratee to transform keys.
|
||
* @param {Object} accumulator The initial aggregated object.
|
||
* @returns {Function} Returns `accumulator`.
|
||
*/
|
||
function arrayAggregator(array, setter, iteratee, accumulator) {
|
||
var index = -1,
|
||
length = array == null ? 0 : array.length
|
||
|
||
while (++index < 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 `_.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 `_.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) {
|
||
var index = -1
|
||
iteratees = arrayMap(
|
||
iteratees.length ? iteratees : [identity],
|
||
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 (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) {
|
||
value = iteratee(value)
|
||
|
||
var low = 0,
|
||
high = array == null ? 0 : array.length,
|
||
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
|
||
}
|
||
// Assume cyclic values are equal.
|
||
var stacked = stack.get(array)
|
||
if (stacked && stack.get(other)) {
|
||
return stacked == other
|
||
}
|
||
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
|
||
}
|
||
}
|
||
// Assume cyclic values are equal.
|
||
var stacked = stack.get(object)
|
||
if (stacked && stack.get(other)) {
|
||
return stacked == other
|
||
}
|
||
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']
|
||
*/
|
||
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': 40 },
|
||
* { 'user': 'barney', 'age': 34 }
|
||
* ];
|
||
*
|
||
* _.sortBy(users, [function(o) { return o.user; }]);
|
||
* // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
|
||
*
|
||
* _.sortBy(users, ['user', 'age']);
|
||
* // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['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 '<p>' + func(text) + '</p>';
|
||
* });
|
||
*
|
||
* p('fred, barney, & pebbles');
|
||
* // => '<p>fred, barney, & pebbles</p>'
|
||
*/
|
||
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('<body>');
|
||
* // => 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 = value.replace(reTrim, "")
|
||
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('<b><%- value %></b>');
|
||
* compiled({ 'value': '<script>' });
|
||
* // => '<b><script></b>'
|
||
*
|
||
* // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
|
||
* var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
|
||
* compiled({ 'users': ['fred', 'barney'] });
|
||
* // => '<li>fred</li><li>barney</li>'
|
||
*
|
||
* // Use the internal `print` function in "evaluate" delimiters.
|
||
* var compiled = _.template('<% print("hello " + user); %>!');
|
||
* compiled({ 'user': 'barney' });
|
||
* // => 'hello barney!'
|
||
*
|
||
* // Use the ES template literal delimiter as an "interpolate" delimiter.
|
||
* // Disable support by replacing the "interpolate" delimiter.
|
||
* var compiled = _.template('hello ${ user }!');
|
||
* compiled({ 'user': 'pebbles' });
|
||
* // => 'hello pebbles!'
|
||
*
|
||
* // Use backslashes to treat delimiters as plain text.
|
||
* var compiled = _.template('<%= "\\<%- value %\\>" %>');
|
||
* compiled({ 'value': 'ignored' });
|
||
* // => '<%- value %>'
|
||
*
|
||
* // Use the `imports` option to import `jQuery` as `jq`.
|
||
* var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
|
||
* var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
|
||
* compiled({ 'users': ['fred', 'barney'] });
|
||
* // => '<li>fred</li><li>barney</li>'
|
||
*
|
||
* // Use the `sourceURL` option to specify a custom sourceURL for the template.
|
||
* var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
|
||
* compiled(data);
|
||
* // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
|
||
*
|
||
* // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
|
||
* var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
|
||
* compiled.source;
|
||
* // => function(data) {
|
||
* // var __t, __p = '';
|
||
* // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
|
||
* // return __p;
|
||
* // }
|
||
*
|
||
* // Use custom template delimiters.
|
||
* _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
|
||
* var compiled = _.template('hello {{ user }}!');
|
||
* compiled({ 'user': 'mustache' });
|
||
* // => 'hello mustache!'
|
||
*
|
||
* // Use the `source` property to inline compiled templates for meaningful
|
||
* // line numbers in error messages and stack traces.
|
||
* fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
|
||
* var JST = {\
|
||
* "main": ' + _.template(mainText).source + '\
|
||
* };\
|
||
* ');
|
||
*/
|
||
function template(string, options, guard) {
|
||
// Based on John Resig's `tmpl` implementation
|
||
// (http://ejohn.org/blog/javascript-micro-templating/)
|
||
// and Laura Doktorova's doT.js (https://github.com/olado/doT).
|
||
var settings = lodash.templateSettings
|
||
|
||
if (guard && isIterateeCall(string, options, guard)) {
|
||
options = undefined$1
|
||
}
|
||
string = toString(string)
|
||
options = assignInWith({}, options, settings, customDefaultsAssignIn)
|
||
|
||
var imports = assignInWith(
|
||
{},
|
||
options.imports,
|
||
settings.imports,
|
||
customDefaultsAssignIn
|
||
),
|
||
importsKeys = keys(imports),
|
||
importsValues = baseValues(imports, importsKeys)
|
||
|
||
var isEscaping,
|
||
isEvaluating,
|
||
index = 0,
|
||
interpolate = options.interpolate || reNoMatch,
|
||
source = "__p += '"
|
||
|
||
// Compile the regexp to match each delimiter.
|
||
var reDelimiters = RegExp(
|
||
(options.escape || reNoMatch).source +
|
||
"|" +
|
||
interpolate.source +
|
||
"|" +
|
||
(interpolate === reInterpolate ? reEsTemplate : reNoMatch)
|
||
.source +
|
||
"|" +
|
||
(options.evaluate || reNoMatch).source +
|
||
"|$",
|
||
"g"
|
||
)
|
||
|
||
// Use a sourceURL for easier debugging.
|
||
// The sourceURL gets injected into the source that's eval-ed, so be careful
|
||
// with lookup (in case of e.g. prototype pollution), and strip newlines if any.
|
||
// A newline wouldn't be a valid sourceURL anyway, and it'd enable code injection.
|
||
var sourceURL =
|
||
"//# sourceURL=" +
|
||
(hasOwnProperty.call(options, "sourceURL")
|
||
? (options.sourceURL + "").replace(/[\r\n]/g, " ")
|
||
: "lodash.templateSources[" + ++templateCounter + "]") +
|
||
"\n"
|
||
|
||
string.replace(reDelimiters, function(
|
||
match,
|
||
escapeValue,
|
||
interpolateValue,
|
||
esTemplateValue,
|
||
evaluateValue,
|
||
offset
|
||
) {
|
||
interpolateValue || (interpolateValue = esTemplateValue)
|
||
|
||
// Escape characters that can't be included in string literals.
|
||
source += string
|
||
.slice(index, offset)
|
||
.replace(reUnescapedString, escapeStringChar)
|
||
|
||
// Replace delimiters with snippets.
|
||
if (escapeValue) {
|
||
isEscaping = true
|
||
source += "' +\n__e(" + escapeValue + ") +\n'"
|
||
}
|
||
if (evaluateValue) {
|
||
isEvaluating = true
|
||
source += "';\n" + evaluateValue + ";\n__p += '"
|
||
}
|
||
if (interpolateValue) {
|
||
source +=
|
||
"' +\n((__t = (" +
|
||
interpolateValue +
|
||
")) == null ? '' : __t) +\n'"
|
||
}
|
||
index = offset + match.length
|
||
|
||
// The JS engine embedded in Adobe products needs `match` returned in
|
||
// order to produce the correct `offset` value.
|
||
return match
|
||
})
|
||
|
||
source += "';\n"
|
||
|
||
// If `variable` is not specified wrap a with-statement around the generated
|
||
// code to add the data object to the top of the scope chain.
|
||
// Like with sourceURL, we take care to not check the option's prototype,
|
||
// as this configuration is a code injection vector.
|
||
var variable =
|
||
hasOwnProperty.call(options, "variable") && options.variable
|
||
if (!variable) {
|
||
source = "with (obj) {\n" + source + "\n}\n"
|
||
}
|
||
// Cleanup code by stripping empty strings.
|
||
source = (isEvaluating
|
||
? source.replace(reEmptyStringLeading, "")
|
||
: source
|
||
)
|
||
.replace(reEmptyStringMiddle, "$1")
|
||
.replace(reEmptyStringTrailing, "$1;")
|
||
|
||
// Frame code as the function body.
|
||
source =
|
||
"function(" +
|
||
(variable || "obj") +
|
||
") {\n" +
|
||
(variable ? "" : "obj || (obj = {});\n") +
|
||
"var __t, __p = ''" +
|
||
(isEscaping ? ", __e = _.escape" : "") +
|
||
(isEvaluating
|
||
? ", __j = Array.prototype.join;\n" +
|
||
"function print() { __p += __j.call(arguments, '') }\n"
|
||
: ";\n") +
|
||
source +
|
||
"return __p\n}"
|
||
|
||
var result = attempt(function() {
|
||
return Function(importsKeys, sourceURL + "return " + source).apply(
|
||
undefined$1,
|
||
importsValues
|
||
)
|
||
})
|
||
|
||
// Provide the compiled function's source by its `toString` method or
|
||
// the `source` property as a convenience for inlining compiled templates.
|
||
result.source = source
|
||
if (isError(result)) {
|
||
throw result
|
||
}
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* Converts `string`, as a whole, to lower case just like
|
||
* [String#toLowerCase](https://mdn.io/toLowerCase).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to convert.
|
||
* @returns {string} Returns the lower cased string.
|
||
* @example
|
||
*
|
||
* _.toLower('--Foo-Bar--');
|
||
* // => '--foo-bar--'
|
||
*
|
||
* _.toLower('fooBar');
|
||
* // => 'foobar'
|
||
*
|
||
* _.toLower('__FOO_BAR__');
|
||
* // => '__foo_bar__'
|
||
*/
|
||
function toLower(value) {
|
||
return toString(value).toLowerCase()
|
||
}
|
||
|
||
/**
|
||
* Converts `string`, as a whole, to upper case just like
|
||
* [String#toUpperCase](https://mdn.io/toUpperCase).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to convert.
|
||
* @returns {string} Returns the upper cased string.
|
||
* @example
|
||
*
|
||
* _.toUpper('--foo-bar--');
|
||
* // => '--FOO-BAR--'
|
||
*
|
||
* _.toUpper('fooBar');
|
||
* // => 'FOOBAR'
|
||
*
|
||
* _.toUpper('__foo_bar__');
|
||
* // => '__FOO_BAR__'
|
||
*/
|
||
function toUpper(value) {
|
||
return toString(value).toUpperCase()
|
||
}
|
||
|
||
/**
|
||
* Removes leading and trailing whitespace or specified characters from `string`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to trim.
|
||
* @param {string} [chars=whitespace] The characters to trim.
|
||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
* @returns {string} Returns the trimmed string.
|
||
* @example
|
||
*
|
||
* _.trim(' abc ');
|
||
* // => 'abc'
|
||
*
|
||
* _.trim('-_-abc-_-', '_-');
|
||
* // => 'abc'
|
||
*
|
||
* _.map([' foo ', ' bar '], _.trim);
|
||
* // => ['foo', 'bar']
|
||
*/
|
||
function trim(string, chars, guard) {
|
||
string = toString(string)
|
||
if (string && (guard || chars === undefined$1)) {
|
||
return string.replace(reTrim, "")
|
||
}
|
||
if (!string || !(chars = baseToString(chars))) {
|
||
return string
|
||
}
|
||
var strSymbols = stringToArray(string),
|
||
chrSymbols = stringToArray(chars),
|
||
start = charsStartIndex(strSymbols, chrSymbols),
|
||
end = charsEndIndex(strSymbols, chrSymbols) + 1
|
||
|
||
return castSlice(strSymbols, start, end).join("")
|
||
}
|
||
|
||
/**
|
||
* Removes trailing whitespace or specified characters from `string`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to trim.
|
||
* @param {string} [chars=whitespace] The characters to trim.
|
||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
* @returns {string} Returns the trimmed string.
|
||
* @example
|
||
*
|
||
* _.trimEnd(' abc ');
|
||
* // => ' abc'
|
||
*
|
||
* _.trimEnd('-_-abc-_-', '_-');
|
||
* // => '-_-abc'
|
||
*/
|
||
function trimEnd(string, chars, guard) {
|
||
string = toString(string)
|
||
if (string && (guard || chars === undefined$1)) {
|
||
return string.replace(reTrimEnd, "")
|
||
}
|
||
if (!string || !(chars = baseToString(chars))) {
|
||
return string
|
||
}
|
||
var strSymbols = stringToArray(string),
|
||
end = charsEndIndex(strSymbols, stringToArray(chars)) + 1
|
||
|
||
return castSlice(strSymbols, 0, end).join("")
|
||
}
|
||
|
||
/**
|
||
* Removes leading whitespace or specified characters from `string`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to trim.
|
||
* @param {string} [chars=whitespace] The characters to trim.
|
||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
* @returns {string} Returns the trimmed string.
|
||
* @example
|
||
*
|
||
* _.trimStart(' abc ');
|
||
* // => 'abc '
|
||
*
|
||
* _.trimStart('-_-abc-_-', '_-');
|
||
* // => 'abc-_-'
|
||
*/
|
||
function trimStart(string, chars, guard) {
|
||
string = toString(string)
|
||
if (string && (guard || chars === undefined$1)) {
|
||
return string.replace(reTrimStart, "")
|
||
}
|
||
if (!string || !(chars = baseToString(chars))) {
|
||
return string
|
||
}
|
||
var strSymbols = stringToArray(string),
|
||
start = charsStartIndex(strSymbols, stringToArray(chars))
|
||
|
||
return castSlice(strSymbols, start).join("")
|
||
}
|
||
|
||
/**
|
||
* Truncates `string` if it's longer than the given maximum string length.
|
||
* The last characters of the truncated string are replaced with the omission
|
||
* string which defaults to "...".
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to truncate.
|
||
* @param {Object} [options={}] The options object.
|
||
* @param {number} [options.length=30] The maximum string length.
|
||
* @param {string} [options.omission='...'] The string to indicate text is omitted.
|
||
* @param {RegExp|string} [options.separator] The separator pattern to truncate to.
|
||
* @returns {string} Returns the truncated string.
|
||
* @example
|
||
*
|
||
* _.truncate('hi-diddly-ho there, neighborino');
|
||
* // => 'hi-diddly-ho there, neighbo...'
|
||
*
|
||
* _.truncate('hi-diddly-ho there, neighborino', {
|
||
* 'length': 24,
|
||
* 'separator': ' '
|
||
* });
|
||
* // => 'hi-diddly-ho there,...'
|
||
*
|
||
* _.truncate('hi-diddly-ho there, neighborino', {
|
||
* 'length': 24,
|
||
* 'separator': /,? +/
|
||
* });
|
||
* // => 'hi-diddly-ho there...'
|
||
*
|
||
* _.truncate('hi-diddly-ho there, neighborino', {
|
||
* 'omission': ' [...]'
|
||
* });
|
||
* // => 'hi-diddly-ho there, neig [...]'
|
||
*/
|
||
function truncate(string, options) {
|
||
var length = DEFAULT_TRUNC_LENGTH,
|
||
omission = DEFAULT_TRUNC_OMISSION
|
||
|
||
if (isObject(options)) {
|
||
var separator =
|
||
"separator" in options ? options.separator : separator
|
||
length = "length" in options ? toInteger(options.length) : length
|
||
omission =
|
||
"omission" in options ? baseToString(options.omission) : omission
|
||
}
|
||
string = toString(string)
|
||
|
||
var strLength = string.length
|
||
if (hasUnicode(string)) {
|
||
var strSymbols = stringToArray(string)
|
||
strLength = strSymbols.length
|
||
}
|
||
if (length >= strLength) {
|
||
return string
|
||
}
|
||
var end = length - stringSize(omission)
|
||
if (end < 1) {
|
||
return omission
|
||
}
|
||
var result = strSymbols
|
||
? castSlice(strSymbols, 0, end).join("")
|
||
: string.slice(0, end)
|
||
|
||
if (separator === undefined$1) {
|
||
return result + omission
|
||
}
|
||
if (strSymbols) {
|
||
end += result.length - end
|
||
}
|
||
if (isRegExp(separator)) {
|
||
if (string.slice(end).search(separator)) {
|
||
var match,
|
||
substring = result
|
||
|
||
if (!separator.global) {
|
||
separator = RegExp(
|
||
separator.source,
|
||
toString(reFlags.exec(separator)) + "g"
|
||
)
|
||
}
|
||
separator.lastIndex = 0
|
||
while ((match = separator.exec(substring))) {
|
||
var newEnd = match.index
|
||
}
|
||
result = result.slice(0, newEnd === undefined$1 ? end : newEnd)
|
||
}
|
||
} else if (string.indexOf(baseToString(separator), end) != end) {
|
||
var index = result.lastIndexOf(separator)
|
||
if (index > -1) {
|
||
result = result.slice(0, index)
|
||
}
|
||
}
|
||
return result + omission
|
||
}
|
||
|
||
/**
|
||
* The inverse of `_.escape`; this method converts the HTML entities
|
||
* `&`, `<`, `>`, `"`, and `'` in `string` to
|
||
* their corresponding characters.
|
||
*
|
||
* **Note:** No other HTML entities are unescaped. To unescape additional
|
||
* HTML entities use a third-party library like [_he_](https://mths.be/he).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 0.6.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to unescape.
|
||
* @returns {string} Returns the unescaped string.
|
||
* @example
|
||
*
|
||
* _.unescape('fred, barney, & pebbles');
|
||
* // => 'fred, barney, & pebbles'
|
||
*/
|
||
function unescape(string) {
|
||
string = toString(string)
|
||
return string && reHasEscapedHtml.test(string)
|
||
? string.replace(reEscapedHtml, unescapeHtmlChar)
|
||
: string
|
||
}
|
||
|
||
/**
|
||
* Converts `string`, as space separated words, to upper case.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to convert.
|
||
* @returns {string} Returns the upper cased string.
|
||
* @example
|
||
*
|
||
* _.upperCase('--foo-bar');
|
||
* // => 'FOO BAR'
|
||
*
|
||
* _.upperCase('fooBar');
|
||
* // => 'FOO BAR'
|
||
*
|
||
* _.upperCase('__foo_bar__');
|
||
* // => 'FOO BAR'
|
||
*/
|
||
var upperCase = createCompounder(function(result, word, index) {
|
||
return result + (index ? " " : "") + word.toUpperCase()
|
||
})
|
||
|
||
/**
|
||
* Converts the first character of `string` to upper case.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to convert.
|
||
* @returns {string} Returns the converted string.
|
||
* @example
|
||
*
|
||
* _.upperFirst('fred');
|
||
* // => 'Fred'
|
||
*
|
||
* _.upperFirst('FRED');
|
||
* // => 'FRED'
|
||
*/
|
||
var upperFirst = createCaseFirst("toUpperCase")
|
||
|
||
/**
|
||
* Splits `string` into an array of its words.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category String
|
||
* @param {string} [string=''] The string to inspect.
|
||
* @param {RegExp|string} [pattern] The pattern to match words.
|
||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||
* @returns {Array} Returns the words of `string`.
|
||
* @example
|
||
*
|
||
* _.words('fred, barney, & pebbles');
|
||
* // => ['fred', 'barney', 'pebbles']
|
||
*
|
||
* _.words('fred, barney, & pebbles', /[^, ]+/g);
|
||
* // => ['fred', 'barney', '&', 'pebbles']
|
||
*/
|
||
function words(string, pattern, guard) {
|
||
string = toString(string)
|
||
pattern = guard ? undefined$1 : pattern
|
||
|
||
if (pattern === undefined$1) {
|
||
return hasUnicodeWord(string)
|
||
? unicodeWords(string)
|
||
: asciiWords(string)
|
||
}
|
||
return string.match(pattern) || []
|
||
}
|
||
|
||
/*------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* Attempts to invoke `func`, returning either the result or the caught error
|
||
* object. Any additional arguments are provided to `func` when it's invoked.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category Util
|
||
* @param {Function} func The function to attempt.
|
||
* @param {...*} [args] The arguments to invoke `func` with.
|
||
* @returns {*} Returns the `func` result or error object.
|
||
* @example
|
||
*
|
||
* // Avoid throwing errors for invalid selectors.
|
||
* var elements = _.attempt(function(selector) {
|
||
* return document.querySelectorAll(selector);
|
||
* }, '>_>');
|
||
*
|
||
* if (_.isError(elements)) {
|
||
* elements = [];
|
||
* }
|
||
*/
|
||
var attempt = baseRest(function(func, args) {
|
||
try {
|
||
return apply(func, undefined$1, args)
|
||
} catch (e) {
|
||
return isError(e) ? e : new Error(e)
|
||
}
|
||
})
|
||
|
||
/**
|
||
* Binds methods of an object to the object itself, overwriting the existing
|
||
* method.
|
||
*
|
||
* **Note:** This method doesn't set the "length" property of bound functions.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {Object} object The object to bind and assign the bound methods to.
|
||
* @param {...(string|string[])} methodNames The object method names to bind.
|
||
* @returns {Object} Returns `object`.
|
||
* @example
|
||
*
|
||
* var view = {
|
||
* 'label': 'docs',
|
||
* 'click': function() {
|
||
* console.log('clicked ' + this.label);
|
||
* }
|
||
* };
|
||
*
|
||
* _.bindAll(view, ['click']);
|
||
* jQuery(element).on('click', view.click);
|
||
* // => Logs 'clicked docs' when clicked.
|
||
*/
|
||
var bindAll = flatRest(function(object, methodNames) {
|
||
arrayEach(methodNames, function(key) {
|
||
key = toKey(key)
|
||
baseAssignValue(object, key, bind(object[key], object))
|
||
})
|
||
return object
|
||
})
|
||
|
||
/**
|
||
* Creates a function that iterates over `pairs` and invokes the corresponding
|
||
* function of the first predicate to return truthy. The predicate-function
|
||
* pairs are invoked with the `this` binding and arguments of the created
|
||
* function.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {Array} pairs The predicate-function pairs.
|
||
* @returns {Function} Returns the new composite function.
|
||
* @example
|
||
*
|
||
* var func = _.cond([
|
||
* [_.matches({ 'a': 1 }), _.constant('matches A')],
|
||
* [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
|
||
* [_.stubTrue, _.constant('no match')]
|
||
* ]);
|
||
*
|
||
* func({ 'a': 1, 'b': 2 });
|
||
* // => 'matches A'
|
||
*
|
||
* func({ 'a': 0, 'b': 1 });
|
||
* // => 'matches B'
|
||
*
|
||
* func({ 'a': '1', 'b': '2' });
|
||
* // => 'no match'
|
||
*/
|
||
function cond(pairs) {
|
||
var length = pairs == null ? 0 : pairs.length,
|
||
toIteratee = getIteratee()
|
||
|
||
pairs = !length
|
||
? []
|
||
: arrayMap(pairs, function(pair) {
|
||
if (typeof pair[1] != "function") {
|
||
throw new TypeError(FUNC_ERROR_TEXT)
|
||
}
|
||
return [toIteratee(pair[0]), pair[1]]
|
||
})
|
||
|
||
return baseRest(function(args) {
|
||
var index = -1
|
||
while (++index < length) {
|
||
var pair = pairs[index]
|
||
if (apply(pair[0], this, args)) {
|
||
return apply(pair[1], this, args)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes the predicate properties of `source` with
|
||
* the corresponding property values of a given object, returning `true` if
|
||
* all predicates return truthy, else `false`.
|
||
*
|
||
* **Note:** The created function is equivalent to `_.conformsTo` with
|
||
* `source` partially applied.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {Object} source The object of property predicates to conform to.
|
||
* @returns {Function} Returns the new spec function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': 2, 'b': 1 },
|
||
* { 'a': 1, 'b': 2 }
|
||
* ];
|
||
*
|
||
* _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
|
||
* // => [{ 'a': 1, 'b': 2 }]
|
||
*/
|
||
function conforms(source) {
|
||
return baseConforms(baseClone(source, CLONE_DEEP_FLAG))
|
||
}
|
||
|
||
/**
|
||
* Creates a function that returns `value`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 2.4.0
|
||
* @category Util
|
||
* @param {*} value The value to return from the new function.
|
||
* @returns {Function} Returns the new constant function.
|
||
* @example
|
||
*
|
||
* var objects = _.times(2, _.constant({ 'a': 1 }));
|
||
*
|
||
* console.log(objects);
|
||
* // => [{ 'a': 1 }, { 'a': 1 }]
|
||
*
|
||
* console.log(objects[0] === objects[1]);
|
||
* // => true
|
||
*/
|
||
function constant(value) {
|
||
return function() {
|
||
return value
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Checks `value` to determine whether a default value should be returned in
|
||
* its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
|
||
* or `undefined`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.14.0
|
||
* @category Util
|
||
* @param {*} value The value to check.
|
||
* @param {*} defaultValue The default value.
|
||
* @returns {*} Returns the resolved value.
|
||
* @example
|
||
*
|
||
* _.defaultTo(1, 10);
|
||
* // => 1
|
||
*
|
||
* _.defaultTo(undefined, 10);
|
||
* // => 10
|
||
*/
|
||
function defaultTo(value, defaultValue) {
|
||
return value == null || value !== value ? defaultValue : value
|
||
}
|
||
|
||
/**
|
||
* Creates a function that returns the result of invoking the given functions
|
||
* with the `this` binding of the created function, where each successive
|
||
* invocation is supplied the return value of the previous.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category Util
|
||
* @param {...(Function|Function[])} [funcs] The functions to invoke.
|
||
* @returns {Function} Returns the new composite function.
|
||
* @see _.flowRight
|
||
* @example
|
||
*
|
||
* function square(n) {
|
||
* return n * n;
|
||
* }
|
||
*
|
||
* var addSquare = _.flow([_.add, square]);
|
||
* addSquare(1, 2);
|
||
* // => 9
|
||
*/
|
||
var flow = createFlow()
|
||
|
||
/**
|
||
* This method is like `_.flow` except that it creates a function that
|
||
* invokes the given functions from right to left.
|
||
*
|
||
* @static
|
||
* @since 3.0.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {...(Function|Function[])} [funcs] The functions to invoke.
|
||
* @returns {Function} Returns the new composite function.
|
||
* @see _.flow
|
||
* @example
|
||
*
|
||
* function square(n) {
|
||
* return n * n;
|
||
* }
|
||
*
|
||
* var addSquare = _.flowRight([square, _.add]);
|
||
* addSquare(1, 2);
|
||
* // => 9
|
||
*/
|
||
var flowRight = createFlow(true)
|
||
|
||
/**
|
||
* This method returns the first argument it receives.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {*} value Any value.
|
||
* @returns {*} Returns `value`.
|
||
* @example
|
||
*
|
||
* var object = { 'a': 1 };
|
||
*
|
||
* console.log(_.identity(object) === object);
|
||
* // => true
|
||
*/
|
||
function identity(value) {
|
||
return value
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes `func` with the arguments of the created
|
||
* function. If `func` is a property name, the created function returns the
|
||
* property value for a given element. If `func` is an array or object, the
|
||
* created function returns `true` for elements that contain the equivalent
|
||
* source properties, otherwise it returns `false`.
|
||
*
|
||
* @static
|
||
* @since 4.0.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {*} [func=_.identity] The value to convert to a callback.
|
||
* @returns {Function} Returns the callback.
|
||
* @example
|
||
*
|
||
* var users = [
|
||
* { 'user': 'barney', 'age': 36, 'active': true },
|
||
* { 'user': 'fred', 'age': 40, 'active': false }
|
||
* ];
|
||
*
|
||
* // The `_.matches` iteratee shorthand.
|
||
* _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
|
||
* // => [{ 'user': 'barney', 'age': 36, 'active': true }]
|
||
*
|
||
* // The `_.matchesProperty` iteratee shorthand.
|
||
* _.filter(users, _.iteratee(['user', 'fred']));
|
||
* // => [{ 'user': 'fred', 'age': 40 }]
|
||
*
|
||
* // The `_.property` iteratee shorthand.
|
||
* _.map(users, _.iteratee('user'));
|
||
* // => ['barney', 'fred']
|
||
*
|
||
* // Create custom iteratee shorthands.
|
||
* _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
|
||
* return !_.isRegExp(func) ? iteratee(func) : function(string) {
|
||
* return func.test(string);
|
||
* };
|
||
* });
|
||
*
|
||
* _.filter(['abc', 'def'], /ef/);
|
||
* // => ['def']
|
||
*/
|
||
function iteratee(func) {
|
||
return baseIteratee(
|
||
typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG)
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Creates a function that performs a partial deep comparison between a given
|
||
* object and `source`, returning `true` if the given object has equivalent
|
||
* property values, else `false`.
|
||
*
|
||
* **Note:** The created function is equivalent to `_.isMatch` with `source`
|
||
* 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 Util
|
||
* @param {Object} source The object of property values to match.
|
||
* @returns {Function} Returns the new spec function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': 1, 'b': 2, 'c': 3 },
|
||
* { 'a': 4, 'b': 5, 'c': 6 }
|
||
* ];
|
||
*
|
||
* _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
|
||
* // => [{ 'a': 4, 'b': 5, 'c': 6 }]
|
||
*/
|
||
function matches(source) {
|
||
return baseMatches(baseClone(source, CLONE_DEEP_FLAG))
|
||
}
|
||
|
||
/**
|
||
* Creates a function that performs a partial deep comparison between the
|
||
* value at `path` of a given object to `srcValue`, returning `true` if the
|
||
* object value is equivalent, else `false`.
|
||
*
|
||
* **Note:** Partial comparisons will match empty array and empty object
|
||
* `srcValue` values against any array or object value, respectively. See
|
||
* `_.isEqual` for a list of supported value comparisons.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.2.0
|
||
* @category Util
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @param {*} srcValue The value to match.
|
||
* @returns {Function} Returns the new spec function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': 1, 'b': 2, 'c': 3 },
|
||
* { 'a': 4, 'b': 5, 'c': 6 }
|
||
* ];
|
||
*
|
||
* _.find(objects, _.matchesProperty('a', 4));
|
||
* // => { 'a': 4, 'b': 5, 'c': 6 }
|
||
*/
|
||
function matchesProperty(path, srcValue) {
|
||
return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG))
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes the method at `path` of a given object.
|
||
* Any additional arguments are provided to the invoked method.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.7.0
|
||
* @category Util
|
||
* @param {Array|string} path The path of the method to invoke.
|
||
* @param {...*} [args] The arguments to invoke the method with.
|
||
* @returns {Function} Returns the new invoker function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': { 'b': _.constant(2) } },
|
||
* { 'a': { 'b': _.constant(1) } }
|
||
* ];
|
||
*
|
||
* _.map(objects, _.method('a.b'));
|
||
* // => [2, 1]
|
||
*
|
||
* _.map(objects, _.method(['a', 'b']));
|
||
* // => [2, 1]
|
||
*/
|
||
var method = baseRest(function(path, args) {
|
||
return function(object) {
|
||
return baseInvoke(object, path, args)
|
||
}
|
||
})
|
||
|
||
/**
|
||
* The opposite of `_.method`; this method creates a function that invokes
|
||
* the method at a given path of `object`. Any additional arguments are
|
||
* provided to the invoked method.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.7.0
|
||
* @category Util
|
||
* @param {Object} object The object to query.
|
||
* @param {...*} [args] The arguments to invoke the method with.
|
||
* @returns {Function} Returns the new invoker function.
|
||
* @example
|
||
*
|
||
* var array = _.times(3, _.constant),
|
||
* object = { 'a': array, 'b': array, 'c': array };
|
||
*
|
||
* _.map(['a[2]', 'c[0]'], _.methodOf(object));
|
||
* // => [2, 0]
|
||
*
|
||
* _.map([['a', '2'], ['c', '0']], _.methodOf(object));
|
||
* // => [2, 0]
|
||
*/
|
||
var methodOf = baseRest(function(object, args) {
|
||
return function(path) {
|
||
return baseInvoke(object, path, args)
|
||
}
|
||
})
|
||
|
||
/**
|
||
* Adds all own enumerable string keyed function properties of a source
|
||
* object to the destination object. If `object` is a function, then methods
|
||
* are added to its prototype as well.
|
||
*
|
||
* **Note:** Use `_.runInContext` to create a pristine `lodash` function to
|
||
* avoid conflicts caused by modifying the original.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {Function|Object} [object=lodash] The destination object.
|
||
* @param {Object} source The object of functions to add.
|
||
* @param {Object} [options={}] The options object.
|
||
* @param {boolean} [options.chain=true] Specify whether mixins are chainable.
|
||
* @returns {Function|Object} Returns `object`.
|
||
* @example
|
||
*
|
||
* function vowels(string) {
|
||
* return _.filter(string, function(v) {
|
||
* return /[aeiou]/i.test(v);
|
||
* });
|
||
* }
|
||
*
|
||
* _.mixin({ 'vowels': vowels });
|
||
* _.vowels('fred');
|
||
* // => ['e']
|
||
*
|
||
* _('fred').vowels().value();
|
||
* // => ['e']
|
||
*
|
||
* _.mixin({ 'vowels': vowels }, { 'chain': false });
|
||
* _('fred').vowels();
|
||
* // => ['e']
|
||
*/
|
||
function mixin(object, source, options) {
|
||
var props = keys(source),
|
||
methodNames = baseFunctions(source, props)
|
||
|
||
if (
|
||
options == null &&
|
||
!(isObject(source) && (methodNames.length || !props.length))
|
||
) {
|
||
options = source
|
||
source = object
|
||
object = this
|
||
methodNames = baseFunctions(source, keys(source))
|
||
}
|
||
var chain =
|
||
!(isObject(options) && "chain" in options) || !!options.chain,
|
||
isFunc = isFunction(object)
|
||
|
||
arrayEach(methodNames, function(methodName) {
|
||
var func = source[methodName]
|
||
object[methodName] = func
|
||
if (isFunc) {
|
||
object.prototype[methodName] = function() {
|
||
var chainAll = this.__chain__
|
||
if (chain || chainAll) {
|
||
var result = object(this.__wrapped__),
|
||
actions = (result.__actions__ = copyArray(this.__actions__))
|
||
|
||
actions.push({ func: func, args: arguments, thisArg: object })
|
||
result.__chain__ = chainAll
|
||
return result
|
||
}
|
||
return func.apply(object, arrayPush([this.value()], arguments))
|
||
}
|
||
}
|
||
})
|
||
|
||
return object
|
||
}
|
||
|
||
/**
|
||
* Reverts the `_` variable to its previous value and returns a reference to
|
||
* the `lodash` function.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @returns {Function} Returns the `lodash` function.
|
||
* @example
|
||
*
|
||
* var lodash = _.noConflict();
|
||
*/
|
||
function noConflict() {
|
||
if (root._ === this) {
|
||
root._ = oldDash
|
||
}
|
||
return this
|
||
}
|
||
|
||
/**
|
||
* This method returns `undefined`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 2.3.0
|
||
* @category Util
|
||
* @example
|
||
*
|
||
* _.times(2, _.noop);
|
||
* // => [undefined, undefined]
|
||
*/
|
||
function noop() {
|
||
// No operation performed.
|
||
}
|
||
|
||
/**
|
||
* Creates a function that gets the argument at index `n`. If `n` is negative,
|
||
* the nth argument from the end is returned.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {number} [n=0] The index of the argument to return.
|
||
* @returns {Function} Returns the new pass-thru function.
|
||
* @example
|
||
*
|
||
* var func = _.nthArg(1);
|
||
* func('a', 'b', 'c', 'd');
|
||
* // => 'b'
|
||
*
|
||
* var func = _.nthArg(-2);
|
||
* func('a', 'b', 'c', 'd');
|
||
* // => 'c'
|
||
*/
|
||
function nthArg(n) {
|
||
n = toInteger(n)
|
||
return baseRest(function(args) {
|
||
return baseNth(args, n)
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Creates a function that invokes `iteratees` with the arguments it receives
|
||
* and returns their results.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {...(Function|Function[])} [iteratees=[_.identity]]
|
||
* The iteratees to invoke.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var func = _.over([Math.max, Math.min]);
|
||
*
|
||
* func(1, 2, 3, 4);
|
||
* // => [4, 1]
|
||
*/
|
||
var over = createOver(arrayMap)
|
||
|
||
/**
|
||
* Creates a function that checks if **all** of the `predicates` return
|
||
* truthy when invoked with the arguments it receives.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {...(Function|Function[])} [predicates=[_.identity]]
|
||
* The predicates to check.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var func = _.overEvery([Boolean, isFinite]);
|
||
*
|
||
* func('1');
|
||
* // => true
|
||
*
|
||
* func(null);
|
||
* // => false
|
||
*
|
||
* func(NaN);
|
||
* // => false
|
||
*/
|
||
var overEvery = createOver(arrayEvery)
|
||
|
||
/**
|
||
* Creates a function that checks if **any** of the `predicates` return
|
||
* truthy when invoked with the arguments it receives.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {...(Function|Function[])} [predicates=[_.identity]]
|
||
* The predicates to check.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var func = _.overSome([Boolean, isFinite]);
|
||
*
|
||
* func('1');
|
||
* // => true
|
||
*
|
||
* func(null);
|
||
* // => true
|
||
*
|
||
* func(NaN);
|
||
* // => false
|
||
*/
|
||
var overSome = createOver(arraySome)
|
||
|
||
/**
|
||
* Creates a function that returns the value at `path` of a given object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 2.4.0
|
||
* @category Util
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @returns {Function} Returns the new accessor function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': { 'b': 2 } },
|
||
* { 'a': { 'b': 1 } }
|
||
* ];
|
||
*
|
||
* _.map(objects, _.property('a.b'));
|
||
* // => [2, 1]
|
||
*
|
||
* _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
|
||
* // => [1, 2]
|
||
*/
|
||
function property(path) {
|
||
return isKey(path)
|
||
? baseProperty(toKey(path))
|
||
: basePropertyDeep(path)
|
||
}
|
||
|
||
/**
|
||
* The opposite of `_.property`; this method creates a function that returns
|
||
* the value at a given path of `object`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.0.0
|
||
* @category Util
|
||
* @param {Object} object The object to query.
|
||
* @returns {Function} Returns the new accessor function.
|
||
* @example
|
||
*
|
||
* var array = [0, 1, 2],
|
||
* object = { 'a': array, 'b': array, 'c': array };
|
||
*
|
||
* _.map(['a[2]', 'c[0]'], _.propertyOf(object));
|
||
* // => [2, 0]
|
||
*
|
||
* _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
|
||
* // => [2, 0]
|
||
*/
|
||
function propertyOf(object) {
|
||
return function(path) {
|
||
return object == null ? undefined$1 : baseGet(object, path)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Creates an array of numbers (positive and/or negative) progressing from
|
||
* `start` up to, but not including, `end`. A step of `-1` is used if a negative
|
||
* `start` is specified without an `end` or `step`. If `end` is not specified,
|
||
* it's set to `start` with `start` then set to `0`.
|
||
*
|
||
* **Note:** JavaScript follows the IEEE-754 standard for resolving
|
||
* floating-point values which can produce unexpected results.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {number} [start=0] The start of the range.
|
||
* @param {number} end The end of the range.
|
||
* @param {number} [step=1] The value to increment or decrement by.
|
||
* @returns {Array} Returns the range of numbers.
|
||
* @see _.inRange, _.rangeRight
|
||
* @example
|
||
*
|
||
* _.range(4);
|
||
* // => [0, 1, 2, 3]
|
||
*
|
||
* _.range(-4);
|
||
* // => [0, -1, -2, -3]
|
||
*
|
||
* _.range(1, 5);
|
||
* // => [1, 2, 3, 4]
|
||
*
|
||
* _.range(0, 20, 5);
|
||
* // => [0, 5, 10, 15]
|
||
*
|
||
* _.range(0, -4, -1);
|
||
* // => [0, -1, -2, -3]
|
||
*
|
||
* _.range(1, 4, 0);
|
||
* // => [1, 1, 1]
|
||
*
|
||
* _.range(0);
|
||
* // => []
|
||
*/
|
||
var range = createRange()
|
||
|
||
/**
|
||
* This method is like `_.range` except that it populates values in
|
||
* descending order.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {number} [start=0] The start of the range.
|
||
* @param {number} end The end of the range.
|
||
* @param {number} [step=1] The value to increment or decrement by.
|
||
* @returns {Array} Returns the range of numbers.
|
||
* @see _.inRange, _.range
|
||
* @example
|
||
*
|
||
* _.rangeRight(4);
|
||
* // => [3, 2, 1, 0]
|
||
*
|
||
* _.rangeRight(-4);
|
||
* // => [-3, -2, -1, 0]
|
||
*
|
||
* _.rangeRight(1, 5);
|
||
* // => [4, 3, 2, 1]
|
||
*
|
||
* _.rangeRight(0, 20, 5);
|
||
* // => [15, 10, 5, 0]
|
||
*
|
||
* _.rangeRight(0, -4, -1);
|
||
* // => [-3, -2, -1, 0]
|
||
*
|
||
* _.rangeRight(1, 4, 0);
|
||
* // => [1, 1, 1]
|
||
*
|
||
* _.rangeRight(0);
|
||
* // => []
|
||
*/
|
||
var rangeRight = createRange(true)
|
||
|
||
/**
|
||
* This method returns a new empty array.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {Array} Returns the new empty array.
|
||
* @example
|
||
*
|
||
* var arrays = _.times(2, _.stubArray);
|
||
*
|
||
* console.log(arrays);
|
||
* // => [[], []]
|
||
*
|
||
* console.log(arrays[0] === arrays[1]);
|
||
* // => false
|
||
*/
|
||
function stubArray() {
|
||
return []
|
||
}
|
||
|
||
/**
|
||
* This method returns `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {boolean} Returns `false`.
|
||
* @example
|
||
*
|
||
* _.times(2, _.stubFalse);
|
||
* // => [false, false]
|
||
*/
|
||
function stubFalse() {
|
||
return false
|
||
}
|
||
|
||
/**
|
||
* This method returns a new empty object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {Object} Returns the new empty object.
|
||
* @example
|
||
*
|
||
* var objects = _.times(2, _.stubObject);
|
||
*
|
||
* console.log(objects);
|
||
* // => [{}, {}]
|
||
*
|
||
* console.log(objects[0] === objects[1]);
|
||
* // => false
|
||
*/
|
||
function stubObject() {
|
||
return {}
|
||
}
|
||
|
||
/**
|
||
* This method returns an empty string.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {string} Returns the empty string.
|
||
* @example
|
||
*
|
||
* _.times(2, _.stubString);
|
||
* // => ['', '']
|
||
*/
|
||
function stubString() {
|
||
return ""
|
||
}
|
||
|
||
/**
|
||
* This method returns `true`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.13.0
|
||
* @category Util
|
||
* @returns {boolean} Returns `true`.
|
||
* @example
|
||
*
|
||
* _.times(2, _.stubTrue);
|
||
* // => [true, true]
|
||
*/
|
||
function stubTrue() {
|
||
return true
|
||
}
|
||
|
||
/**
|
||
* Invokes the iteratee `n` times, returning an array of the results of
|
||
* each invocation. The iteratee is invoked with one argument; (index).
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {number} n The number of times to invoke `iteratee`.
|
||
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
|
||
* @returns {Array} Returns the array of results.
|
||
* @example
|
||
*
|
||
* _.times(3, String);
|
||
* // => ['0', '1', '2']
|
||
*
|
||
* _.times(4, _.constant(0));
|
||
* // => [0, 0, 0, 0]
|
||
*/
|
||
function times(n, iteratee) {
|
||
n = toInteger(n)
|
||
if (n < 1 || n > MAX_SAFE_INTEGER) {
|
||
return []
|
||
}
|
||
var index = MAX_ARRAY_LENGTH,
|
||
length = nativeMin(n, MAX_ARRAY_LENGTH)
|
||
|
||
iteratee = getIteratee(iteratee)
|
||
n -= MAX_ARRAY_LENGTH
|
||
|
||
var result = baseTimes(length, iteratee)
|
||
while (++index < n) {
|
||
iteratee(index)
|
||
}
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* Converts `value` to a property path array.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Util
|
||
* @param {*} value The value to convert.
|
||
* @returns {Array} Returns the new property path array.
|
||
* @example
|
||
*
|
||
* _.toPath('a.b.c');
|
||
* // => ['a', 'b', 'c']
|
||
*
|
||
* _.toPath('a[0].b.c');
|
||
* // => ['a', '0', 'b', 'c']
|
||
*/
|
||
function toPath(value) {
|
||
if (isArray(value)) {
|
||
return arrayMap(value, toKey)
|
||
}
|
||
return isSymbol(value)
|
||
? [value]
|
||
: copyArray(stringToPath(toString(value)))
|
||
}
|
||
|
||
/**
|
||
* Generates a unique ID. If `prefix` is given, the ID is appended to it.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Util
|
||
* @param {string} [prefix=''] The value to prefix the ID with.
|
||
* @returns {string} Returns the unique ID.
|
||
* @example
|
||
*
|
||
* _.uniqueId('contact_');
|
||
* // => 'contact_104'
|
||
*
|
||
* _.uniqueId();
|
||
* // => '105'
|
||
*/
|
||
function uniqueId(prefix) {
|
||
var id = ++idCounter
|
||
return toString(prefix) + id
|
||
}
|
||
|
||
/*------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* Adds two numbers.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.4.0
|
||
* @category Math
|
||
* @param {number} augend The first number in an addition.
|
||
* @param {number} addend The second number in an addition.
|
||
* @returns {number} Returns the total.
|
||
* @example
|
||
*
|
||
* _.add(6, 4);
|
||
* // => 10
|
||
*/
|
||
var add = createMathOperation(function(augend, addend) {
|
||
return augend + addend
|
||
}, 0)
|
||
|
||
/**
|
||
* Computes `number` rounded up to `precision`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.10.0
|
||
* @category Math
|
||
* @param {number} number The number to round up.
|
||
* @param {number} [precision=0] The precision to round up to.
|
||
* @returns {number} Returns the rounded up number.
|
||
* @example
|
||
*
|
||
* _.ceil(4.006);
|
||
* // => 5
|
||
*
|
||
* _.ceil(6.004, 2);
|
||
* // => 6.01
|
||
*
|
||
* _.ceil(6040, -2);
|
||
* // => 6100
|
||
*/
|
||
var ceil = createRound("ceil")
|
||
|
||
/**
|
||
* Divide two numbers.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.7.0
|
||
* @category Math
|
||
* @param {number} dividend The first number in a division.
|
||
* @param {number} divisor The second number in a division.
|
||
* @returns {number} Returns the quotient.
|
||
* @example
|
||
*
|
||
* _.divide(6, 4);
|
||
* // => 1.5
|
||
*/
|
||
var divide = createMathOperation(function(dividend, divisor) {
|
||
return dividend / divisor
|
||
}, 1)
|
||
|
||
/**
|
||
* Computes `number` rounded down to `precision`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.10.0
|
||
* @category Math
|
||
* @param {number} number The number to round down.
|
||
* @param {number} [precision=0] The precision to round down to.
|
||
* @returns {number} Returns the rounded down number.
|
||
* @example
|
||
*
|
||
* _.floor(4.006);
|
||
* // => 4
|
||
*
|
||
* _.floor(0.046, 2);
|
||
* // => 0.04
|
||
*
|
||
* _.floor(4060, -2);
|
||
* // => 4000
|
||
*/
|
||
var floor = createRound("floor")
|
||
|
||
/**
|
||
* Computes the maximum value of `array`. If `array` is empty or falsey,
|
||
* `undefined` is returned.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @returns {*} Returns the maximum value.
|
||
* @example
|
||
*
|
||
* _.max([4, 2, 8, 6]);
|
||
* // => 8
|
||
*
|
||
* _.max([]);
|
||
* // => undefined
|
||
*/
|
||
function max(array) {
|
||
return array && array.length
|
||
? baseExtremum(array, identity, baseGt)
|
||
: undefined$1
|
||
}
|
||
|
||
/**
|
||
* This method is like `_.max` except that it accepts `iteratee` which is
|
||
* invoked for each element in `array` to generate the criterion by which
|
||
* the value is ranked. The iteratee is invoked with one argument: (value).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
|
||
* @returns {*} Returns the maximum value.
|
||
* @example
|
||
*
|
||
* var objects = [{ 'n': 1 }, { 'n': 2 }];
|
||
*
|
||
* _.maxBy(objects, function(o) { return o.n; });
|
||
* // => { 'n': 2 }
|
||
*
|
||
* // The `_.property` iteratee shorthand.
|
||
* _.maxBy(objects, 'n');
|
||
* // => { 'n': 2 }
|
||
*/
|
||
function maxBy(array, iteratee) {
|
||
return array && array.length
|
||
? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
|
||
: undefined$1
|
||
}
|
||
|
||
/**
|
||
* Computes the mean of the values in `array`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @returns {number} Returns the mean.
|
||
* @example
|
||
*
|
||
* _.mean([4, 2, 8, 6]);
|
||
* // => 5
|
||
*/
|
||
function mean(array) {
|
||
return baseMean(array, identity)
|
||
}
|
||
|
||
/**
|
||
* This method is like `_.mean` except that it accepts `iteratee` which is
|
||
* invoked for each element in `array` to generate the value to be averaged.
|
||
* The iteratee is invoked with one argument: (value).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.7.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
|
||
* @returns {number} Returns the mean.
|
||
* @example
|
||
*
|
||
* var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
|
||
*
|
||
* _.meanBy(objects, function(o) { return o.n; });
|
||
* // => 5
|
||
*
|
||
* // The `_.property` iteratee shorthand.
|
||
* _.meanBy(objects, 'n');
|
||
* // => 5
|
||
*/
|
||
function meanBy(array, iteratee) {
|
||
return baseMean(array, getIteratee(iteratee, 2))
|
||
}
|
||
|
||
/**
|
||
* Computes the minimum value of `array`. If `array` is empty or falsey,
|
||
* `undefined` is returned.
|
||
*
|
||
* @static
|
||
* @since 0.1.0
|
||
* @memberOf _
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @returns {*} Returns the minimum value.
|
||
* @example
|
||
*
|
||
* _.min([4, 2, 8, 6]);
|
||
* // => 2
|
||
*
|
||
* _.min([]);
|
||
* // => undefined
|
||
*/
|
||
function min(array) {
|
||
return array && array.length
|
||
? baseExtremum(array, identity, baseLt)
|
||
: undefined$1
|
||
}
|
||
|
||
/**
|
||
* This method is like `_.min` except that it accepts `iteratee` which is
|
||
* invoked for each element in `array` to generate the criterion by which
|
||
* the value is ranked. The iteratee is invoked with one argument: (value).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
|
||
* @returns {*} Returns the minimum value.
|
||
* @example
|
||
*
|
||
* var objects = [{ 'n': 1 }, { 'n': 2 }];
|
||
*
|
||
* _.minBy(objects, function(o) { return o.n; });
|
||
* // => { 'n': 1 }
|
||
*
|
||
* // The `_.property` iteratee shorthand.
|
||
* _.minBy(objects, 'n');
|
||
* // => { 'n': 1 }
|
||
*/
|
||
function minBy(array, iteratee) {
|
||
return array && array.length
|
||
? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
|
||
: undefined$1
|
||
}
|
||
|
||
/**
|
||
* Multiply two numbers.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.7.0
|
||
* @category Math
|
||
* @param {number} multiplier The first number in a multiplication.
|
||
* @param {number} multiplicand The second number in a multiplication.
|
||
* @returns {number} Returns the product.
|
||
* @example
|
||
*
|
||
* _.multiply(6, 4);
|
||
* // => 24
|
||
*/
|
||
var multiply = createMathOperation(function(multiplier, multiplicand) {
|
||
return multiplier * multiplicand
|
||
}, 1)
|
||
|
||
/**
|
||
* Computes `number` rounded to `precision`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.10.0
|
||
* @category Math
|
||
* @param {number} number The number to round.
|
||
* @param {number} [precision=0] The precision to round to.
|
||
* @returns {number} Returns the rounded number.
|
||
* @example
|
||
*
|
||
* _.round(4.006);
|
||
* // => 4
|
||
*
|
||
* _.round(4.006, 2);
|
||
* // => 4.01
|
||
*
|
||
* _.round(4060, -2);
|
||
* // => 4100
|
||
*/
|
||
var round = createRound("round")
|
||
|
||
/**
|
||
* Subtract two numbers.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Math
|
||
* @param {number} minuend The first number in a subtraction.
|
||
* @param {number} subtrahend The second number in a subtraction.
|
||
* @returns {number} Returns the difference.
|
||
* @example
|
||
*
|
||
* _.subtract(6, 4);
|
||
* // => 2
|
||
*/
|
||
var subtract = createMathOperation(function(minuend, subtrahend) {
|
||
return minuend - subtrahend
|
||
}, 0)
|
||
|
||
/**
|
||
* Computes the sum of the values in `array`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 3.4.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @returns {number} Returns the sum.
|
||
* @example
|
||
*
|
||
* _.sum([4, 2, 8, 6]);
|
||
* // => 20
|
||
*/
|
||
function sum(array) {
|
||
return array && array.length ? baseSum(array, identity) : 0
|
||
}
|
||
|
||
/**
|
||
* This method is like `_.sum` except that it accepts `iteratee` which is
|
||
* invoked for each element in `array` to generate the value to be summed.
|
||
* The iteratee is invoked with one argument: (value).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @since 4.0.0
|
||
* @category Math
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
|
||
* @returns {number} Returns the sum.
|
||
* @example
|
||
*
|
||
* var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
|
||
*
|
||
* _.sumBy(objects, function(o) { return o.n; });
|
||
* // => 20
|
||
*
|
||
* // The `_.property` iteratee shorthand.
|
||
* _.sumBy(objects, 'n');
|
||
* // => 20
|
||
*/
|
||
function sumBy(array, iteratee) {
|
||
return array && array.length
|
||
? baseSum(array, getIteratee(iteratee, 2))
|
||
: 0
|
||
}
|
||
|
||
/*------------------------------------------------------------------------*/
|
||
|
||
// Add methods that return wrapped values in chain sequences.
|
||
lodash.after = after
|
||
lodash.ary = ary
|
||
lodash.assign = assign
|
||
lodash.assignIn = assignIn
|
||
lodash.assignInWith = assignInWith
|
||
lodash.assignWith = assignWith
|
||
lodash.at = at
|
||
lodash.before = before
|
||
lodash.bind = bind
|
||
lodash.bindAll = bindAll
|
||
lodash.bindKey = bindKey
|
||
lodash.castArray = castArray
|
||
lodash.chain = chain
|
||
lodash.chunk = chunk
|
||
lodash.compact = compact
|
||
lodash.concat = concat
|
||
lodash.cond = cond
|
||
lodash.conforms = conforms
|
||
lodash.constant = constant
|
||
lodash.countBy = countBy
|
||
lodash.create = create
|
||
lodash.curry = curry
|
||
lodash.curryRight = curryRight
|
||
lodash.debounce = debounce
|
||
lodash.defaults = defaults
|
||
lodash.defaultsDeep = defaultsDeep
|
||
lodash.defer = defer
|
||
lodash.delay = delay
|
||
lodash.difference = difference
|
||
lodash.differenceBy = differenceBy
|
||
lodash.differenceWith = differenceWith
|
||
lodash.drop = drop
|
||
lodash.dropRight = dropRight
|
||
lodash.dropRightWhile = dropRightWhile
|
||
lodash.dropWhile = dropWhile
|
||
lodash.fill = fill
|
||
lodash.filter = filter
|
||
lodash.flatMap = flatMap
|
||
lodash.flatMapDeep = flatMapDeep
|
||
lodash.flatMapDepth = flatMapDepth
|
||
lodash.flatten = flatten
|
||
lodash.flattenDeep = flattenDeep
|
||
lodash.flattenDepth = flattenDepth
|
||
lodash.flip = flip
|
||
lodash.flow = flow
|
||
lodash.flowRight = flowRight
|
||
lodash.fromPairs = fromPairs
|
||
lodash.functions = functions
|
||
lodash.functionsIn = functionsIn
|
||
lodash.groupBy = groupBy
|
||
lodash.initial = initial
|
||
lodash.intersection = intersection
|
||
lodash.intersectionBy = intersectionBy
|
||
lodash.intersectionWith = intersectionWith
|
||
lodash.invert = invert
|
||
lodash.invertBy = invertBy
|
||
lodash.invokeMap = invokeMap
|
||
lodash.iteratee = iteratee
|
||
lodash.keyBy = keyBy
|
||
lodash.keys = keys
|
||
lodash.keysIn = keysIn
|
||
lodash.map = map
|
||
lodash.mapKeys = mapKeys
|
||
lodash.mapValues = mapValues
|
||
lodash.matches = matches
|
||
lodash.matchesProperty = matchesProperty
|
||
lodash.memoize = memoize
|
||
lodash.merge = merge
|
||
lodash.mergeWith = mergeWith
|
||
lodash.method = method
|
||
lodash.methodOf = methodOf
|
||
lodash.mixin = mixin
|
||
lodash.negate = negate
|
||
lodash.nthArg = nthArg
|
||
lodash.omit = omit
|
||
lodash.omitBy = omitBy
|
||
lodash.once = once
|
||
lodash.orderBy = orderBy
|
||
lodash.over = over
|
||
lodash.overArgs = overArgs
|
||
lodash.overEvery = overEvery
|
||
lodash.overSome = overSome
|
||
lodash.partial = partial
|
||
lodash.partialRight = partialRight
|
||
lodash.partition = partition
|
||
lodash.pick = pick
|
||
lodash.pickBy = pickBy
|
||
lodash.property = property
|
||
lodash.propertyOf = propertyOf
|
||
lodash.pull = pull
|
||
lodash.pullAll = pullAll
|
||
lodash.pullAllBy = pullAllBy
|
||
lodash.pullAllWith = pullAllWith
|
||
lodash.pullAt = pullAt
|
||
lodash.range = range
|
||
lodash.rangeRight = rangeRight
|
||
lodash.rearg = rearg
|
||
lodash.reject = reject
|
||
lodash.remove = remove
|
||
lodash.rest = rest
|
||
lodash.reverse = reverse
|
||
lodash.sampleSize = sampleSize
|
||
lodash.set = set
|
||
lodash.setWith = setWith
|
||
lodash.shuffle = shuffle
|
||
lodash.slice = slice
|
||
lodash.sortBy = sortBy
|
||
lodash.sortedUniq = sortedUniq
|
||
lodash.sortedUniqBy = sortedUniqBy
|
||
lodash.split = split
|
||
lodash.spread = spread
|
||
lodash.tail = tail
|
||
lodash.take = take
|
||
lodash.takeRight = takeRight
|
||
lodash.takeRightWhile = takeRightWhile
|
||
lodash.takeWhile = takeWhile
|
||
lodash.tap = tap
|
||
lodash.throttle = throttle
|
||
lodash.thru = thru
|
||
lodash.toArray = toArray
|
||
lodash.toPairs = toPairs
|
||
lodash.toPairsIn = toPairsIn
|
||
lodash.toPath = toPath
|
||
lodash.toPlainObject = toPlainObject
|
||
lodash.transform = transform
|
||
lodash.unary = unary
|
||
lodash.union = union
|
||
lodash.unionBy = unionBy
|
||
lodash.unionWith = unionWith
|
||
lodash.uniq = uniq
|
||
lodash.uniqBy = uniqBy
|
||
lodash.uniqWith = uniqWith
|
||
lodash.unset = unset
|
||
lodash.unzip = unzip
|
||
lodash.unzipWith = unzipWith
|
||
lodash.update = update
|
||
lodash.updateWith = updateWith
|
||
lodash.values = values
|
||
lodash.valuesIn = valuesIn
|
||
lodash.without = without
|
||
lodash.words = words
|
||
lodash.wrap = wrap
|
||
lodash.xor = xor
|
||
lodash.xorBy = xorBy
|
||
lodash.xorWith = xorWith
|
||
lodash.zip = zip
|
||
lodash.zipObject = zipObject
|
||
lodash.zipObjectDeep = zipObjectDeep
|
||
lodash.zipWith = zipWith
|
||
|
||
// Add aliases.
|
||
lodash.entries = toPairs
|
||
lodash.entriesIn = toPairsIn
|
||
lodash.extend = assignIn
|
||
lodash.extendWith = assignInWith
|
||
|
||
// Add methods to `lodash.prototype`.
|
||
mixin(lodash, lodash)
|
||
|
||
/*------------------------------------------------------------------------*/
|
||
|
||
// Add methods that return unwrapped values in chain sequences.
|
||
lodash.add = add
|
||
lodash.attempt = attempt
|
||
lodash.camelCase = camelCase
|
||
lodash.capitalize = capitalize
|
||
lodash.ceil = ceil
|
||
lodash.clamp = clamp
|
||
lodash.clone = clone
|
||
lodash.cloneDeep = cloneDeep
|
||
lodash.cloneDeepWith = cloneDeepWith
|
||
lodash.cloneWith = cloneWith
|
||
lodash.conformsTo = conformsTo
|
||
lodash.deburr = deburr
|
||
lodash.defaultTo = defaultTo
|
||
lodash.divide = divide
|
||
lodash.endsWith = endsWith
|
||
lodash.eq = eq
|
||
lodash.escape = escape
|
||
lodash.escapeRegExp = escapeRegExp
|
||
lodash.every = every
|
||
lodash.find = find
|
||
lodash.findIndex = findIndex
|
||
lodash.findKey = findKey
|
||
lodash.findLast = findLast
|
||
lodash.findLastIndex = findLastIndex
|
||
lodash.findLastKey = findLastKey
|
||
lodash.floor = floor
|
||
lodash.forEach = forEach
|
||
lodash.forEachRight = forEachRight
|
||
lodash.forIn = forIn
|
||
lodash.forInRight = forInRight
|
||
lodash.forOwn = forOwn
|
||
lodash.forOwnRight = forOwnRight
|
||
lodash.get = get
|
||
lodash.gt = gt
|
||
lodash.gte = gte
|
||
lodash.has = has
|
||
lodash.hasIn = hasIn
|
||
lodash.head = head
|
||
lodash.identity = identity
|
||
lodash.includes = includes
|
||
lodash.indexOf = indexOf
|
||
lodash.inRange = inRange
|
||
lodash.invoke = invoke
|
||
lodash.isArguments = isArguments
|
||
lodash.isArray = isArray
|
||
lodash.isArrayBuffer = isArrayBuffer
|
||
lodash.isArrayLike = isArrayLike
|
||
lodash.isArrayLikeObject = isArrayLikeObject
|
||
lodash.isBoolean = isBoolean
|
||
lodash.isBuffer = isBuffer
|
||
lodash.isDate = isDate
|
||
lodash.isElement = isElement
|
||
lodash.isEmpty = isEmpty
|
||
lodash.isEqual = isEqual
|
||
lodash.isEqualWith = isEqualWith
|
||
lodash.isError = isError
|
||
lodash.isFinite = isFinite
|
||
lodash.isFunction = isFunction
|
||
lodash.isInteger = isInteger
|
||
lodash.isLength = isLength
|
||
lodash.isMap = isMap
|
||
lodash.isMatch = isMatch
|
||
lodash.isMatchWith = isMatchWith
|
||
lodash.isNaN = isNaN
|
||
lodash.isNative = isNative
|
||
lodash.isNil = isNil
|
||
lodash.isNull = isNull
|
||
lodash.isNumber = isNumber
|
||
lodash.isObject = isObject
|
||
lodash.isObjectLike = isObjectLike
|
||
lodash.isPlainObject = isPlainObject
|
||
lodash.isRegExp = isRegExp
|
||
lodash.isSafeInteger = isSafeInteger
|
||
lodash.isSet = isSet
|
||
lodash.isString = isString
|
||
lodash.isSymbol = isSymbol
|
||
lodash.isTypedArray = isTypedArray
|
||
lodash.isUndefined = isUndefined
|
||
lodash.isWeakMap = isWeakMap
|
||
lodash.isWeakSet = isWeakSet
|
||
lodash.join = join
|
||
lodash.kebabCase = kebabCase
|
||
lodash.last = last
|
||
lodash.lastIndexOf = lastIndexOf
|
||
lodash.lowerCase = lowerCase
|
||
lodash.lowerFirst = lowerFirst
|
||
lodash.lt = lt
|
||
lodash.lte = lte
|
||
lodash.max = max
|
||
lodash.maxBy = maxBy
|
||
lodash.mean = mean
|
||
lodash.meanBy = meanBy
|
||
lodash.min = min
|
||
lodash.minBy = minBy
|
||
lodash.stubArray = stubArray
|
||
lodash.stubFalse = stubFalse
|
||
lodash.stubObject = stubObject
|
||
lodash.stubString = stubString
|
||
lodash.stubTrue = stubTrue
|
||
lodash.multiply = multiply
|
||
lodash.nth = nth
|
||
lodash.noConflict = noConflict
|
||
lodash.noop = noop
|
||
lodash.now = now
|
||
lodash.pad = pad
|
||
lodash.padEnd = padEnd
|
||
lodash.padStart = padStart
|
||
lodash.parseInt = parseInt
|
||
lodash.random = random
|
||
lodash.reduce = reduce
|
||
lodash.reduceRight = reduceRight
|
||
lodash.repeat = repeat
|
||
lodash.replace = replace
|
||
lodash.result = result
|
||
lodash.round = round
|
||
lodash.runInContext = runInContext
|
||
lodash.sample = sample
|
||
lodash.size = size
|
||
lodash.snakeCase = snakeCase
|
||
lodash.some = some
|
||
lodash.sortedIndex = sortedIndex
|
||
lodash.sortedIndexBy = sortedIndexBy
|
||
lodash.sortedIndexOf = sortedIndexOf
|
||
lodash.sortedLastIndex = sortedLastIndex
|
||
lodash.sortedLastIndexBy = sortedLastIndexBy
|
||
lodash.sortedLastIndexOf = sortedLastIndexOf
|
||
lodash.startCase = startCase
|
||
lodash.startsWith = startsWith
|
||
lodash.subtract = subtract
|
||
lodash.sum = sum
|
||
lodash.sumBy = sumBy
|
||
lodash.template = template
|
||
lodash.times = times
|
||
lodash.toFinite = toFinite
|
||
lodash.toInteger = toInteger
|
||
lodash.toLength = toLength
|
||
lodash.toLower = toLower
|
||
lodash.toNumber = toNumber
|
||
lodash.toSafeInteger = toSafeInteger
|
||
lodash.toString = toString
|
||
lodash.toUpper = toUpper
|
||
lodash.trim = trim
|
||
lodash.trimEnd = trimEnd
|
||
lodash.trimStart = trimStart
|
||
lodash.truncate = truncate
|
||
lodash.unescape = unescape
|
||
lodash.uniqueId = uniqueId
|
||
lodash.upperCase = upperCase
|
||
lodash.upperFirst = upperFirst
|
||
|
||
// Add aliases.
|
||
lodash.each = forEach
|
||
lodash.eachRight = forEachRight
|
||
lodash.first = head
|
||
|
||
mixin(
|
||
lodash,
|
||
(function() {
|
||
var source = {}
|
||
baseForOwn(lodash, function(func, methodName) {
|
||
if (!hasOwnProperty.call(lodash.prototype, methodName)) {
|
||
source[methodName] = func
|
||
}
|
||
})
|
||
return source
|
||
})(),
|
||
{ chain: false }
|
||
)
|
||
|
||
/*------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* The semantic version number.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @type {string}
|
||
*/
|
||
lodash.VERSION = VERSION
|
||
|
||
// Assign default placeholders.
|
||
arrayEach(
|
||
["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"],
|
||
function(methodName) {
|
||
lodash[methodName].placeholder = lodash
|
||
}
|
||
)
|
||
|
||
// Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
|
||
arrayEach(["drop", "take"], function(methodName, index) {
|
||
LazyWrapper.prototype[methodName] = function(n) {
|
||
n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0)
|
||
|
||
var result =
|
||
this.__filtered__ && !index ? new LazyWrapper(this) : this.clone()
|
||
|
||
if (result.__filtered__) {
|
||
result.__takeCount__ = nativeMin(n, result.__takeCount__)
|
||
} else {
|
||
result.__views__.push({
|
||
size: nativeMin(n, MAX_ARRAY_LENGTH),
|
||
type: methodName + (result.__dir__ < 0 ? "Right" : ""),
|
||
})
|
||
}
|
||
return result
|
||
}
|
||
|
||
LazyWrapper.prototype[methodName + "Right"] = function(n) {
|
||
return this.reverse()
|
||
[methodName](n)
|
||
.reverse()
|
||
}
|
||
})
|
||
|
||
// Add `LazyWrapper` methods that accept an `iteratee` value.
|
||
arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
|
||
var type = index + 1,
|
||
isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG
|
||
|
||
LazyWrapper.prototype[methodName] = function(iteratee) {
|
||
var result = this.clone()
|
||
result.__iteratees__.push({
|
||
iteratee: getIteratee(iteratee, 3),
|
||
type: type,
|
||
})
|
||
result.__filtered__ = result.__filtered__ || isFilter
|
||
return result
|
||
}
|
||
})
|
||
|
||
// Add `LazyWrapper` methods for `_.head` and `_.last`.
|
||
arrayEach(["head", "last"], function(methodName, index) {
|
||
var takeName = "take" + (index ? "Right" : "")
|
||
|
||
LazyWrapper.prototype[methodName] = function() {
|
||
return this[takeName](1).value()[0]
|
||
}
|
||
})
|
||
|
||
// Add `LazyWrapper` methods for `_.initial` and `_.tail`.
|
||
arrayEach(["initial", "tail"], function(methodName, index) {
|
||
var dropName = "drop" + (index ? "" : "Right")
|
||
|
||
LazyWrapper.prototype[methodName] = function() {
|
||
return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1)
|
||
}
|
||
})
|
||
|
||
LazyWrapper.prototype.compact = function() {
|
||
return this.filter(identity)
|
||
}
|
||
|
||
LazyWrapper.prototype.find = function(predicate) {
|
||
return this.filter(predicate).head()
|
||
}
|
||
|
||
LazyWrapper.prototype.findLast = function(predicate) {
|
||
return this.reverse().find(predicate)
|
||
}
|
||
|
||
LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
|
||
if (typeof path == "function") {
|
||
return new LazyWrapper(this)
|
||
}
|
||
return this.map(function(value) {
|
||
return baseInvoke(value, path, args)
|
||
})
|
||
})
|
||
|
||
LazyWrapper.prototype.reject = function(predicate) {
|
||
return this.filter(negate(getIteratee(predicate)))
|
||
}
|
||
|
||
LazyWrapper.prototype.slice = function(start, end) {
|
||
start = toInteger(start)
|
||
|
||
var result = this
|
||
if (result.__filtered__ && (start > 0 || end < 0)) {
|
||
return new LazyWrapper(result)
|
||
}
|
||
if (start < 0) {
|
||
result = result.takeRight(-start)
|
||
} else if (start) {
|
||
result = result.drop(start)
|
||
}
|
||
if (end !== undefined$1) {
|
||
end = toInteger(end)
|
||
result = end < 0 ? result.dropRight(-end) : result.take(end - start)
|
||
}
|
||
return result
|
||
}
|
||
|
||
LazyWrapper.prototype.takeRightWhile = function(predicate) {
|
||
return this.reverse()
|
||
.takeWhile(predicate)
|
||
.reverse()
|
||
}
|
||
|
||
LazyWrapper.prototype.toArray = function() {
|
||
return this.take(MAX_ARRAY_LENGTH)
|
||
}
|
||
|
||
// Add `LazyWrapper` methods to `lodash.prototype`.
|
||
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
|
||
var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(
|
||
methodName
|
||
),
|
||
isTaker = /^(?:head|last)$/.test(methodName),
|
||
lodashFunc =
|
||
lodash[
|
||
isTaker
|
||
? "take" + (methodName == "last" ? "Right" : "")
|
||
: methodName
|
||
],
|
||
retUnwrapped = isTaker || /^find/.test(methodName)
|
||
|
||
if (!lodashFunc) {
|
||
return
|
||
}
|
||
lodash.prototype[methodName] = function() {
|
||
var value = this.__wrapped__,
|
||
args = isTaker ? [1] : arguments,
|
||
isLazy = value instanceof LazyWrapper,
|
||
iteratee = args[0],
|
||
useLazy = isLazy || isArray(value)
|
||
|
||
var interceptor = function(value) {
|
||
var result = lodashFunc.apply(lodash, arrayPush([value], args))
|
||
return isTaker && chainAll ? result[0] : result
|
||
}
|
||
|
||
if (
|
||
useLazy &&
|
||
checkIteratee &&
|
||
typeof iteratee == "function" &&
|
||
iteratee.length != 1
|
||
) {
|
||
// Avoid lazy use if the iteratee has a "length" value other than `1`.
|
||
isLazy = useLazy = false
|
||
}
|
||
var chainAll = this.__chain__,
|
||
isHybrid = !!this.__actions__.length,
|
||
isUnwrapped = retUnwrapped && !chainAll,
|
||
onlyLazy = isLazy && !isHybrid
|
||
|
||
if (!retUnwrapped && useLazy) {
|
||
value = onlyLazy ? value : new LazyWrapper(this)
|
||
var result = func.apply(value, args)
|
||
result.__actions__.push({
|
||
func: thru,
|
||
args: [interceptor],
|
||
thisArg: undefined$1,
|
||
})
|
||
return new LodashWrapper(result, chainAll)
|
||
}
|
||
if (isUnwrapped && onlyLazy) {
|
||
return func.apply(this, args)
|
||
}
|
||
result = this.thru(interceptor)
|
||
return isUnwrapped
|
||
? isTaker
|
||
? result.value()[0]
|
||
: result.value()
|
||
: result
|
||
}
|
||
})
|
||
|
||
// Add `Array` methods to `lodash.prototype`.
|
||
arrayEach(
|
||
["pop", "push", "shift", "sort", "splice", "unshift"],
|
||
function(methodName) {
|
||
var func = arrayProto[methodName],
|
||
chainName = /^(?:push|sort|unshift)$/.test(methodName)
|
||
? "tap"
|
||
: "thru",
|
||
retUnwrapped = /^(?:pop|shift)$/.test(methodName)
|
||
|
||
lodash.prototype[methodName] = function() {
|
||
var args = arguments
|
||
if (retUnwrapped && !this.__chain__) {
|
||
var value = this.value()
|
||
return func.apply(isArray(value) ? value : [], args)
|
||
}
|
||
return this[chainName](function(value) {
|
||
return func.apply(isArray(value) ? value : [], args)
|
||
})
|
||
}
|
||
}
|
||
)
|
||
|
||
// Map minified method names to their real names.
|
||
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
|
||
var lodashFunc = lodash[methodName]
|
||
if (lodashFunc) {
|
||
var key = lodashFunc.name + ""
|
||
if (!hasOwnProperty.call(realNames, key)) {
|
||
realNames[key] = []
|
||
}
|
||
realNames[key].push({ name: methodName, func: lodashFunc })
|
||
}
|
||
})
|
||
|
||
realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [
|
||
{
|
||
name: "wrapper",
|
||
func: undefined$1,
|
||
},
|
||
]
|
||
|
||
// Add methods to `LazyWrapper`.
|
||
LazyWrapper.prototype.clone = lazyClone
|
||
LazyWrapper.prototype.reverse = lazyReverse
|
||
LazyWrapper.prototype.value = lazyValue
|
||
|
||
// Add chain sequence methods to the `lodash` wrapper.
|
||
lodash.prototype.at = wrapperAt
|
||
lodash.prototype.chain = wrapperChain
|
||
lodash.prototype.commit = wrapperCommit
|
||
lodash.prototype.next = wrapperNext
|
||
lodash.prototype.plant = wrapperPlant
|
||
lodash.prototype.reverse = wrapperReverse
|
||
lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue
|
||
|
||
// Add lazy aliases.
|
||
lodash.prototype.first = lodash.prototype.head
|
||
|
||
if (symIterator) {
|
||
lodash.prototype[symIterator] = wrapperToIterator
|
||
}
|
||
return lodash
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
// Export lodash.
|
||
var _ = runInContext()
|
||
|
||
// Some AMD build optimizers, like r.js, check for condition patterns like:
|
||
if (freeModule) {
|
||
// Export for Node.js.
|
||
;(freeModule.exports = _)._ = _
|
||
// Export for CommonJS support.
|
||
freeExports._ = _
|
||
} else {
|
||
// Export to the global object.
|
||
root._ = _
|
||
}
|
||
}.call(commonjsGlobal))
|
||
})
|
||
var lodash_1 = lodash.flow
|
||
var lodash_2 = lodash.head
|
||
var lodash_3 = lodash.tail
|
||
var lodash_4 = lodash.findIndex
|
||
var lodash_5 = lodash.startsWith
|
||
var lodash_6 = lodash.dropRight
|
||
var lodash_7 = lodash.takeRight
|
||
var lodash_8 = lodash.trim
|
||
var lodash_9 = lodash.split
|
||
var lodash_10 = lodash.replace
|
||
var lodash_11 = lodash.merge
|
||
var lodash_12 = lodash.assign
|
||
|
||
const commonPlus = extra => fp_5(["onBegin", "onComplete", "onError"])(extra)
|
||
|
||
const common = () => commonPlus([])
|
||
|
||
const _events = {
|
||
recordApi: {
|
||
save: commonPlus(["onInvalid", "onRecordUpdated", "onRecordCreated"]),
|
||
delete: common(),
|
||
getContext: common(),
|
||
getNew: common(),
|
||
load: common(),
|
||
validate: common(),
|
||
uploadFile: common(),
|
||
downloadFile: common(),
|
||
},
|
||
indexApi: {
|
||
buildIndex: common(),
|
||
listItems: common(),
|
||
delete: common(),
|
||
aggregates: common(),
|
||
},
|
||
collectionApi: {
|
||
getAllowedRecordTypes: common(),
|
||
initialise: common(),
|
||
delete: common(),
|
||
},
|
||
authApi: {
|
||
authenticate: common(),
|
||
authenticateTemporaryAccess: common(),
|
||
createTemporaryAccess: common(),
|
||
createUser: common(),
|
||
enableUser: common(),
|
||
disableUser: common(),
|
||
loadAccessLevels: common(),
|
||
getNewAccessLevel: common(),
|
||
getNewUser: common(),
|
||
getNewUserAuth: common(),
|
||
getUsers: common(),
|
||
saveAccessLevels: common(),
|
||
isAuthorized: common(),
|
||
changeMyPassword: common(),
|
||
setPasswordFromTemporaryCode: common(),
|
||
scorePassword: common(),
|
||
isValidPassword: common(),
|
||
validateUser: common(),
|
||
validateAccessLevels: common(),
|
||
setUserAccessLevels: common(),
|
||
},
|
||
templateApi: {
|
||
saveApplicationHierarchy: common(),
|
||
saveActionsAndTriggers: common(),
|
||
},
|
||
actionsApi: {
|
||
execute: common(),
|
||
},
|
||
}
|
||
|
||
const _eventsList = []
|
||
|
||
const makeEvent = (area, method, name) => `${area}:${method}:${name}`
|
||
|
||
for (const areaKey in _events) {
|
||
for (const methodKey in _events[areaKey]) {
|
||
_events[areaKey][methodKey] = fp_6((obj, s) => {
|
||
obj[s] = makeEvent(areaKey, methodKey, s)
|
||
return obj
|
||
}, {})(_events[areaKey][methodKey])
|
||
}
|
||
}
|
||
|
||
for (const areaKey in _events) {
|
||
for (const methodKey in _events[areaKey]) {
|
||
for (const name in _events[areaKey][methodKey]) {
|
||
_eventsList.push(_events[areaKey][methodKey][name])
|
||
}
|
||
}
|
||
}
|
||
|
||
const events = _events
|
||
|
||
// Found this seed-based random generator somewhere
|
||
// Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu)
|
||
|
||
var seed = 1
|
||
|
||
/**
|
||
* return a random number based on a seed
|
||
* @param seed
|
||
* @returns {number}
|
||
*/
|
||
function getNextValue() {
|
||
seed = (seed * 9301 + 49297) % 233280
|
||
return seed / 233280.0
|
||
}
|
||
|
||
function setSeed(_seed_) {
|
||
seed = _seed_
|
||
}
|
||
|
||
var randomFromSeed = {
|
||
nextValue: getNextValue,
|
||
seed: setSeed,
|
||
}
|
||
|
||
var ORIGINAL =
|
||
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"
|
||
var alphabet
|
||
var previousSeed
|
||
|
||
var shuffled
|
||
|
||
function reset() {
|
||
shuffled = false
|
||
}
|
||
|
||
function setCharacters(_alphabet_) {
|
||
if (!_alphabet_) {
|
||
if (alphabet !== ORIGINAL) {
|
||
alphabet = ORIGINAL
|
||
reset()
|
||
}
|
||
return
|
||
}
|
||
|
||
if (_alphabet_ === alphabet) {
|
||
return
|
||
}
|
||
|
||
if (_alphabet_.length !== ORIGINAL.length) {
|
||
throw new Error(
|
||
"Custom alphabet for shortid must be " +
|
||
ORIGINAL.length +
|
||
" unique characters. You submitted " +
|
||
_alphabet_.length +
|
||
" characters: " +
|
||
_alphabet_
|
||
)
|
||
}
|
||
|
||
var unique = _alphabet_.split("").filter(function(item, ind, arr) {
|
||
return ind !== arr.lastIndexOf(item)
|
||
})
|
||
|
||
if (unique.length) {
|
||
throw new Error(
|
||
"Custom alphabet for shortid must be " +
|
||
ORIGINAL.length +
|
||
" unique characters. These characters were not unique: " +
|
||
unique.join(", ")
|
||
)
|
||
}
|
||
|
||
alphabet = _alphabet_
|
||
reset()
|
||
}
|
||
|
||
function characters(_alphabet_) {
|
||
setCharacters(_alphabet_)
|
||
return alphabet
|
||
}
|
||
|
||
function setSeed$1(seed) {
|
||
randomFromSeed.seed(seed)
|
||
if (previousSeed !== seed) {
|
||
reset()
|
||
previousSeed = seed
|
||
}
|
||
}
|
||
|
||
function shuffle() {
|
||
if (!alphabet) {
|
||
setCharacters(ORIGINAL)
|
||
}
|
||
|
||
var sourceArray = alphabet.split("")
|
||
var targetArray = []
|
||
var r = randomFromSeed.nextValue()
|
||
var characterIndex
|
||
|
||
while (sourceArray.length > 0) {
|
||
r = randomFromSeed.nextValue()
|
||
characterIndex = Math.floor(r * sourceArray.length)
|
||
targetArray.push(sourceArray.splice(characterIndex, 1)[0])
|
||
}
|
||
return targetArray.join("")
|
||
}
|
||
|
||
function getShuffled() {
|
||
if (shuffled) {
|
||
return shuffled
|
||
}
|
||
shuffled = shuffle()
|
||
return shuffled
|
||
}
|
||
|
||
/**
|
||
* lookup shuffled letter
|
||
* @param index
|
||
* @returns {string}
|
||
*/
|
||
function lookup(index) {
|
||
var alphabetShuffled = getShuffled()
|
||
return alphabetShuffled[index]
|
||
}
|
||
|
||
function get() {
|
||
return alphabet || ORIGINAL
|
||
}
|
||
|
||
var alphabet_1 = {
|
||
get: get,
|
||
characters: characters,
|
||
seed: setSeed$1,
|
||
lookup: lookup,
|
||
shuffled: getShuffled,
|
||
}
|
||
|
||
var crypto = typeof window === "object" && (window.crypto || window.msCrypto) // IE 11 uses window.msCrypto
|
||
|
||
var randomByte
|
||
|
||
if (!crypto || !crypto.getRandomValues) {
|
||
randomByte = function(size) {
|
||
var bytes = []
|
||
for (var i = 0; i < size; i++) {
|
||
bytes.push(Math.floor(Math.random() * 256))
|
||
}
|
||
return bytes
|
||
}
|
||
} else {
|
||
randomByte = function(size) {
|
||
return crypto.getRandomValues(new Uint8Array(size))
|
||
}
|
||
}
|
||
|
||
var randomByteBrowser = randomByte
|
||
|
||
/**
|
||
* Secure random string generator with custom alphabet.
|
||
*
|
||
* Alphabet must contain 256 symbols or less. Otherwise, the generator
|
||
* will not be secure.
|
||
*
|
||
* @param {generator} random The random bytes generator.
|
||
* @param {string} alphabet Symbols to be used in new random string.
|
||
* @param {size} size The number of symbols in new random string.
|
||
*
|
||
* @return {string} Random string.
|
||
*
|
||
* @example
|
||
* const format = require('nanoid/format')
|
||
*
|
||
* function random (size) {
|
||
* const result = []
|
||
* for (let i = 0; i < size; i++) {
|
||
* result.push(randomByte())
|
||
* }
|
||
* return result
|
||
* }
|
||
*
|
||
* format(random, "abcdef", 5) //=> "fbaef"
|
||
*
|
||
* @name format
|
||
* @function
|
||
*/
|
||
var format = function(random, alphabet, size) {
|
||
var mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
|
||
var step = Math.ceil((1.6 * mask * size) / alphabet.length)
|
||
size = +size
|
||
|
||
var id = ""
|
||
while (true) {
|
||
var bytes = random(step)
|
||
for (var i = 0; i < step; i++) {
|
||
var byte = bytes[i] & mask
|
||
if (alphabet[byte]) {
|
||
id += alphabet[byte]
|
||
if (id.length === size) return id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function generate(number) {
|
||
var loopCounter = 0
|
||
var done
|
||
|
||
var str = ""
|
||
|
||
while (!done) {
|
||
str = str + format(randomByteBrowser, alphabet_1.get(), 1)
|
||
done = number < Math.pow(16, loopCounter + 1)
|
||
loopCounter++
|
||
}
|
||
return str
|
||
}
|
||
|
||
var generate_1 = generate
|
||
|
||
// Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness.
|
||
// This number should be updated every year or so to keep the generated id short.
|
||
// To regenerate `new Date() - 0` and bump the version. Always bump the version!
|
||
var REDUCE_TIME = 1567752802062
|
||
|
||
// don't change unless we change the algos or REDUCE_TIME
|
||
// must be an integer and less than 16
|
||
var version = 7
|
||
|
||
// Counter is used when shortid is called multiple times in one second.
|
||
var counter
|
||
|
||
// Remember the last time shortid was called in case counter is needed.
|
||
var previousSeconds
|
||
|
||
/**
|
||
* Generate unique id
|
||
* Returns string id
|
||
*/
|
||
function build(clusterWorkerId) {
|
||
var str = ""
|
||
|
||
var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001)
|
||
|
||
if (seconds === previousSeconds) {
|
||
counter++
|
||
} else {
|
||
counter = 0
|
||
previousSeconds = seconds
|
||
}
|
||
|
||
str = str + generate_1(version)
|
||
str = str + generate_1(clusterWorkerId)
|
||
if (counter > 0) {
|
||
str = str + generate_1(counter)
|
||
}
|
||
str = str + generate_1(seconds)
|
||
return str
|
||
}
|
||
|
||
var build_1 = build
|
||
|
||
function isShortId(id) {
|
||
if (!id || typeof id !== "string" || id.length < 6) {
|
||
return false
|
||
}
|
||
|
||
var nonAlphabetic = new RegExp(
|
||
"[^" + alphabet_1.get().replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&") + "]"
|
||
)
|
||
return !nonAlphabetic.test(id)
|
||
}
|
||
|
||
var isValid = isShortId
|
||
|
||
var lib = createCommonjsModule(function(module) {
|
||
// if you are using cluster or multiple servers use this to make each instance
|
||
// has a unique value for worker
|
||
// Note: I don't know if this is automatically set when using third
|
||
// party cluster solutions such as pm2.
|
||
var clusterWorkerId = 0
|
||
|
||
/**
|
||
* Set the seed.
|
||
* Highly recommended if you don't want people to try to figure out your id schema.
|
||
* exposed as shortid.seed(int)
|
||
* @param seed Integer value to seed the random alphabet. ALWAYS USE THE SAME SEED or you might get overlaps.
|
||
*/
|
||
function seed(seedValue) {
|
||
alphabet_1.seed(seedValue)
|
||
return module.exports
|
||
}
|
||
|
||
/**
|
||
* Set the cluster worker or machine id
|
||
* exposed as shortid.worker(int)
|
||
* @param workerId worker must be positive integer. Number less than 16 is recommended.
|
||
* returns shortid module so it can be chained.
|
||
*/
|
||
function worker(workerId) {
|
||
clusterWorkerId = workerId
|
||
return module.exports
|
||
}
|
||
|
||
/**
|
||
*
|
||
* sets new characters to use in the alphabet
|
||
* returns the shuffled alphabet
|
||
*/
|
||
function characters(newCharacters) {
|
||
if (newCharacters !== undefined) {
|
||
alphabet_1.characters(newCharacters)
|
||
}
|
||
|
||
return alphabet_1.shuffled()
|
||
}
|
||
|
||
/**
|
||
* Generate unique id
|
||
* Returns string id
|
||
*/
|
||
function generate() {
|
||
return build_1(clusterWorkerId)
|
||
}
|
||
|
||
// Export all other functions as properties of the generate function
|
||
module.exports = generate
|
||
module.exports.generate = generate
|
||
module.exports.seed = seed
|
||
module.exports.worker = worker
|
||
module.exports.characters = characters
|
||
module.exports.isValid = isValid
|
||
})
|
||
var lib_1 = lib.generate
|
||
var lib_2 = lib.seed
|
||
var lib_3 = lib.worker
|
||
var lib_4 = lib.characters
|
||
var lib_5 = lib.isValid
|
||
|
||
var shortid = lib
|
||
var shortid_1 = shortid.generate
|
||
|
||
class BadRequestError extends Error {
|
||
constructor(message) {
|
||
super(message)
|
||
this.httpStatusCode = 400
|
||
}
|
||
}
|
||
|
||
class UnauthorisedError extends Error {
|
||
constructor(message) {
|
||
super(message)
|
||
this.httpStatusCode = 401
|
||
}
|
||
}
|
||
|
||
const apiWrapperSync = (
|
||
app,
|
||
eventNamespace,
|
||
isAuthorized,
|
||
eventContext,
|
||
func,
|
||
...params
|
||
) => {
|
||
pushCallStack(app, eventNamespace)
|
||
|
||
if (!isAuthorized(app)) {
|
||
handleNotAuthorized(app, eventContext, eventNamespace)
|
||
return
|
||
}
|
||
|
||
const startDate = Date.now()
|
||
const elapsed = () => Date.now() - startDate
|
||
|
||
try {
|
||
app.publish(eventNamespace.onBegin, eventContext)
|
||
|
||
const result = func(...params)
|
||
|
||
publishComplete(app, eventContext, eventNamespace, elapsed, result)
|
||
return result
|
||
} catch (error) {
|
||
publishError(app, eventContext, eventNamespace, elapsed, error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
const handleNotAuthorized = (app, eventContext, eventNamespace) => {
|
||
const err = new UnauthorisedError(`Unauthorized: ${eventNamespace}`)
|
||
publishError(app, eventContext, eventNamespace, () => 0, err)
|
||
throw err
|
||
}
|
||
|
||
const pushCallStack = (app, eventNamespace, seedCallId) => {
|
||
const callId = shortid_1()
|
||
|
||
const createCallStack = () => ({
|
||
seedCallId: !fp_2(seedCallId) ? seedCallId : callId,
|
||
threadCallId: callId,
|
||
stack: [],
|
||
})
|
||
|
||
if (fp_2(app.calls)) {
|
||
app.calls = createCallStack()
|
||
}
|
||
|
||
app.calls.stack.push({
|
||
namespace: eventNamespace,
|
||
callId,
|
||
})
|
||
}
|
||
|
||
const popCallStack = app => {
|
||
app.calls.stack.pop()
|
||
if (app.calls.stack.length === 0) {
|
||
delete app.calls
|
||
}
|
||
}
|
||
|
||
const publishError = async (
|
||
app,
|
||
eventContext,
|
||
eventNamespace,
|
||
elapsed,
|
||
err
|
||
) => {
|
||
const ctx = fp_8(eventContext)
|
||
ctx.error = err
|
||
ctx.elapsed = elapsed()
|
||
await app.publish(eventNamespace.onError, ctx)
|
||
popCallStack(app)
|
||
}
|
||
|
||
const publishComplete = async (
|
||
app,
|
||
eventContext,
|
||
eventNamespace,
|
||
elapsed,
|
||
result
|
||
) => {
|
||
const endcontext = fp_8(eventContext)
|
||
endcontext.result = result
|
||
endcontext.elapsed = elapsed()
|
||
await app.publish(eventNamespace.onComplete, endcontext)
|
||
popCallStack(app)
|
||
return result
|
||
}
|
||
|
||
// this is the combinator function
|
||
const $$ = (...funcs) => arg => lodash_1(funcs)(arg)
|
||
|
||
// this is the pipe function
|
||
const $ = (arg, funcs) => $$(...funcs)(arg)
|
||
|
||
const keySep = "/"
|
||
const trimKeySep = str => lodash_8(str, keySep)
|
||
const splitByKeySep = str => fp_3(keySep)(str)
|
||
const safeKey = key =>
|
||
lodash_10(`${keySep}${trimKeySep(key)}`, `${keySep}${keySep}`, keySep)
|
||
const joinKey = (...strs) => {
|
||
const paramsOrArray = (strs.length === 1) & fp_10(strs[0]) ? strs[0] : strs
|
||
return safeKey(fp_17(keySep)(paramsOrArray))
|
||
}
|
||
const splitKey = $$(trimKeySep, splitByKeySep)
|
||
|
||
const configFolder = `${keySep}.config`
|
||
const fieldDefinitions = joinKey(configFolder, "fields.json")
|
||
const templateDefinitions = joinKey(configFolder, "templates.json")
|
||
const appDefinitionFile = joinKey(configFolder, "appDefinition.json")
|
||
|
||
const not = func => val => !func(val)
|
||
const isDefined = not(fp_2)
|
||
const isNonNull = not(fp_28)
|
||
const isNotNaN = not(fp_35)
|
||
|
||
const allTrue = (...funcArgs) => val =>
|
||
fp_6(
|
||
(result, conditionFunc) =>
|
||
(fp_28(result) || result == true) && conditionFunc(val),
|
||
null
|
||
)(funcArgs)
|
||
|
||
const isSomething = allTrue(isDefined, isNonNull, isNotNaN)
|
||
const isNothing = not(isSomething)
|
||
|
||
const none = predicate => collection => !fp_9(predicate)(collection)
|
||
|
||
const all = predicate => collection => none(v => !predicate(v))(collection)
|
||
|
||
const isNotEmpty = ob => !fp_15(ob)
|
||
const isNonEmptyString = allTrue(fp_26, isNotEmpty)
|
||
const tryOr = failFunc => (func, ...args) => {
|
||
try {
|
||
return func.apply(null, ...args)
|
||
} catch (_) {
|
||
return failFunc()
|
||
}
|
||
}
|
||
const causesException = func => {
|
||
try {
|
||
func()
|
||
return false
|
||
} catch (e) {
|
||
return true
|
||
}
|
||
}
|
||
|
||
const executesWithoutException = func => !causesException(func)
|
||
|
||
const handleErrorWith = returnValInError => tryOr(fp_20(returnValInError))
|
||
|
||
const handleErrorWithUndefined = handleErrorWith(undefined)
|
||
|
||
const switchCase = (...cases) => value => {
|
||
const nextCase = () => lodash_2(cases)[0](value)
|
||
const nextResult = () => lodash_2(cases)[1](value)
|
||
|
||
if (fp_15(cases)) return // undefined
|
||
if (nextCase() === true) return nextResult()
|
||
return switchCase(...lodash_3(cases))(value)
|
||
}
|
||
const isOneOf = (...vals) => val => fp_18(val)(vals)
|
||
const defaultCase = fp_20(true)
|
||
|
||
const isSafeInteger = n =>
|
||
fp_36(n) && n <= Number.MAX_SAFE_INTEGER && n >= 0 - Number.MAX_SAFE_INTEGER
|
||
|
||
const toDateOrNull = s => (fp_28(s) ? null : fp_31(s) ? s : new Date(s))
|
||
const toBoolOrNull = s => (fp_28(s) ? null : s === "true" || s === true)
|
||
const toNumberOrNull = s => (fp_28(s) ? null : fp_37(s))
|
||
|
||
const isArrayOfString = opts => fp_10(opts) && all(fp_26)(opts)
|
||
|
||
const setState = (store, path, value) => {
|
||
if (!path || path.length === 0) return
|
||
|
||
const pathParts = path.split(".")
|
||
const safeSetPath = (obj, currentPartIndex = 0) => {
|
||
const currentKey = pathParts[currentPartIndex]
|
||
|
||
if (pathParts.length - 1 == currentPartIndex) {
|
||
obj[currentKey] = value
|
||
return
|
||
}
|
||
|
||
if (
|
||
obj[currentKey] === null ||
|
||
obj[currentKey] === undefined ||
|
||
!fp_7(obj.currentKey)
|
||
) {
|
||
obj[currentKey] = {}
|
||
}
|
||
|
||
safeSetPath(obj[currentKey], currentPartIndex + 1)
|
||
}
|
||
|
||
store.update(s => {
|
||
safeSetPath(s)
|
||
return s
|
||
})
|
||
}
|
||
|
||
const BB_STATE_BINDINGPATH = "##bbstate"
|
||
const BB_STATE_BINDINGSOURCE = "##bbsource"
|
||
const BB_STATE_FALLBACK = "##bbstatefallback"
|
||
|
||
const isBound = prop => prop[BB_STATE_BINDINGPATH] !== undefined
|
||
const takeStateFromStore = prop =>
|
||
prop[BB_STATE_BINDINGSOURCE] === undefined ||
|
||
prop[BB_STATE_BINDINGSOURCE] === "store"
|
||
|
||
const takeStateFromContext = prop =>
|
||
prop[BB_STATE_BINDINGSOURCE] === "context"
|
||
|
||
const takeStateFromEventParameters = prop =>
|
||
prop[BB_STATE_BINDINGSOURCE] === "event"
|
||
|
||
const getState = (s, path, fallback) => {
|
||
if (!path || path.length === 0) return fallback
|
||
|
||
const pathParts = path.split(".")
|
||
const safeGetPath = (obj, currentPartIndex = 0) => {
|
||
const currentKey = pathParts[currentPartIndex]
|
||
|
||
if (pathParts.length - 1 == currentPartIndex) {
|
||
const value = obj[currentKey]
|
||
if (fp_2(value)) return fallback
|
||
else return value
|
||
}
|
||
|
||
if (
|
||
obj[currentKey] === null ||
|
||
obj[currentKey] === undefined ||
|
||
!fp_7(obj[currentKey])
|
||
) {
|
||
return fallback
|
||
}
|
||
|
||
return safeGetPath(obj[currentKey], currentPartIndex + 1)
|
||
}
|
||
|
||
return safeGetPath(s)
|
||
}
|
||
|
||
const getStateOrValue = (globalState, prop, currentContext) => {
|
||
if (!isBound(prop)) return prop
|
||
|
||
const stateToUse = takeStateFromStore(prop) ? globalState : currentContext
|
||
|
||
return getState(
|
||
stateToUse,
|
||
prop[BB_STATE_BINDINGPATH],
|
||
prop[BB_STATE_FALLBACK]
|
||
)
|
||
}
|
||
|
||
const ERROR = "##error_message"
|
||
|
||
const trimSlash = str => str.replace(/^\/+|\/+$/g, "")
|
||
|
||
const loadRecord = api => async ({ recordKey, statePath }) => {
|
||
if (!recordKey) {
|
||
api.error("Load Record: record key not set")
|
||
return
|
||
}
|
||
|
||
if (!statePath) {
|
||
api.error("Load Record: state path not set")
|
||
return
|
||
}
|
||
|
||
const record = await api.get({
|
||
url: `/api/record/${trimSlash(key)}`,
|
||
})
|
||
|
||
if (api.isSuccess(record)) api.setState(statePath, record)
|
||
}
|
||
|
||
const listRecords = api => async ({ indexKey, statePath }) => {
|
||
if (!indexKey) {
|
||
api.error("Load Record: record key not set")
|
||
return
|
||
}
|
||
|
||
if (!statePath) {
|
||
api.error("Load Record: state path not set")
|
||
return
|
||
}
|
||
|
||
const records = api.get({
|
||
url: `/api/listRecords/${trimSlash(indexKey)}`,
|
||
})
|
||
|
||
if (api.isSuccess(records)) api.setState(statePath, records)
|
||
}
|
||
|
||
const USER_STATE_PATH = "_bbuser"
|
||
|
||
const authenticate = api => async ({ username, password }) => {
|
||
if (!username) {
|
||
api.error("Authenticate: username not set")
|
||
return
|
||
}
|
||
|
||
if (!password) {
|
||
api.error("Authenticate: password not set")
|
||
return
|
||
}
|
||
|
||
const user = await api.post({
|
||
url: "/api/authenticate",
|
||
body: { username, password },
|
||
})
|
||
|
||
// set user even if error - so it is defined at least
|
||
api.setState(USER_STATE_PATH, user)
|
||
localStorage.setItem("budibase:user", user)
|
||
}
|
||
|
||
const createApi = ({ rootPath, setState, getState }) => {
|
||
const apiCall = method => ({
|
||
url,
|
||
body,
|
||
notFound,
|
||
badRequest,
|
||
forbidden,
|
||
}) => {
|
||
fetch(`${rootPath}${url}`, {
|
||
method: method,
|
||
headers: {
|
||
"Content-Type": "application/json",
|
||
},
|
||
body: body && JSON.stringify(body),
|
||
credentials: "same-origin",
|
||
}).then(r => {
|
||
switch (r.status) {
|
||
case 200:
|
||
return r.json()
|
||
case 404:
|
||
return error(notFound || `${url} Not found`)
|
||
case 400:
|
||
return error(badRequest || `${url} Bad Request`)
|
||
case 403:
|
||
return error(forbidden || `${url} Forbidden`)
|
||
default:
|
||
if (
|
||
r.status.toString().startsWith("2") ||
|
||
r.status.toString().startsWith("3")
|
||
)
|
||
return r.json()
|
||
else return error(`${url} - ${r.statusText}`)
|
||
}
|
||
})
|
||
}
|
||
|
||
const post = apiCall("POST")
|
||
const get = apiCall("GET")
|
||
const patch = apiCall("PATCH")
|
||
const del = apiCall("DELETE")
|
||
|
||
const ERROR_MEMBER = "##error"
|
||
const error = message => {
|
||
const e = {}
|
||
e[ERROR_MEMBER] = message
|
||
setState(ERROR, message)
|
||
return e
|
||
}
|
||
|
||
const isSuccess = obj => !!obj[ERROR_MEMBER]
|
||
|
||
const apiOpts = {
|
||
rootPath,
|
||
setState,
|
||
getState,
|
||
isSuccess,
|
||
error,
|
||
post,
|
||
get,
|
||
patch,
|
||
delete: del,
|
||
}
|
||
|
||
return {
|
||
loadRecord: loadRecord(apiOpts),
|
||
listRecords: listRecords(apiOpts),
|
||
authenticate: authenticate(apiOpts),
|
||
}
|
||
}
|
||
|
||
const getNewChildRecordToState = (store, coreApi, setState) => ({
|
||
recordKey,
|
||
collectionName,
|
||
childRecordType,
|
||
statePath,
|
||
}) => {
|
||
const error = errorHandler(setState)
|
||
try {
|
||
if (!recordKey) {
|
||
error("getNewChild > recordKey not set")
|
||
return
|
||
}
|
||
|
||
if (!collectionName) {
|
||
error("getNewChild > collectionName not set")
|
||
return
|
||
}
|
||
|
||
if (!childRecordType) {
|
||
error("getNewChild > childRecordType not set")
|
||
return
|
||
}
|
||
|
||
if (!statePath) {
|
||
error("getNewChild > statePath not set")
|
||
return
|
||
}
|
||
|
||
const rec = coreApi.recordApi.getNewChild(
|
||
recordKey,
|
||
collectionName,
|
||
childRecordType
|
||
)
|
||
setState(store, statePath, rec)
|
||
} catch (e) {
|
||
error(e.message)
|
||
}
|
||
}
|
||
|
||
const getNewRecordToState = (store, coreApi, setState) => ({
|
||
collectionKey,
|
||
childRecordType,
|
||
statePath,
|
||
}) => {
|
||
const error = errorHandler(setState)
|
||
try {
|
||
if (!collectionKey) {
|
||
error("getNewChild > collectionKey not set")
|
||
return
|
||
}
|
||
|
||
if (!childRecordType) {
|
||
error("getNewChild > childRecordType not set")
|
||
return
|
||
}
|
||
|
||
if (!statePath) {
|
||
error("getNewChild > statePath not set")
|
||
return
|
||
}
|
||
|
||
const rec = coreApi.recordApi.getNew(collectionKey, childRecordType)
|
||
setState(store, statePath, rec)
|
||
} catch (e) {
|
||
error(e.message)
|
||
}
|
||
}
|
||
|
||
const errorHandler = setState => message => setState(ERROR, message)
|
||
|
||
const EVENT_TYPE_MEMBER_NAME = "##eventHandlerType"
|
||
|
||
const eventHandlers = (store, coreApi, rootPath) => {
|
||
const handler = (parameters, execute) => ({
|
||
execute,
|
||
parameters,
|
||
})
|
||
|
||
const setStateWithStore = (path, value) => setState(store, path, value)
|
||
|
||
const api = createApi({
|
||
rootPath: rootPath,
|
||
setState: (path, value) => setStateWithStore,
|
||
getState: (path, fallback) => getState(store, path, fallback),
|
||
})
|
||
|
||
const setStateHandler = ({ path, value }) => setState(store, path, value)
|
||
|
||
return {
|
||
"Set State": handler(["path", "value"], setStateHandler),
|
||
"Load Record": handler(["recordKey", "statePath"], api.loadRecord),
|
||
"List Records": handler(["indexKey", "statePath"], api.listRecords),
|
||
"Save Record": handler(["statePath"], api.saveRecord),
|
||
|
||
"Get New Child Record": handler(
|
||
["recordKey", "collectionName", "childRecordType", "statePath"],
|
||
getNewChildRecordToState(store, coreApi, setStateWithStore)
|
||
),
|
||
|
||
"Get New Record": handler(
|
||
["collectionKey", "childRecordType", "statePath"],
|
||
getNewRecordToState(store, coreApi, setStateWithStore)
|
||
),
|
||
|
||
Authenticate: handler(["username", "password"], api.authenticate),
|
||
}
|
||
}
|
||
|
||
const isEventType = prop =>
|
||
fp_10(prop) && prop.length > 0 && !fp_2(prop[0][EVENT_TYPE_MEMBER_NAME])
|
||
|
||
const doNothing = () => {}
|
||
doNothing.isPlaceholder = true
|
||
|
||
const setupBinding = (store, rootProps, coreApi, context, rootPath) => {
|
||
const rootInitialProps = { ...rootProps }
|
||
|
||
const getBindings = (props, initialProps) => {
|
||
const boundProps = []
|
||
const componentEventHandlers = []
|
||
const boundArrays = []
|
||
|
||
for (let propName in props) {
|
||
if (propName === "_component") continue
|
||
|
||
const val = initialProps[propName]
|
||
|
||
if (isBound(val) && takeStateFromStore(val)) {
|
||
const binding = stateBinding(val)
|
||
const fallback = stateFallback(val)
|
||
|
||
boundProps.push({
|
||
stateBinding: binding,
|
||
fallback,
|
||
propName,
|
||
})
|
||
|
||
initialProps[propName] = fallback
|
||
} else if (isBound(val) && takeStateFromContext(val)) {
|
||
const binding = stateBinding(val)
|
||
const fallback = stateFallback(val)
|
||
|
||
initialProps[propName] = getState(context || {}, binding, fallback)
|
||
} else if (isEventType(val)) {
|
||
const handlers = { propName, handlers: [] }
|
||
componentEventHandlers.push(handlers)
|
||
|
||
for (let e of val) {
|
||
handlers.handlers.push({
|
||
handlerType: e[EVENT_TYPE_MEMBER_NAME],
|
||
parameters: e.parameters,
|
||
})
|
||
}
|
||
|
||
initialProps[propName] = doNothing
|
||
} else if (Array.isArray(val)) {
|
||
const arrayOfBindings = []
|
||
for (let element of val) {
|
||
arrayOfBindings.push(getBindings(element, { ...element }))
|
||
}
|
||
|
||
boundArrays.push({
|
||
arrayOfBindings,
|
||
propName,
|
||
})
|
||
}
|
||
}
|
||
|
||
return { boundProps, componentEventHandlers, boundArrays, initialProps }
|
||
}
|
||
|
||
const bind = rootBindings => component => {
|
||
if (
|
||
rootBindings.boundProps.length === 0 &&
|
||
rootBindings.componentEventHandlers.length === 0 &&
|
||
rootBindings.boundArrays.length === 0
|
||
)
|
||
return
|
||
|
||
const handlerTypes = eventHandlers(store, coreApi, rootPath)
|
||
|
||
const unsubscribe = store.subscribe(rootState => {
|
||
const getPropsFromBindings = (s, bindings) => {
|
||
const { boundProps, componentEventHandlers, boundArrays } = bindings
|
||
const newProps = { ...bindings.initialProps }
|
||
|
||
for (let boundProp of boundProps) {
|
||
const val = getState(s, boundProp.stateBinding, boundProp.fallback)
|
||
|
||
if (
|
||
val === undefined &&
|
||
newProps[boundProp.propName] !== undefined
|
||
) {
|
||
delete newProps[boundProp.propName]
|
||
}
|
||
|
||
if (val !== undefined) {
|
||
newProps[boundProp.propName] = val
|
||
}
|
||
}
|
||
|
||
for (let boundHandler of componentEventHandlers) {
|
||
const closuredHandlers = []
|
||
for (let h of boundHandler.handlers) {
|
||
const handlerType = handlerTypes[h.handlerType]
|
||
closuredHandlers.push(eventContext => {
|
||
const parameters = {}
|
||
for (let pname in h.parameters) {
|
||
const p = h.parameters[pname]
|
||
parameters[pname] = !isBound(p)
|
||
? p
|
||
: takeStateFromStore(p)
|
||
? getState(s, p[BB_STATE_BINDINGPATH], p[BB_STATE_FALLBACK])
|
||
: takeStateFromEventParameters(p)
|
||
? getState(
|
||
eventContext,
|
||
p[BB_STATE_BINDINGPATH],
|
||
p[BB_STATE_FALLBACK]
|
||
)
|
||
: takeStateFromContext(p)
|
||
? getState(
|
||
context,
|
||
p[BB_STATE_BINDINGPATH],
|
||
p[BB_STATE_FALLBACK]
|
||
)
|
||
: p[BB_STATE_FALLBACK]
|
||
}
|
||
handlerType.execute(parameters)
|
||
})
|
||
}
|
||
|
||
newProps[boundHandler.propName] = async context => {
|
||
for (let runHandler of closuredHandlers) {
|
||
await runHandler(context)
|
||
}
|
||
}
|
||
}
|
||
|
||
for (let boundArray of boundArrays) {
|
||
let index = 0
|
||
if (!newProps[boundArray.propName])
|
||
newProps[boundArray.propName] = []
|
||
for (let bindings of boundArray.arrayOfBindings) {
|
||
newProps[boundArray.propName][index] = getPropsFromBindings(
|
||
s,
|
||
bindings
|
||
)
|
||
index++
|
||
}
|
||
}
|
||
|
||
return newProps
|
||
}
|
||
|
||
const rootNewProps = getPropsFromBindings(rootState, rootBindings)
|
||
|
||
component.$set(rootNewProps)
|
||
})
|
||
|
||
return unsubscribe
|
||
}
|
||
|
||
const bindings = getBindings(rootProps, rootInitialProps)
|
||
|
||
return {
|
||
initialProps: rootInitialProps,
|
||
bind: bind(bindings),
|
||
}
|
||
}
|
||
|
||
const stateBinding = prop => prop[BB_STATE_BINDINGPATH]
|
||
const stateFallback = prop => prop[BB_STATE_FALLBACK]
|
||
|
||
const createCoreApp = (appDefinition, user) => {
|
||
const app = {
|
||
datastore: null,
|
||
crypto: null,
|
||
publish: () => {},
|
||
hierarchy: appDefinition.hierarchy,
|
||
actions: appDefinition.actions,
|
||
user,
|
||
}
|
||
|
||
return app
|
||
}
|
||
|
||
const makerule = (field, error, isValid) => ({ field, error, isValid })
|
||
|
||
var filters = new Map()
|
||
var limiters = new Map()
|
||
|
||
function compileRawExpression(src) {
|
||
return new Function(
|
||
"context",
|
||
"tempVars", // eslint-disable-line
|
||
"const sandbox = $nxCompileToSandbox(context, tempVars)\n try { with (sandbox) { return " +
|
||
src +
|
||
" } } catch (err) {\n if (!(err instanceof TypeError)) throw err\n }\n $nxClearSandbox()"
|
||
)
|
||
}
|
||
|
||
function compileRawCode(src) {
|
||
return new Function(
|
||
"context",
|
||
"tempVars", // eslint-disable-line
|
||
"const sandbox = $nxCompileToSandbox(context, tempVars)\n with (sandbox) { " +
|
||
src +
|
||
" }\n $nxClearSandbox()"
|
||
)
|
||
}
|
||
|
||
var filterRegex = /(?:[^\|]|\|\|)+/g
|
||
var limiterRegex = /(?:[^&]|&&)+/g
|
||
var argsRegex = /\S+/g
|
||
|
||
function parseExpression(src) {
|
||
var tokens = src.match(filterRegex)
|
||
if (tokens.length === 1) {
|
||
return compileRawExpression(tokens[0])
|
||
}
|
||
|
||
var expression = {
|
||
exec: compileRawExpression(tokens[0]),
|
||
filters: [],
|
||
}
|
||
for (var i = 1; i < tokens.length; i++) {
|
||
var filterTokens = tokens[i].match(argsRegex)
|
||
var filterName = filterTokens.shift()
|
||
var effect = filters.get(filterName)
|
||
if (!effect) {
|
||
throw new Error("There is no filter named: " + filterName + ".")
|
||
}
|
||
expression.filters.push({
|
||
effect: effect,
|
||
argExpressions: filterTokens.map(compileRawExpression),
|
||
})
|
||
}
|
||
return expression
|
||
}
|
||
|
||
function parseCode(src) {
|
||
var tokens = src.match(limiterRegex)
|
||
if (tokens.length === 1) {
|
||
return compileRawCode(tokens[0])
|
||
}
|
||
|
||
var code = {
|
||
exec: compileRawCode(tokens[0]),
|
||
limiters: [],
|
||
}
|
||
for (var i = 1; i < tokens.length; i++) {
|
||
var limiterTokens = tokens[i].match(argsRegex)
|
||
var limiterName = limiterTokens.shift()
|
||
var effect = limiters.get(limiterName)
|
||
if (!effect) {
|
||
throw new Error("There is no limiter named: " + limiterName + ".")
|
||
}
|
||
code.limiters.push({
|
||
effect: effect,
|
||
argExpressions: limiterTokens.map(compileRawExpression),
|
||
})
|
||
}
|
||
return code
|
||
}
|
||
|
||
var expressionCache = new Map()
|
||
var codeCache = new Map()
|
||
|
||
function compileExpression(src) {
|
||
if (typeof src !== "string") {
|
||
throw new TypeError("First argument must be a string.")
|
||
}
|
||
var expression = expressionCache.get(src)
|
||
if (!expression) {
|
||
expression = parseExpression(src)
|
||
expressionCache.set(src, expression)
|
||
}
|
||
|
||
if (typeof expression === "function") {
|
||
return expression
|
||
}
|
||
|
||
return function evaluateExpression(context, tempVars) {
|
||
var value = expression.exec(context, tempVars)
|
||
for (var i = 0, list = expression.filters; i < list.length; i += 1) {
|
||
var filter = list[i]
|
||
|
||
var args = filter.argExpressions.map(evaluateArgExpression, context)
|
||
value = filter.effect.apply(filter, [value].concat(args))
|
||
}
|
||
return value
|
||
}
|
||
}
|
||
|
||
function compileCode(src) {
|
||
if (typeof src !== "string") {
|
||
throw new TypeError("First argument must be a string.")
|
||
}
|
||
var code = codeCache.get(src)
|
||
if (!code) {
|
||
code = parseCode(src)
|
||
codeCache.set(src, code)
|
||
}
|
||
|
||
if (typeof code === "function") {
|
||
return code
|
||
}
|
||
|
||
var context = {}
|
||
return function evaluateCode(state, tempVars) {
|
||
var i = 0
|
||
function next() {
|
||
Object.assign(context, tempVars)
|
||
if (i < code.limiters.length) {
|
||
var limiter = code.limiters[i++]
|
||
var args = limiter.argExpressions.map(evaluateArgExpression, state)
|
||
limiter.effect.apply(limiter, [next, context].concat(args))
|
||
} else {
|
||
code.exec(state, tempVars)
|
||
}
|
||
}
|
||
next()
|
||
}
|
||
}
|
||
|
||
function evaluateArgExpression(argExpression) {
|
||
return argExpression(this)
|
||
}
|
||
|
||
var hasHandler = { has: has }
|
||
var allHandlers = { has: has, get: get$1 }
|
||
var globals$1 = new Set()
|
||
var temp
|
||
|
||
var globalObj
|
||
if (typeof window !== "undefined") {
|
||
globalObj = window
|
||
} // eslint-disable-line
|
||
else if (typeof global !== "undefined") {
|
||
globalObj = global
|
||
} // eslint-disable-line
|
||
else if (typeof self !== "undefined") {
|
||
globalObj = self
|
||
} // eslint-disable-line
|
||
globalObj.$nxCompileToSandbox = toSandbox
|
||
globalObj.$nxClearSandbox = clearSandbox
|
||
|
||
function has(target, key) {
|
||
return globals$1.has(key) ? key in target : true
|
||
}
|
||
|
||
function get$1(target, key) {
|
||
return key in temp ? temp[key] : target[key]
|
||
}
|
||
|
||
function toSandbox(obj, tempVars) {
|
||
if (tempVars) {
|
||
temp = tempVars
|
||
return new Proxy(obj, allHandlers)
|
||
}
|
||
return new Proxy(obj, hasHandler)
|
||
}
|
||
|
||
function clearSandbox() {
|
||
temp = undefined
|
||
}
|
||
|
||
const compileFilter = index => compileExpression(index.filter)
|
||
|
||
const compileMap = index => compileCode(index.map)
|
||
|
||
const indexTypes = { reference: "reference", ancestor: "ancestor" }
|
||
|
||
const indexRuleSet = [
|
||
makerule("map", "index has no map function", index =>
|
||
isNonEmptyString(index.map)
|
||
),
|
||
makerule(
|
||
"map",
|
||
"index's map function does not compile",
|
||
index =>
|
||
!isNonEmptyString(index.map) ||
|
||
executesWithoutException(() => compileMap(index))
|
||
),
|
||
makerule(
|
||
"filter",
|
||
"index's filter function does not compile",
|
||
index =>
|
||
!isNonEmptyString(index.filter) ||
|
||
executesWithoutException(() => compileFilter(index))
|
||
),
|
||
makerule("name", "must declare a name for index", index =>
|
||
isNonEmptyString(index.name)
|
||
),
|
||
makerule(
|
||
"name",
|
||
"there is a duplicate named index on this node",
|
||
index =>
|
||
fp_15(index.name) ||
|
||
fp_16("name")(index.parent().indexes)[index.name] === 1
|
||
),
|
||
makerule(
|
||
"indexType",
|
||
"reference index may only exist on a record node",
|
||
index =>
|
||
isRecord(index.parent()) || index.indexType !== indexTypes.reference
|
||
),
|
||
makerule(
|
||
"indexType",
|
||
`index type must be one of: ${fp_17(", ")(fp_13(indexTypes))}`,
|
||
index => fp_18(index.indexType)(fp_13(indexTypes))
|
||
),
|
||
]
|
||
|
||
const getFlattenedHierarchy = (appHierarchy, useCached = true) => {
|
||
if (isSomething(appHierarchy.getFlattenedHierarchy) && useCached) {
|
||
return appHierarchy.getFlattenedHierarchy()
|
||
}
|
||
|
||
const flattenHierarchy = (currentNode, flattened) => {
|
||
flattened.push(currentNode)
|
||
if (
|
||
(!currentNode.children || currentNode.children.length === 0) &&
|
||
(!currentNode.indexes || currentNode.indexes.length === 0) &&
|
||
(!currentNode.aggregateGroups ||
|
||
currentNode.aggregateGroups.length === 0)
|
||
) {
|
||
return flattened
|
||
}
|
||
|
||
const unionIfAny = l2 => l1 => fp_5(l1)(!l2 ? [] : l2)
|
||
|
||
const children = $(
|
||
[],
|
||
[
|
||
unionIfAny(currentNode.children),
|
||
unionIfAny(currentNode.indexes),
|
||
unionIfAny(currentNode.aggregateGroups),
|
||
]
|
||
)
|
||
|
||
for (const child of children) {
|
||
flattenHierarchy(child, flattened)
|
||
}
|
||
return flattened
|
||
}
|
||
|
||
appHierarchy.getFlattenedHierarchy = () =>
|
||
flattenHierarchy(appHierarchy, [])
|
||
return appHierarchy.getFlattenedHierarchy()
|
||
}
|
||
|
||
const getExactNodeForPath = appHierarchy => key =>
|
||
$(appHierarchy, [
|
||
getFlattenedHierarchy,
|
||
fp_1(n => new RegExp(`${n.pathRegx()}$`).test(key)),
|
||
])
|
||
|
||
const getNodeForCollectionPath = appHierarchy => collectionKey =>
|
||
$(appHierarchy, [
|
||
getFlattenedHierarchy,
|
||
fp_1(
|
||
n =>
|
||
isCollectionRecord(n) &&
|
||
new RegExp(`${n.collectionPathRegx()}$`).test(collectionKey)
|
||
),
|
||
])
|
||
|
||
const getNode = (appHierarchy, nodeKey) =>
|
||
$(appHierarchy, [
|
||
getFlattenedHierarchy,
|
||
fp_1(
|
||
n =>
|
||
n.nodeKey() === nodeKey ||
|
||
(isCollectionRecord(n) && n.collectionNodeKey() === nodeKey)
|
||
),
|
||
])
|
||
|
||
const getNodeByKeyOrNodeKey = (appHierarchy, keyOrNodeKey) => {
|
||
const nodeByKey = getExactNodeForPath(appHierarchy)(keyOrNodeKey)
|
||
return isNothing(nodeByKey)
|
||
? getNode(appHierarchy, keyOrNodeKey)
|
||
: nodeByKey
|
||
}
|
||
|
||
const isNode = (appHierarchy, key) =>
|
||
isSomething(getExactNodeForPath(appHierarchy)(key))
|
||
|
||
const isRecord = node => isSomething(node) && node.type === "record"
|
||
const isCollectionRecord = node => isRecord(node) && !node.isSingle
|
||
|
||
const getSafeFieldParser = (tryParse, defaultValueFunctions) => (
|
||
field,
|
||
record
|
||
) => {
|
||
if (fp_24(field.name)(record)) {
|
||
return getSafeValueParser(
|
||
tryParse,
|
||
defaultValueFunctions
|
||
)(record[field.name])
|
||
}
|
||
return defaultValueFunctions[field.getUndefinedValue]()
|
||
}
|
||
|
||
const getSafeValueParser = (tryParse, defaultValueFunctions) => value => {
|
||
const parsed = tryParse(value)
|
||
if (parsed.success) {
|
||
return parsed.value
|
||
}
|
||
return defaultValueFunctions.default()
|
||
}
|
||
|
||
const getNewValue = (tryParse, defaultValueFunctions) => field => {
|
||
const getInitialValue =
|
||
fp_2(field) || fp_2(field.getInitialValue)
|
||
? "default"
|
||
: field.getInitialValue
|
||
|
||
return fp_24(getInitialValue)(defaultValueFunctions)
|
||
? defaultValueFunctions[getInitialValue]()
|
||
: getSafeValueParser(tryParse, defaultValueFunctions)(getInitialValue)
|
||
}
|
||
|
||
const typeFunctions = specificFunctions =>
|
||
lodash_11(
|
||
{
|
||
value: fp_20,
|
||
null: fp_20(null),
|
||
},
|
||
specificFunctions
|
||
)
|
||
|
||
const validateTypeConstraints = validationRules => async (
|
||
field,
|
||
record,
|
||
context
|
||
) => {
|
||
const fieldValue = record[field.name]
|
||
const validateRule = async r =>
|
||
!(await r.isValid(fieldValue, field.typeOptions, context))
|
||
? r.getMessage(fieldValue, field.typeOptions)
|
||
: ""
|
||
|
||
const errors = []
|
||
for (const r of validationRules) {
|
||
const err = await validateRule(r)
|
||
if (isNotEmpty(err)) errors.push(err)
|
||
}
|
||
|
||
return errors
|
||
}
|
||
|
||
const getDefaultOptions = fp_25(v => v.defaultValue)
|
||
|
||
const makerule$1 = (isValid, getMessage) => ({ isValid, getMessage })
|
||
const parsedFailed = val => ({ success: false, value: val })
|
||
const parsedSuccess = val => ({ success: true, value: val })
|
||
const getDefaultExport = (
|
||
name,
|
||
tryParse,
|
||
functions,
|
||
options,
|
||
validationRules,
|
||
sampleValue,
|
||
stringify
|
||
) => ({
|
||
getNew: getNewValue(tryParse, functions),
|
||
safeParseField: getSafeFieldParser(tryParse, functions),
|
||
safeParseValue: getSafeValueParser(tryParse, functions),
|
||
tryParse,
|
||
name,
|
||
getDefaultOptions: () => getDefaultOptions(fp_8(options)),
|
||
optionDefinitions: options,
|
||
validateTypeConstraints: validateTypeConstraints(validationRules),
|
||
sampleValue,
|
||
stringify: val => (val === null || val === undefined ? "" : stringify(val)),
|
||
getDefaultValue: functions.default,
|
||
})
|
||
|
||
const stringFunctions = typeFunctions({
|
||
default: fp_20(null),
|
||
})
|
||
|
||
const stringTryParse = switchCase(
|
||
[fp_26, parsedSuccess],
|
||
[fp_28, parsedSuccess],
|
||
[defaultCase, v => parsedSuccess(v.toString())]
|
||
)
|
||
|
||
const options = {
|
||
maxLength: {
|
||
defaultValue: null,
|
||
isValid: n => n === null || (isSafeInteger(n) && n > 0),
|
||
requirementDescription:
|
||
"max length must be null (no limit) or a greater than zero integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
values: {
|
||
defaultValue: null,
|
||
isValid: v =>
|
||
v === null || (isArrayOfString(v) && v.length > 0 && v.length < 10000),
|
||
requirementDescription:
|
||
"'values' must be null (no values) or an arry of at least one string",
|
||
parse: s => s,
|
||
},
|
||
allowDeclaredValuesOnly: {
|
||
defaultValue: false,
|
||
isValid: fp_27,
|
||
requirementDescription: "allowDeclaredValuesOnly must be true or false",
|
||
parse: toBoolOrNull,
|
||
},
|
||
}
|
||
|
||
const typeConstraints = [
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.maxLength === null || val.length <= opts.maxLength,
|
||
(val, opts) => `value exceeds maximum length of ${opts.maxLength}`
|
||
),
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null ||
|
||
opts.allowDeclaredValuesOnly === false ||
|
||
fp_18(val)(opts.values),
|
||
val => `"${val}" does not exist in the list of allowed values`
|
||
),
|
||
]
|
||
|
||
var string = getDefaultExport(
|
||
"string",
|
||
stringTryParse,
|
||
stringFunctions,
|
||
options,
|
||
typeConstraints,
|
||
"abcde",
|
||
str => str
|
||
)
|
||
|
||
const boolFunctions = typeFunctions({
|
||
default: fp_20(null),
|
||
})
|
||
|
||
const boolTryParse = switchCase(
|
||
[fp_27, parsedSuccess],
|
||
[fp_28, parsedSuccess],
|
||
[isOneOf("true", "1", "yes", "on"), () => parsedSuccess(true)],
|
||
[isOneOf("false", "0", "no", "off"), () => parsedSuccess(false)],
|
||
[defaultCase, parsedFailed]
|
||
)
|
||
|
||
const options$1 = {
|
||
allowNulls: {
|
||
defaultValue: true,
|
||
isValid: fp_27,
|
||
requirementDescription: "must be a true or false",
|
||
parse: toBoolOrNull,
|
||
},
|
||
}
|
||
|
||
const typeConstraints$1 = [
|
||
makerule$1(
|
||
async (val, opts) => opts.allowNulls === true || val !== null,
|
||
() => "field cannot be null"
|
||
),
|
||
]
|
||
|
||
var bool = getDefaultExport(
|
||
"bool",
|
||
boolTryParse,
|
||
boolFunctions,
|
||
options$1,
|
||
typeConstraints$1,
|
||
true,
|
||
JSON.stringify
|
||
)
|
||
|
||
const numberFunctions = typeFunctions({
|
||
default: fp_20(null),
|
||
})
|
||
|
||
const parseStringtoNumberOrNull = s => {
|
||
const num = Number(s)
|
||
return isNaN(num) ? parsedFailed(s) : parsedSuccess(num)
|
||
}
|
||
|
||
const numberTryParse = switchCase(
|
||
[fp_29, parsedSuccess],
|
||
[fp_26, parseStringtoNumberOrNull],
|
||
[fp_28, parsedSuccess],
|
||
[defaultCase, parsedFailed]
|
||
)
|
||
|
||
const options$2 = {
|
||
maxValue: {
|
||
defaultValue: Number.MAX_SAFE_INTEGER,
|
||
isValid: isSafeInteger,
|
||
requirementDescription: "must be a valid integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
minValue: {
|
||
defaultValue: 0 - Number.MAX_SAFE_INTEGER,
|
||
isValid: isSafeInteger,
|
||
requirementDescription: "must be a valid integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
decimalPlaces: {
|
||
defaultValue: 0,
|
||
isValid: n => isSafeInteger(n) && n >= 0,
|
||
requirementDescription: "must be a positive integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
}
|
||
|
||
const getDecimalPlaces = val => {
|
||
const splitDecimal = val.toString().split(".")
|
||
if (splitDecimal.length === 1) return 0
|
||
return splitDecimal[1].length
|
||
}
|
||
|
||
const typeConstraints$2 = [
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.minValue === null || val >= opts.minValue,
|
||
(val, opts) =>
|
||
`value (${val.toString()}) must be greater than or equal to ${
|
||
opts.minValue
|
||
}`
|
||
),
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.maxValue === null || val <= opts.maxValue,
|
||
(val, opts) =>
|
||
`value (${val.toString()}) must be less than or equal to ${
|
||
opts.minValue
|
||
} options`
|
||
),
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.decimalPlaces >= getDecimalPlaces(val),
|
||
(val, opts) =>
|
||
`value (${val.toString()}) must have ${
|
||
opts.decimalPlaces
|
||
} decimal places or less`
|
||
),
|
||
]
|
||
|
||
var number = getDefaultExport(
|
||
"number",
|
||
numberTryParse,
|
||
numberFunctions,
|
||
options$2,
|
||
typeConstraints$2,
|
||
1,
|
||
num => num.toString()
|
||
)
|
||
|
||
const dateFunctions = typeFunctions({
|
||
default: fp_20(null),
|
||
now: () => new Date(),
|
||
})
|
||
|
||
const isValidDate = d => d instanceof Date && !isNaN(d)
|
||
|
||
const parseStringToDate = s =>
|
||
switchCase(
|
||
[isValidDate, parsedSuccess],
|
||
[defaultCase, parsedFailed]
|
||
)(new Date(s))
|
||
|
||
const dateTryParse = switchCase(
|
||
[fp_31, parsedSuccess],
|
||
[fp_26, parseStringToDate],
|
||
[fp_28, parsedSuccess],
|
||
[defaultCase, parsedFailed]
|
||
)
|
||
|
||
const options$3 = {
|
||
maxValue: {
|
||
defaultValue: new Date(32503680000000),
|
||
isValid: fp_31,
|
||
requirementDescription: "must be a valid date",
|
||
parse: toDateOrNull,
|
||
},
|
||
minValue: {
|
||
defaultValue: new Date(-8520336000000),
|
||
isValid: fp_31,
|
||
requirementDescription: "must be a valid date",
|
||
parse: toDateOrNull,
|
||
},
|
||
}
|
||
|
||
const typeConstraints$3 = [
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.minValue === null || val >= opts.minValue,
|
||
(val, opts) =>
|
||
`value (${val.toString()}) must be greater than or equal to ${
|
||
opts.minValue
|
||
}`
|
||
),
|
||
makerule$1(
|
||
async (val, opts) =>
|
||
val === null || opts.maxValue === null || val <= opts.maxValue,
|
||
(val, opts) =>
|
||
`value (${val.toString()}) must be less than or equal to ${
|
||
opts.minValue
|
||
} options`
|
||
),
|
||
]
|
||
|
||
var datetime = getDefaultExport(
|
||
"datetime",
|
||
dateTryParse,
|
||
dateFunctions,
|
||
options$3,
|
||
typeConstraints$3,
|
||
new Date(1984, 4, 1),
|
||
date => JSON.stringify(date).replace(new RegExp('"', "g"), "")
|
||
)
|
||
|
||
const arrayFunctions = () =>
|
||
typeFunctions({
|
||
default: fp_20([]),
|
||
})
|
||
|
||
const mapToParsedArrary = type =>
|
||
$$(
|
||
fp_11(i => type.safeParseValue(i)),
|
||
parsedSuccess
|
||
)
|
||
|
||
const arrayTryParse = type =>
|
||
switchCase([fp_10, mapToParsedArrary(type)], [defaultCase, parsedFailed])
|
||
|
||
const typeName = type => `array<${type}>`
|
||
|
||
const options$4 = {
|
||
maxLength: {
|
||
defaultValue: 10000,
|
||
isValid: isSafeInteger,
|
||
requirementDescription: "must be a positive integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
minLength: {
|
||
defaultValue: 0,
|
||
isValid: n => isSafeInteger(n) && n >= 0,
|
||
requirementDescription: "must be a positive integer",
|
||
parse: toNumberOrNull,
|
||
},
|
||
}
|
||
|
||
const typeConstraints$4 = [
|
||
makerule$1(
|
||
async (val, opts) => val === null || val.length >= opts.minLength,
|
||
(val, opts) => `must choose ${opts.minLength} or more options`
|
||
),
|
||
makerule$1(
|
||
async (val, opts) => val === null || val.length <= opts.maxLength,
|
||
(val, opts) => `cannot choose more than ${opts.maxLength} options`
|
||
),
|
||
]
|
||
|
||
var array = type =>
|
||
getDefaultExport(
|
||
typeName(type.name),
|
||
arrayTryParse(type),
|
||
arrayFunctions(),
|
||
options$4,
|
||
typeConstraints$4,
|
||
[type.sampleValue],
|
||
JSON.stringify
|
||
)
|
||
|
||
const referenceNothing = () => ({ key: "" })
|
||
|
||
const referenceFunctions = typeFunctions({
|
||
default: referenceNothing,
|
||
})
|
||
|
||
const hasStringValue = (ob, path) => fp_24(path)(ob) && fp_26(ob[path])
|
||
|
||
const isObjectWithKey = v => fp_30(v) && hasStringValue(v, "key")
|
||
|
||
const tryParseFromString = s => {
|
||
try {
|
||
const asObj = JSON.parse(s)
|
||
if (isObjectWithKey) {
|
||
return parsedSuccess(asObj)
|
||
}
|
||
} catch (_) {
|
||
// EMPTY
|
||
}
|
||
|
||
return parsedFailed(s)
|
||
}
|
||
|
||
const referenceTryParse = v =>
|
||
switchCase(
|
||
[isObjectWithKey, parsedSuccess],
|
||
[fp_26, tryParseFromString],
|
||
[fp_28, () => parsedSuccess(referenceNothing())],
|
||
[defaultCase, parsedFailed]
|
||
)(v)
|
||
|
||
const options$5 = {
|
||
indexNodeKey: {
|
||
defaultValue: null,
|
||
isValid: isNonEmptyString,
|
||
requirementDescription: "must be a non-empty string",
|
||
parse: s => s,
|
||
},
|
||
displayValue: {
|
||
defaultValue: "",
|
||
isValid: isNonEmptyString,
|
||
requirementDescription: "must be a non-empty string",
|
||
parse: s => s,
|
||
},
|
||
reverseIndexNodeKeys: {
|
||
defaultValue: null,
|
||
isValid: v => isArrayOfString(v) && v.length > 0,
|
||
requirementDescription: "must be a non-empty array of strings",
|
||
parse: s => s,
|
||
},
|
||
}
|
||
|
||
const isEmptyString = s => fp_26(s) && fp_15(s)
|
||
|
||
const ensureReferenceExists = async (val, opts, context) =>
|
||
isEmptyString(val.key) || (await context.referenceExists(opts, val.key))
|
||
|
||
const typeConstraints$5 = [
|
||
makerule$1(
|
||
ensureReferenceExists,
|
||
(val, opts) =>
|
||
`"${val[opts.displayValue]}" does not exist in options list (key: ${
|
||
val.key
|
||
})`
|
||
),
|
||
]
|
||
|
||
var reference = getDefaultExport(
|
||
"reference",
|
||
referenceTryParse,
|
||
referenceFunctions,
|
||
options$5,
|
||
typeConstraints$5,
|
||
{ key: "key", value: "value" },
|
||
JSON.stringify
|
||
)
|
||
|
||
const illegalCharacters = "*?\\/:<>|\0\b\f\v"
|
||
|
||
const isLegalFilename = filePath => {
|
||
const fn = fileName(filePath)
|
||
return (
|
||
fn.length <= 255 &&
|
||
fp_22(fn.split(""))(illegalCharacters.split("")).length === 0 &&
|
||
none(f => f === "..")(splitKey(filePath))
|
||
)
|
||
}
|
||
|
||
const fileNothing = () => ({ relativePath: "", size: 0 })
|
||
|
||
const fileFunctions = typeFunctions({
|
||
default: fileNothing,
|
||
})
|
||
|
||
const fileTryParse = v =>
|
||
switchCase(
|
||
[isValidFile, parsedSuccess],
|
||
[fp_28, () => parsedSuccess(fileNothing())],
|
||
[defaultCase, parsedFailed]
|
||
)(v)
|
||
|
||
const fileName = filePath => $(filePath, [splitKey, fp_4])
|
||
|
||
const isValidFile = f =>
|
||
!fp_28(f) &&
|
||
fp_24("relativePath")(f) &&
|
||
fp_24("size")(f) &&
|
||
fp_29(f.size) &&
|
||
fp_26(f.relativePath) &&
|
||
isLegalFilename(f.relativePath)
|
||
|
||
const options$6 = {}
|
||
|
||
const typeConstraints$6 = []
|
||
|
||
var file$a = getDefaultExport(
|
||
"file",
|
||
fileTryParse,
|
||
fileFunctions,
|
||
options$6,
|
||
typeConstraints$6,
|
||
{ relativePath: "some_file.jpg", size: 1000 },
|
||
JSON.stringify
|
||
)
|
||
|
||
const allTypes = () => {
|
||
const basicTypes = {
|
||
string,
|
||
number,
|
||
datetime,
|
||
bool,
|
||
reference,
|
||
file: file$a,
|
||
}
|
||
|
||
const arrays = $(basicTypes, [
|
||
fp_13,
|
||
fp_11(k => {
|
||
const kvType = {}
|
||
const concreteArray = array(basicTypes[k])
|
||
kvType[concreteArray.name] = concreteArray
|
||
return kvType
|
||
}),
|
||
types => lodash_12({}, ...types),
|
||
])
|
||
|
||
return lodash_11({}, basicTypes, arrays)
|
||
}
|
||
|
||
const all$1 = allTypes()
|
||
|
||
const getType = typeName => {
|
||
if (!fp_24(typeName)(all$1))
|
||
throw new BadRequestError(`Do not recognise type ${typeName}`)
|
||
return all$1[typeName]
|
||
}
|
||
|
||
const getNewFieldValue = field => getType(field.type).getNew(field)
|
||
|
||
const AUTH_FOLDER = "/.auth"
|
||
const USERS_LIST_FILE = joinKey(AUTH_FOLDER, "users.json")
|
||
const USERS_LOCK_FILE = joinKey(AUTH_FOLDER, "users_lock")
|
||
const ACCESS_LEVELS_FILE = joinKey(AUTH_FOLDER, "access_levels.json")
|
||
const ACCESS_LEVELS_LOCK_FILE = joinKey(AUTH_FOLDER, "access_levels_lock")
|
||
|
||
const permissionTypes = {
|
||
CREATE_RECORD: "create record",
|
||
UPDATE_RECORD: "update record",
|
||
READ_RECORD: "read record",
|
||
DELETE_RECORD: "delete record",
|
||
READ_INDEX: "read index",
|
||
MANAGE_INDEX: "manage index",
|
||
MANAGE_COLLECTION: "manage collection",
|
||
WRITE_TEMPLATES: "write templates",
|
||
CREATE_USER: "create user",
|
||
SET_PASSWORD: "set password",
|
||
CREATE_TEMPORARY_ACCESS: "create temporary access",
|
||
ENABLE_DISABLE_USER: "enable or disable user",
|
||
WRITE_ACCESS_LEVELS: "write access levels",
|
||
LIST_USERS: "list users",
|
||
LIST_ACCESS_LEVELS: "list access levels",
|
||
EXECUTE_ACTION: "execute action",
|
||
SET_USER_ACCESS_LEVELS: "set user access levels",
|
||
}
|
||
|
||
const isAuthorized = app => (permissionType, resourceKey) =>
|
||
apiWrapperSync(
|
||
app,
|
||
events.authApi.isAuthorized,
|
||
alwaysAuthorized,
|
||
{ resourceKey, permissionType },
|
||
_isAuthorized,
|
||
app,
|
||
permissionType,
|
||
resourceKey
|
||
)
|
||
|
||
const _isAuthorized = (app, permissionType, resourceKey) => {
|
||
if (!app.user) {
|
||
return false
|
||
}
|
||
|
||
const validType = $(permissionTypes, [fp_33, fp_18(permissionType)])
|
||
|
||
if (!validType) {
|
||
return false
|
||
}
|
||
|
||
const permMatchesResource = userperm => {
|
||
const nodeKey = isNothing(resourceKey)
|
||
? null
|
||
: isNode(app.hierarchy, resourceKey)
|
||
? getNodeByKeyOrNodeKey(app.hierarchy, resourceKey).nodeKey()
|
||
: resourceKey
|
||
|
||
return (
|
||
userperm.type === permissionType &&
|
||
(isNothing(resourceKey) || nodeKey === userperm.nodeKey)
|
||
)
|
||
}
|
||
|
||
return $(app.user.permissions, [fp_9(permMatchesResource)])
|
||
}
|
||
|
||
const nodePermission = type => ({
|
||
add: (nodeKey, accessLevel) =>
|
||
accessLevel.permissions.push({ type, nodeKey }),
|
||
isAuthorized: resourceKey => app => isAuthorized(app)(type, resourceKey),
|
||
isNode: true,
|
||
get: nodeKey => ({ type, nodeKey }),
|
||
})
|
||
|
||
const staticPermission = type => ({
|
||
add: accessLevel => accessLevel.permissions.push({ type }),
|
||
isAuthorized: app => isAuthorized(app)(type),
|
||
isNode: false,
|
||
get: () => ({ type }),
|
||
})
|
||
|
||
const createRecord = nodePermission(permissionTypes.CREATE_RECORD)
|
||
|
||
const updateRecord = nodePermission(permissionTypes.UPDATE_RECORD)
|
||
|
||
const deleteRecord = nodePermission(permissionTypes.DELETE_RECORD)
|
||
|
||
const readRecord = nodePermission(permissionTypes.READ_RECORD)
|
||
|
||
const writeTemplates = staticPermission(permissionTypes.WRITE_TEMPLATES)
|
||
|
||
const createUser = staticPermission(permissionTypes.CREATE_USER)
|
||
|
||
const setPassword = staticPermission(permissionTypes.SET_PASSWORD)
|
||
|
||
const readIndex = nodePermission(permissionTypes.READ_INDEX)
|
||
|
||
const manageIndex = staticPermission(permissionTypes.MANAGE_INDEX)
|
||
|
||
const manageCollection = staticPermission(permissionTypes.MANAGE_COLLECTION)
|
||
|
||
const createTemporaryAccess = staticPermission(
|
||
permissionTypes.CREATE_TEMPORARY_ACCESS
|
||
)
|
||
|
||
const enableDisableUser = staticPermission(
|
||
permissionTypes.ENABLE_DISABLE_USER
|
||
)
|
||
|
||
const writeAccessLevels = staticPermission(
|
||
permissionTypes.WRITE_ACCESS_LEVELS
|
||
)
|
||
|
||
const listUsers = staticPermission(permissionTypes.LIST_USERS)
|
||
|
||
const listAccessLevels = staticPermission(permissionTypes.LIST_ACCESS_LEVELS)
|
||
|
||
const setUserAccessLevels = staticPermission(
|
||
permissionTypes.SET_USER_ACCESS_LEVELS
|
||
)
|
||
|
||
const executeAction = nodePermission(permissionTypes.EXECUTE_ACTION)
|
||
|
||
const alwaysAuthorized = () => true
|
||
|
||
const permission = {
|
||
createRecord,
|
||
updateRecord,
|
||
deleteRecord,
|
||
readRecord,
|
||
writeTemplates,
|
||
createUser,
|
||
setPassword,
|
||
readIndex,
|
||
createTemporaryAccess,
|
||
enableDisableUser,
|
||
writeAccessLevels,
|
||
listUsers,
|
||
listAccessLevels,
|
||
manageIndex,
|
||
manageCollection,
|
||
executeAction,
|
||
setUserAccessLevels,
|
||
}
|
||
|
||
const getNew = app => (collectionKey, recordTypeName) => {
|
||
const recordNode = getRecordNode(app, collectionKey)
|
||
collectionKey = safeKey(collectionKey)
|
||
return apiWrapperSync(
|
||
app,
|
||
events.recordApi.getNew,
|
||
permission.createRecord.isAuthorized(recordNode.nodeKey()),
|
||
{ collectionKey, recordTypeName },
|
||
_getNew,
|
||
recordNode,
|
||
collectionKey
|
||
)
|
||
}
|
||
|
||
const _getNew = (recordNode, collectionKey) =>
|
||
constructRecord(recordNode, getNewFieldValue, collectionKey)
|
||
|
||
const getRecordNode = (app, collectionKey) => {
|
||
collectionKey = safeKey(collectionKey)
|
||
return getNodeForCollectionPath(app.hierarchy)(collectionKey)
|
||
}
|
||
|
||
const getNewChild = app => (recordKey, collectionName, recordTypeName) =>
|
||
getNew(app)(joinKey(recordKey, collectionName), recordTypeName)
|
||
|
||
const constructRecord = (recordNode, getFieldValue, collectionKey) => {
|
||
const record = $(recordNode.fields, [fp_34("name"), fp_25(getFieldValue)])
|
||
|
||
record.id = `${recordNode.nodeId}-${shortid_1()}`
|
||
record.key = joinKey(collectionKey, record.id)
|
||
record.isNew = true
|
||
record.type = recordNode.name
|
||
return record
|
||
}
|
||
|
||
const createCoreApi = (appDefinition, user) => {
|
||
const app = createCoreApp(appDefinition, user)
|
||
|
||
return {
|
||
recordApi: {
|
||
getNew: getNew(app),
|
||
getNewChild: getNewChild(app),
|
||
},
|
||
}
|
||
}
|
||
|
||
const createApp = (componentLibraries, appDefinition, user) => {
|
||
const initialiseComponent = parentContext => (
|
||
props,
|
||
htmlElement,
|
||
context
|
||
) => {
|
||
const { componentName, libName } = splitName(props._component)
|
||
|
||
if (!componentName || !libName) return
|
||
|
||
const { initialProps, bind } = setupBinding(
|
||
store,
|
||
props,
|
||
coreApi,
|
||
context,
|
||
appDefinition.appRootPath
|
||
)
|
||
|
||
const component = new componentLibraries[libName][componentName]({
|
||
target: htmlElement,
|
||
props: { ...initialProps, _bb: bbInContext(context || parentContext) },
|
||
hydrate: true,
|
||
})
|
||
|
||
bind(component)
|
||
|
||
return component
|
||
}
|
||
|
||
const coreApi = createCoreApi(appDefinition, user)
|
||
const store = writable({
|
||
_bbuser: user,
|
||
})
|
||
|
||
let globalState = null
|
||
store.subscribe(s => {
|
||
globalState = s
|
||
})
|
||
|
||
const relativeUrl = url =>
|
||
appDefinition.appRootPath
|
||
? appDefinition.appRootPath + "/" + trimSlash(url)
|
||
: url
|
||
|
||
const apiCall = method => (url, body) =>
|
||
fetch(relativeUrl(url), {
|
||
method: method,
|
||
headers: {
|
||
"Content-Type": "application/json",
|
||
},
|
||
body: body && JSON.stringify(body),
|
||
})
|
||
|
||
const api = {
|
||
post: apiCall("POST"),
|
||
get: apiCall("GET"),
|
||
patch: apiCall("PATCH"),
|
||
delete: apiCall("DELETE"),
|
||
}
|
||
|
||
const bb = () => ({
|
||
initialiseComponent: initialiseComponent(),
|
||
store,
|
||
relativeUrl,
|
||
api,
|
||
getStateOrValue: (prop, currentContext) =>
|
||
getStateOrValue(globalState, prop, currentContext),
|
||
})
|
||
|
||
const bbRoot = bb()
|
||
|
||
const bbInContext = context => {
|
||
if (!context) return bbRoot
|
||
const bbCxt = bb()
|
||
bbCxt.context = context
|
||
bbCxt.initialiseComponent = initialiseComponent(context)
|
||
return bbCxt
|
||
}
|
||
|
||
return bbRoot
|
||
}
|
||
|
||
const splitName = fullname => {
|
||
const componentName = $(fullname, [fp_3("/"), fp_4])
|
||
|
||
const libName = fullname.substring(
|
||
0,
|
||
fullname.length - componentName.length - 1
|
||
)
|
||
|
||
return { libName, componentName }
|
||
}
|
||
|
||
var createApp$1 = async () => {
|
||
const componentLibraries = {
|
||
components: {
|
||
login: Login,
|
||
grid: Grid,
|
||
form: Form,
|
||
textbox: Textbox,
|
||
text: Text,
|
||
nav: Nav,
|
||
panel: Panel,
|
||
table: Table,
|
||
stackpanel: StackPanel,
|
||
button: Button,
|
||
},
|
||
}
|
||
|
||
const appDef = { hierarchy: {}, actions: {} }
|
||
const user = { name: "yeo", permissions: [] }
|
||
|
||
var app = createApp(componentLibraries, appDef, user)
|
||
app.store.update(s => {
|
||
s.people = [
|
||
{ name: "bob", address: "123 Main Street", status: "Open" },
|
||
{ name: "poppy", address: "456 Side Road", status: "Closed" },
|
||
{ name: "Oscar", address: "678 Dodgy Alley", status: "Open" },
|
||
]
|
||
return s
|
||
})
|
||
|
||
return app
|
||
}
|
||
|
||
const props = {
|
||
login: { _component: "components/login" },
|
||
|
||
form: {
|
||
_component: "components/form",
|
||
formControls: [
|
||
{
|
||
control: {
|
||
_component: "components/textbox",
|
||
},
|
||
label: "First Name",
|
||
},
|
||
{
|
||
control: {
|
||
_component: "components/textbox",
|
||
},
|
||
label: "Last Name",
|
||
},
|
||
],
|
||
},
|
||
|
||
nav: {
|
||
_component: "components/nav",
|
||
navBarBackground: "red",
|
||
navBarBorder: "1px solid maroon",
|
||
navBarColor: "black",
|
||
selectedItemBackground: "maroon",
|
||
selectedItemColor: "white",
|
||
selectedItemBorder: "green",
|
||
itemHoverBackground: "yellow",
|
||
itemHoverColor: "pink",
|
||
items: [
|
||
{
|
||
title: "People",
|
||
component: {
|
||
_component: "components/panel",
|
||
text: "People Panel",
|
||
padding: "40px",
|
||
border: "2px solid pink",
|
||
background: "mistyrose",
|
||
},
|
||
},
|
||
{
|
||
title: "Animals",
|
||
component: {
|
||
_component: "components/panel",
|
||
text: "Animals Panel",
|
||
padding: "40px",
|
||
border: "2px solid green",
|
||
background: "azure",
|
||
},
|
||
},
|
||
],
|
||
},
|
||
|
||
table: {
|
||
_component: "components/table",
|
||
columns: [
|
||
{
|
||
title: {
|
||
"##bbstate": "NameColumnName",
|
||
"##bbsource": "store",
|
||
"##bbstatefallback": "Name",
|
||
},
|
||
value: {
|
||
"##bbstate": "name",
|
||
"##bbsource": "context",
|
||
},
|
||
},
|
||
{
|
||
title: "Address",
|
||
value: {
|
||
"##bbstate": "address",
|
||
"##bbsource": "context",
|
||
},
|
||
},
|
||
{
|
||
title: "Status",
|
||
value: {
|
||
"##bbstate": "status",
|
||
"##bbsource": "context",
|
||
},
|
||
},
|
||
],
|
||
data: {
|
||
"##bbstate": "people",
|
||
},
|
||
onRowClick: [
|
||
{
|
||
"##eventHandlerType": "Set State",
|
||
parameters: {
|
||
path: "NameColumnName",
|
||
value: {
|
||
"##bbstate": "name",
|
||
"##bbsource": "context",
|
||
"##bbstatefallback": "balls to that",
|
||
},
|
||
},
|
||
},
|
||
],
|
||
tableClass: "table-default",
|
||
theadClass: "thead-default",
|
||
tbodyClass: "tbody-default",
|
||
trClass: "tr-default",
|
||
thClass: "th-default",
|
||
},
|
||
|
||
grid: {
|
||
_component: "components/grid",
|
||
gridTemplateColumns: "[left] auto [center] auto [right] auto",
|
||
gridTemplateRows: "[top] auto [middle] auto [bottom] auto",
|
||
children: [
|
||
{
|
||
control: {
|
||
_component: "components/text",
|
||
value: "1",
|
||
background: "blue",
|
||
textAlign: "center",
|
||
color: "white",
|
||
},
|
||
gridColumn: "left",
|
||
gridRow: "top",
|
||
},
|
||
{
|
||
control: {
|
||
_component: "components/text",
|
||
value: "2",
|
||
background: "red",
|
||
textAlign: "center",
|
||
color: "white",
|
||
padding: "10px",
|
||
},
|
||
gridColumn: "center",
|
||
gridRow: "middle",
|
||
},
|
||
{
|
||
control: {
|
||
_component: "components/text",
|
||
value: "3",
|
||
background: "yellow",
|
||
textAlign: "center",
|
||
color: "black",
|
||
},
|
||
gridColumn: "right",
|
||
gridRow: "bottom",
|
||
},
|
||
],
|
||
},
|
||
boundStackPanel: {
|
||
_component: "components/stackpanel",
|
||
direction: "horizontal",
|
||
children: [
|
||
{
|
||
control: {
|
||
_component: "components/text",
|
||
value: "STATIC",
|
||
},
|
||
},
|
||
],
|
||
data: {
|
||
"##bbstate": "people",
|
||
},
|
||
dataItemComponent: {
|
||
_component: "components/panel",
|
||
text: {
|
||
"##bbstate": "name",
|
||
"##bbsource": "context",
|
||
"##bbstatefallback": "balls to that",
|
||
},
|
||
padding: "10px",
|
||
border: "5px solid black",
|
||
margin: "10px",
|
||
hoverColor: "white",
|
||
hoverBackground: "black",
|
||
height: "200px",
|
||
weight: "200px",
|
||
},
|
||
},
|
||
hiddenNav: {
|
||
_component: "components/stackpanel",
|
||
children: [
|
||
{
|
||
control: {
|
||
_component: "components/button",
|
||
contentText: "Peep",
|
||
onClick: [
|
||
{
|
||
"##eventHandlerType": "Set State",
|
||
parameters: {
|
||
path: "selected",
|
||
value: "People",
|
||
},
|
||
},
|
||
],
|
||
},
|
||
},
|
||
{
|
||
control: {
|
||
_component: "components/button",
|
||
contentText: "Ani",
|
||
onClick: [
|
||
{
|
||
"##eventHandlerType": "Set State",
|
||
parameters: {
|
||
path: "selected",
|
||
value: "Animals",
|
||
},
|
||
},
|
||
],
|
||
},
|
||
},
|
||
{
|
||
control: {
|
||
_component: "components/nav",
|
||
hideNavBar: true,
|
||
selectedItem: {
|
||
"##bbstate": "selected",
|
||
"##bbsource": "store",
|
||
"##bbstatefallback": "Animals",
|
||
},
|
||
items: [
|
||
{
|
||
title: "People",
|
||
component: {
|
||
_component: "components/panel",
|
||
text: "People Panel",
|
||
padding: "40px",
|
||
border: "2px solid pink",
|
||
background: "mistyrose",
|
||
},
|
||
},
|
||
{
|
||
title: "Animals",
|
||
component: {
|
||
_component: "components/panel",
|
||
text: "Animals Panel",
|
||
padding: "40px",
|
||
border: "2px solid green",
|
||
background: "azure",
|
||
},
|
||
},
|
||
],
|
||
},
|
||
},
|
||
],
|
||
},
|
||
}
|
||
|
||
/* src\Test\TestApp.svelte generated by Svelte v3.12.1 */
|
||
|
||
const file$b = "src\\Test\\TestApp.svelte"
|
||
|
||
// (1:0) <script> import createApp from "./createApp"; import { props }
|
||
function create_catch_block(ctx) {
|
||
const block = {
|
||
c: noop,
|
||
l: noop,
|
||
m: noop,
|
||
p: noop,
|
||
d: noop,
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_catch_block.name,
|
||
type: "catch",
|
||
source:
|
||
'(1:0) <script> import createApp from "./createApp"; import { props }',
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (26:0) {:then _bb}
|
||
function create_then_block(ctx) {
|
||
var div
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div")
|
||
this.h()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
div = claim_element(nodes, "DIV", { id: true, class: true }, false)
|
||
var div_nodes = children(div)
|
||
|
||
div_nodes.forEach(detach_dev)
|
||
this.h()
|
||
},
|
||
|
||
h: function hydrate() {
|
||
attr_dev(div, "id", "current_component")
|
||
attr_dev(div, "class", "svelte-1xqz9vm")
|
||
add_location(div, file$b, 27, 0, 380)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor)
|
||
ctx.div_binding(div)
|
||
},
|
||
|
||
p: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(div)
|
||
}
|
||
|
||
ctx.div_binding(null)
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_then_block.name,
|
||
type: "then",
|
||
source: "(26:0) {:then _bb}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
// (24:20) loading {:then _bb}
|
||
function create_pending_block(ctx) {
|
||
var t
|
||
|
||
const block = {
|
||
c: function create() {
|
||
t = text("loading")
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
t = claim_text(nodes, "loading")
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, t, anchor)
|
||
},
|
||
|
||
p: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(t)
|
||
}
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_pending_block.name,
|
||
type: "pending",
|
||
source: "(24:20) loading {:then _bb}",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function create_fragment$a(ctx) {
|
||
var await_block_anchor, promise
|
||
|
||
let info = {
|
||
ctx,
|
||
current: null,
|
||
token: null,
|
||
pending: create_pending_block,
|
||
then: create_then_block,
|
||
catch: create_catch_block,
|
||
value: "_bb",
|
||
error: "null",
|
||
}
|
||
|
||
handle_promise((promise = ctx._appPromise), info)
|
||
|
||
const block = {
|
||
c: function create() {
|
||
await_block_anchor = empty()
|
||
|
||
info.block.c()
|
||
},
|
||
|
||
l: function claim(nodes) {
|
||
await_block_anchor = empty()
|
||
|
||
info.block.l(nodes)
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, await_block_anchor, anchor)
|
||
|
||
info.block.m(target, (info.anchor = anchor))
|
||
info.mount = () => await_block_anchor.parentNode
|
||
info.anchor = await_block_anchor
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx
|
||
info.block.p(changed, assign(assign({}, ctx), info.resolved))
|
||
},
|
||
|
||
i: noop,
|
||
o: noop,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
detach_dev(await_block_anchor)
|
||
}
|
||
|
||
info.block.d(detaching)
|
||
info.token = null
|
||
info = null
|
||
},
|
||
}
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$a.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx,
|
||
})
|
||
return block
|
||
}
|
||
|
||
function instance$a($$self, $$props, $$invalidate) {
|
||
let _bb
|
||
|
||
const _appPromise = createApp$1()
|
||
_appPromise.then(a => $$invalidate("_bb", (_bb = a)))
|
||
|
||
const testProps = props.hiddenNav
|
||
|
||
let currentComponent
|
||
|
||
function div_binding($$value) {
|
||
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
$$invalidate("currentComponent", (currentComponent = $$value))
|
||
})
|
||
}
|
||
|
||
$$self.$capture_state = () => {
|
||
return {}
|
||
}
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
|
||
if ("currentComponent" in $$props)
|
||
$$invalidate(
|
||
"currentComponent",
|
||
(currentComponent = $$props.currentComponent)
|
||
)
|
||
}
|
||
|
||
$$self.$$.update = ($$dirty = { _bb: 1, currentComponent: 1 }) => {
|
||
if ($$dirty._bb || $$dirty.currentComponent) {
|
||
{
|
||
if (_bb && currentComponent) {
|
||
_bb.initialiseComponent(testProps, currentComponent)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
_appPromise,
|
||
currentComponent,
|
||
div_binding,
|
||
}
|
||
}
|
||
|
||
class TestApp extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options)
|
||
init(this, options, instance$a, create_fragment$a, safe_not_equal, [])
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "TestApp",
|
||
options,
|
||
id: create_fragment$a.name,
|
||
})
|
||
}
|
||
}
|
||
|
||
const app = new TestApp({
|
||
target: document.body,
|
||
})
|
||
|
||
return app
|
||
})()
|
||
//# sourceMappingURL=bundle.js.map
|