mirror of https://github.com/Budibase/budibase.git
nocodelowcodelow-codedockerdocker-composeinternal-projectinternal-toolinternal-toolslow-code-developmentlow-code-development-platformopensourceselfhostedweb-devweb-developmentweb-development-toolswebdevwebdevelopmentworkflow-automationautomationdeveloper-tools
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
33412 lines
1.0 MiB
33412 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 =>
|
|
isModel(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 isModel = node => isSomething(node) && node.type === "record"
|
|
const isCollectionRecord = node => isModel(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
|