;(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({
          "&": "&amp;",
          "<": "&lt;",
          ">": "&gt;",
          '"': "&quot;",
          "'": "&#39;",
        }),
        tt = x({
          "&amp;": "&",
          "&lt;": "<",
          "&gt;": ">",
          "&quot;": '"',
          "&#39;": "'",
        }),
        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 = {
        "&": "&amp;",
        "<": "&lt;",
        ">": "&gt;",
        '"': "&quot;",
        "'": "&#39;",
      }

      /** Used to map HTML entities to characters. */
      var htmlUnescapes = {
        "&amp;": "&",
        "&lt;": "<",
        "&gt;": ">",
        "&quot;": '"',
        "&#39;": "'",
      }

      /** 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, &amp; 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, &amp; 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>&lt;script&gt;</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
         * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` 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, &amp; pebbles');
         * // => 'fred, barney, & pebbles'
         */
        function unescape(string) {
          string = toString(string)
          return string && reHasEscapedHtml.test(string)
            ? string.replace(reEscapedHtml, unescapeHtmlChar)
            : string
        }

        /**
         * Converts `string`, as space separated words, to upper case.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category String
         * @param {string} [string=''] The string to convert.
         * @returns {string} Returns the upper cased string.
         * @example
         *
         * _.upperCase('--foo-bar');
         * // => 'FOO BAR'
         *
         * _.upperCase('fooBar');
         * // => 'FOO BAR'
         *
         * _.upperCase('__foo_bar__');
         * // => 'FOO BAR'
         */
        var upperCase = createCompounder(function(result, word, index) {
          return result + (index ? " " : "") + word.toUpperCase()
        })

        /**
         * Converts the first character of `string` to upper case.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category String
         * @param {string} [string=''] The string to convert.
         * @returns {string} Returns the converted string.
         * @example
         *
         * _.upperFirst('fred');
         * // => 'Fred'
         *
         * _.upperFirst('FRED');
         * // => 'FRED'
         */
        var upperFirst = createCaseFirst("toUpperCase")

        /**
         * Splits `string` into an array of its words.
         *
         * @static
         * @memberOf _
         * @since 3.0.0
         * @category String
         * @param {string} [string=''] The string to inspect.
         * @param {RegExp|string} [pattern] The pattern to match words.
         * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
         * @returns {Array} Returns the words of `string`.
         * @example
         *
         * _.words('fred, barney, & pebbles');
         * // => ['fred', 'barney', 'pebbles']
         *
         * _.words('fred, barney, & pebbles', /[^, ]+/g);
         * // => ['fred', 'barney', '&', 'pebbles']
         */
        function words(string, pattern, guard) {
          string = toString(string)
          pattern = guard ? undefined$1 : pattern

          if (pattern === undefined$1) {
            return hasUnicodeWord(string)
              ? unicodeWords(string)
              : asciiWords(string)
          }
          return string.match(pattern) || []
        }

        /*------------------------------------------------------------------------*/

        /**
         * Attempts to invoke `func`, returning either the result or the caught error
         * object. Any additional arguments are provided to `func` when it's invoked.
         *
         * @static
         * @memberOf _
         * @since 3.0.0
         * @category Util
         * @param {Function} func The function to attempt.
         * @param {...*} [args] The arguments to invoke `func` with.
         * @returns {*} Returns the `func` result or error object.
         * @example
         *
         * // Avoid throwing errors for invalid selectors.
         * var elements = _.attempt(function(selector) {
         *   return document.querySelectorAll(selector);
         * }, '>_>');
         *
         * if (_.isError(elements)) {
         *   elements = [];
         * }
         */
        var attempt = baseRest(function(func, args) {
          try {
            return apply(func, undefined$1, args)
          } catch (e) {
            return isError(e) ? e : new Error(e)
          }
        })

        /**
         * Binds methods of an object to the object itself, overwriting the existing
         * method.
         *
         * **Note:** This method doesn't set the "length" property of bound functions.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {Object} object The object to bind and assign the bound methods to.
         * @param {...(string|string[])} methodNames The object method names to bind.
         * @returns {Object} Returns `object`.
         * @example
         *
         * var view = {
         *   'label': 'docs',
         *   'click': function() {
         *     console.log('clicked ' + this.label);
         *   }
         * };
         *
         * _.bindAll(view, ['click']);
         * jQuery(element).on('click', view.click);
         * // => Logs 'clicked docs' when clicked.
         */
        var bindAll = flatRest(function(object, methodNames) {
          arrayEach(methodNames, function(key) {
            key = toKey(key)
            baseAssignValue(object, key, bind(object[key], object))
          })
          return object
        })

        /**
         * Creates a function that iterates over `pairs` and invokes the corresponding
         * function of the first predicate to return truthy. The predicate-function
         * pairs are invoked with the `this` binding and arguments of the created
         * function.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {Array} pairs The predicate-function pairs.
         * @returns {Function} Returns the new composite function.
         * @example
         *
         * var func = _.cond([
         *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
         *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
         *   [_.stubTrue,                      _.constant('no match')]
         * ]);
         *
         * func({ 'a': 1, 'b': 2 });
         * // => 'matches A'
         *
         * func({ 'a': 0, 'b': 1 });
         * // => 'matches B'
         *
         * func({ 'a': '1', 'b': '2' });
         * // => 'no match'
         */
        function cond(pairs) {
          var length = pairs == null ? 0 : pairs.length,
            toIteratee = getIteratee()

          pairs = !length
            ? []
            : arrayMap(pairs, function(pair) {
                if (typeof pair[1] != "function") {
                  throw new TypeError(FUNC_ERROR_TEXT)
                }
                return [toIteratee(pair[0]), pair[1]]
              })

          return baseRest(function(args) {
            var index = -1
            while (++index < length) {
              var pair = pairs[index]
              if (apply(pair[0], this, args)) {
                return apply(pair[1], this, args)
              }
            }
          })
        }

        /**
         * Creates a function that invokes the predicate properties of `source` with
         * the corresponding property values of a given object, returning `true` if
         * all predicates return truthy, else `false`.
         *
         * **Note:** The created function is equivalent to `_.conformsTo` with
         * `source` partially applied.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {Object} source The object of property predicates to conform to.
         * @returns {Function} Returns the new spec function.
         * @example
         *
         * var objects = [
         *   { 'a': 2, 'b': 1 },
         *   { 'a': 1, 'b': 2 }
         * ];
         *
         * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
         * // => [{ 'a': 1, 'b': 2 }]
         */
        function conforms(source) {
          return baseConforms(baseClone(source, CLONE_DEEP_FLAG))
        }

        /**
         * Creates a function that returns `value`.
         *
         * @static
         * @memberOf _
         * @since 2.4.0
         * @category Util
         * @param {*} value The value to return from the new function.
         * @returns {Function} Returns the new constant function.
         * @example
         *
         * var objects = _.times(2, _.constant({ 'a': 1 }));
         *
         * console.log(objects);
         * // => [{ 'a': 1 }, { 'a': 1 }]
         *
         * console.log(objects[0] === objects[1]);
         * // => true
         */
        function constant(value) {
          return function() {
            return value
          }
        }

        /**
         * Checks `value` to determine whether a default value should be returned in
         * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
         * or `undefined`.
         *
         * @static
         * @memberOf _
         * @since 4.14.0
         * @category Util
         * @param {*} value The value to check.
         * @param {*} defaultValue The default value.
         * @returns {*} Returns the resolved value.
         * @example
         *
         * _.defaultTo(1, 10);
         * // => 1
         *
         * _.defaultTo(undefined, 10);
         * // => 10
         */
        function defaultTo(value, defaultValue) {
          return value == null || value !== value ? defaultValue : value
        }

        /**
         * Creates a function that returns the result of invoking the given functions
         * with the `this` binding of the created function, where each successive
         * invocation is supplied the return value of the previous.
         *
         * @static
         * @memberOf _
         * @since 3.0.0
         * @category Util
         * @param {...(Function|Function[])} [funcs] The functions to invoke.
         * @returns {Function} Returns the new composite function.
         * @see _.flowRight
         * @example
         *
         * function square(n) {
         *   return n * n;
         * }
         *
         * var addSquare = _.flow([_.add, square]);
         * addSquare(1, 2);
         * // => 9
         */
        var flow = createFlow()

        /**
         * This method is like `_.flow` except that it creates a function that
         * invokes the given functions from right to left.
         *
         * @static
         * @since 3.0.0
         * @memberOf _
         * @category Util
         * @param {...(Function|Function[])} [funcs] The functions to invoke.
         * @returns {Function} Returns the new composite function.
         * @see _.flow
         * @example
         *
         * function square(n) {
         *   return n * n;
         * }
         *
         * var addSquare = _.flowRight([square, _.add]);
         * addSquare(1, 2);
         * // => 9
         */
        var flowRight = createFlow(true)

        /**
         * This method returns the first argument it receives.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {*} value Any value.
         * @returns {*} Returns `value`.
         * @example
         *
         * var object = { 'a': 1 };
         *
         * console.log(_.identity(object) === object);
         * // => true
         */
        function identity(value) {
          return value
        }

        /**
         * Creates a function that invokes `func` with the arguments of the created
         * function. If `func` is a property name, the created function returns the
         * property value for a given element. If `func` is an array or object, the
         * created function returns `true` for elements that contain the equivalent
         * source properties, otherwise it returns `false`.
         *
         * @static
         * @since 4.0.0
         * @memberOf _
         * @category Util
         * @param {*} [func=_.identity] The value to convert to a callback.
         * @returns {Function} Returns the callback.
         * @example
         *
         * var users = [
         *   { 'user': 'barney', 'age': 36, 'active': true },
         *   { 'user': 'fred',   'age': 40, 'active': false }
         * ];
         *
         * // The `_.matches` iteratee shorthand.
         * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
         * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
         *
         * // The `_.matchesProperty` iteratee shorthand.
         * _.filter(users, _.iteratee(['user', 'fred']));
         * // => [{ 'user': 'fred', 'age': 40 }]
         *
         * // The `_.property` iteratee shorthand.
         * _.map(users, _.iteratee('user'));
         * // => ['barney', 'fred']
         *
         * // Create custom iteratee shorthands.
         * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
         *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
         *     return func.test(string);
         *   };
         * });
         *
         * _.filter(['abc', 'def'], /ef/);
         * // => ['def']
         */
        function iteratee(func) {
          return baseIteratee(
            typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG)
          )
        }

        /**
         * Creates a function that performs a partial deep comparison between a given
         * object and `source`, returning `true` if the given object has equivalent
         * property values, else `false`.
         *
         * **Note:** The created function is equivalent to `_.isMatch` with `source`
         * partially applied.
         *
         * Partial comparisons will match empty array and empty object `source`
         * values against any array or object value, respectively. See `_.isEqual`
         * for a list of supported value comparisons.
         *
         * @static
         * @memberOf _
         * @since 3.0.0
         * @category Util
         * @param {Object} source The object of property values to match.
         * @returns {Function} Returns the new spec function.
         * @example
         *
         * var objects = [
         *   { 'a': 1, 'b': 2, 'c': 3 },
         *   { 'a': 4, 'b': 5, 'c': 6 }
         * ];
         *
         * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
         * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
         */
        function matches(source) {
          return baseMatches(baseClone(source, CLONE_DEEP_FLAG))
        }

        /**
         * Creates a function that performs a partial deep comparison between the
         * value at `path` of a given object to `srcValue`, returning `true` if the
         * object value is equivalent, else `false`.
         *
         * **Note:** Partial comparisons will match empty array and empty object
         * `srcValue` values against any array or object value, respectively. See
         * `_.isEqual` for a list of supported value comparisons.
         *
         * @static
         * @memberOf _
         * @since 3.2.0
         * @category Util
         * @param {Array|string} path The path of the property to get.
         * @param {*} srcValue The value to match.
         * @returns {Function} Returns the new spec function.
         * @example
         *
         * var objects = [
         *   { 'a': 1, 'b': 2, 'c': 3 },
         *   { 'a': 4, 'b': 5, 'c': 6 }
         * ];
         *
         * _.find(objects, _.matchesProperty('a', 4));
         * // => { 'a': 4, 'b': 5, 'c': 6 }
         */
        function matchesProperty(path, srcValue) {
          return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG))
        }

        /**
         * Creates a function that invokes the method at `path` of a given object.
         * Any additional arguments are provided to the invoked method.
         *
         * @static
         * @memberOf _
         * @since 3.7.0
         * @category Util
         * @param {Array|string} path The path of the method to invoke.
         * @param {...*} [args] The arguments to invoke the method with.
         * @returns {Function} Returns the new invoker function.
         * @example
         *
         * var objects = [
         *   { 'a': { 'b': _.constant(2) } },
         *   { 'a': { 'b': _.constant(1) } }
         * ];
         *
         * _.map(objects, _.method('a.b'));
         * // => [2, 1]
         *
         * _.map(objects, _.method(['a', 'b']));
         * // => [2, 1]
         */
        var method = baseRest(function(path, args) {
          return function(object) {
            return baseInvoke(object, path, args)
          }
        })

        /**
         * The opposite of `_.method`; this method creates a function that invokes
         * the method at a given path of `object`. Any additional arguments are
         * provided to the invoked method.
         *
         * @static
         * @memberOf _
         * @since 3.7.0
         * @category Util
         * @param {Object} object The object to query.
         * @param {...*} [args] The arguments to invoke the method with.
         * @returns {Function} Returns the new invoker function.
         * @example
         *
         * var array = _.times(3, _.constant),
         *     object = { 'a': array, 'b': array, 'c': array };
         *
         * _.map(['a[2]', 'c[0]'], _.methodOf(object));
         * // => [2, 0]
         *
         * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
         * // => [2, 0]
         */
        var methodOf = baseRest(function(object, args) {
          return function(path) {
            return baseInvoke(object, path, args)
          }
        })

        /**
         * Adds all own enumerable string keyed function properties of a source
         * object to the destination object. If `object` is a function, then methods
         * are added to its prototype as well.
         *
         * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
         * avoid conflicts caused by modifying the original.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {Function|Object} [object=lodash] The destination object.
         * @param {Object} source The object of functions to add.
         * @param {Object} [options={}] The options object.
         * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
         * @returns {Function|Object} Returns `object`.
         * @example
         *
         * function vowels(string) {
         *   return _.filter(string, function(v) {
         *     return /[aeiou]/i.test(v);
         *   });
         * }
         *
         * _.mixin({ 'vowels': vowels });
         * _.vowels('fred');
         * // => ['e']
         *
         * _('fred').vowels().value();
         * // => ['e']
         *
         * _.mixin({ 'vowels': vowels }, { 'chain': false });
         * _('fred').vowels();
         * // => ['e']
         */
        function mixin(object, source, options) {
          var props = keys(source),
            methodNames = baseFunctions(source, props)

          if (
            options == null &&
            !(isObject(source) && (methodNames.length || !props.length))
          ) {
            options = source
            source = object
            object = this
            methodNames = baseFunctions(source, keys(source))
          }
          var chain =
              !(isObject(options) && "chain" in options) || !!options.chain,
            isFunc = isFunction(object)

          arrayEach(methodNames, function(methodName) {
            var func = source[methodName]
            object[methodName] = func
            if (isFunc) {
              object.prototype[methodName] = function() {
                var chainAll = this.__chain__
                if (chain || chainAll) {
                  var result = object(this.__wrapped__),
                    actions = (result.__actions__ = copyArray(this.__actions__))

                  actions.push({ func: func, args: arguments, thisArg: object })
                  result.__chain__ = chainAll
                  return result
                }
                return func.apply(object, arrayPush([this.value()], arguments))
              }
            }
          })

          return object
        }

        /**
         * Reverts the `_` variable to its previous value and returns a reference to
         * the `lodash` function.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @returns {Function} Returns the `lodash` function.
         * @example
         *
         * var lodash = _.noConflict();
         */
        function noConflict() {
          if (root._ === this) {
            root._ = oldDash
          }
          return this
        }

        /**
         * This method returns `undefined`.
         *
         * @static
         * @memberOf _
         * @since 2.3.0
         * @category Util
         * @example
         *
         * _.times(2, _.noop);
         * // => [undefined, undefined]
         */
        function noop() {
          // No operation performed.
        }

        /**
         * Creates a function that gets the argument at index `n`. If `n` is negative,
         * the nth argument from the end is returned.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {number} [n=0] The index of the argument to return.
         * @returns {Function} Returns the new pass-thru function.
         * @example
         *
         * var func = _.nthArg(1);
         * func('a', 'b', 'c', 'd');
         * // => 'b'
         *
         * var func = _.nthArg(-2);
         * func('a', 'b', 'c', 'd');
         * // => 'c'
         */
        function nthArg(n) {
          n = toInteger(n)
          return baseRest(function(args) {
            return baseNth(args, n)
          })
        }

        /**
         * Creates a function that invokes `iteratees` with the arguments it receives
         * and returns their results.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {...(Function|Function[])} [iteratees=[_.identity]]
         *  The iteratees to invoke.
         * @returns {Function} Returns the new function.
         * @example
         *
         * var func = _.over([Math.max, Math.min]);
         *
         * func(1, 2, 3, 4);
         * // => [4, 1]
         */
        var over = createOver(arrayMap)

        /**
         * Creates a function that checks if **all** of the `predicates` return
         * truthy when invoked with the arguments it receives.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {...(Function|Function[])} [predicates=[_.identity]]
         *  The predicates to check.
         * @returns {Function} Returns the new function.
         * @example
         *
         * var func = _.overEvery([Boolean, isFinite]);
         *
         * func('1');
         * // => true
         *
         * func(null);
         * // => false
         *
         * func(NaN);
         * // => false
         */
        var overEvery = createOver(arrayEvery)

        /**
         * Creates a function that checks if **any** of the `predicates` return
         * truthy when invoked with the arguments it receives.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {...(Function|Function[])} [predicates=[_.identity]]
         *  The predicates to check.
         * @returns {Function} Returns the new function.
         * @example
         *
         * var func = _.overSome([Boolean, isFinite]);
         *
         * func('1');
         * // => true
         *
         * func(null);
         * // => true
         *
         * func(NaN);
         * // => false
         */
        var overSome = createOver(arraySome)

        /**
         * Creates a function that returns the value at `path` of a given object.
         *
         * @static
         * @memberOf _
         * @since 2.4.0
         * @category Util
         * @param {Array|string} path The path of the property to get.
         * @returns {Function} Returns the new accessor function.
         * @example
         *
         * var objects = [
         *   { 'a': { 'b': 2 } },
         *   { 'a': { 'b': 1 } }
         * ];
         *
         * _.map(objects, _.property('a.b'));
         * // => [2, 1]
         *
         * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
         * // => [1, 2]
         */
        function property(path) {
          return isKey(path)
            ? baseProperty(toKey(path))
            : basePropertyDeep(path)
        }

        /**
         * The opposite of `_.property`; this method creates a function that returns
         * the value at a given path of `object`.
         *
         * @static
         * @memberOf _
         * @since 3.0.0
         * @category Util
         * @param {Object} object The object to query.
         * @returns {Function} Returns the new accessor function.
         * @example
         *
         * var array = [0, 1, 2],
         *     object = { 'a': array, 'b': array, 'c': array };
         *
         * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
         * // => [2, 0]
         *
         * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
         * // => [2, 0]
         */
        function propertyOf(object) {
          return function(path) {
            return object == null ? undefined$1 : baseGet(object, path)
          }
        }

        /**
         * Creates an array of numbers (positive and/or negative) progressing from
         * `start` up to, but not including, `end`. A step of `-1` is used if a negative
         * `start` is specified without an `end` or `step`. If `end` is not specified,
         * it's set to `start` with `start` then set to `0`.
         *
         * **Note:** JavaScript follows the IEEE-754 standard for resolving
         * floating-point values which can produce unexpected results.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {number} [start=0] The start of the range.
         * @param {number} end The end of the range.
         * @param {number} [step=1] The value to increment or decrement by.
         * @returns {Array} Returns the range of numbers.
         * @see _.inRange, _.rangeRight
         * @example
         *
         * _.range(4);
         * // => [0, 1, 2, 3]
         *
         * _.range(-4);
         * // => [0, -1, -2, -3]
         *
         * _.range(1, 5);
         * // => [1, 2, 3, 4]
         *
         * _.range(0, 20, 5);
         * // => [0, 5, 10, 15]
         *
         * _.range(0, -4, -1);
         * // => [0, -1, -2, -3]
         *
         * _.range(1, 4, 0);
         * // => [1, 1, 1]
         *
         * _.range(0);
         * // => []
         */
        var range = createRange()

        /**
         * This method is like `_.range` except that it populates values in
         * descending order.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {number} [start=0] The start of the range.
         * @param {number} end The end of the range.
         * @param {number} [step=1] The value to increment or decrement by.
         * @returns {Array} Returns the range of numbers.
         * @see _.inRange, _.range
         * @example
         *
         * _.rangeRight(4);
         * // => [3, 2, 1, 0]
         *
         * _.rangeRight(-4);
         * // => [-3, -2, -1, 0]
         *
         * _.rangeRight(1, 5);
         * // => [4, 3, 2, 1]
         *
         * _.rangeRight(0, 20, 5);
         * // => [15, 10, 5, 0]
         *
         * _.rangeRight(0, -4, -1);
         * // => [-3, -2, -1, 0]
         *
         * _.rangeRight(1, 4, 0);
         * // => [1, 1, 1]
         *
         * _.rangeRight(0);
         * // => []
         */
        var rangeRight = createRange(true)

        /**
         * This method returns a new empty array.
         *
         * @static
         * @memberOf _
         * @since 4.13.0
         * @category Util
         * @returns {Array} Returns the new empty array.
         * @example
         *
         * var arrays = _.times(2, _.stubArray);
         *
         * console.log(arrays);
         * // => [[], []]
         *
         * console.log(arrays[0] === arrays[1]);
         * // => false
         */
        function stubArray() {
          return []
        }

        /**
         * This method returns `false`.
         *
         * @static
         * @memberOf _
         * @since 4.13.0
         * @category Util
         * @returns {boolean} Returns `false`.
         * @example
         *
         * _.times(2, _.stubFalse);
         * // => [false, false]
         */
        function stubFalse() {
          return false
        }

        /**
         * This method returns a new empty object.
         *
         * @static
         * @memberOf _
         * @since 4.13.0
         * @category Util
         * @returns {Object} Returns the new empty object.
         * @example
         *
         * var objects = _.times(2, _.stubObject);
         *
         * console.log(objects);
         * // => [{}, {}]
         *
         * console.log(objects[0] === objects[1]);
         * // => false
         */
        function stubObject() {
          return {}
        }

        /**
         * This method returns an empty string.
         *
         * @static
         * @memberOf _
         * @since 4.13.0
         * @category Util
         * @returns {string} Returns the empty string.
         * @example
         *
         * _.times(2, _.stubString);
         * // => ['', '']
         */
        function stubString() {
          return ""
        }

        /**
         * This method returns `true`.
         *
         * @static
         * @memberOf _
         * @since 4.13.0
         * @category Util
         * @returns {boolean} Returns `true`.
         * @example
         *
         * _.times(2, _.stubTrue);
         * // => [true, true]
         */
        function stubTrue() {
          return true
        }

        /**
         * Invokes the iteratee `n` times, returning an array of the results of
         * each invocation. The iteratee is invoked with one argument; (index).
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {number} n The number of times to invoke `iteratee`.
         * @param {Function} [iteratee=_.identity] The function invoked per iteration.
         * @returns {Array} Returns the array of results.
         * @example
         *
         * _.times(3, String);
         * // => ['0', '1', '2']
         *
         *  _.times(4, _.constant(0));
         * // => [0, 0, 0, 0]
         */
        function times(n, iteratee) {
          n = toInteger(n)
          if (n < 1 || n > MAX_SAFE_INTEGER) {
            return []
          }
          var index = MAX_ARRAY_LENGTH,
            length = nativeMin(n, MAX_ARRAY_LENGTH)

          iteratee = getIteratee(iteratee)
          n -= MAX_ARRAY_LENGTH

          var result = baseTimes(length, iteratee)
          while (++index < n) {
            iteratee(index)
          }
          return result
        }

        /**
         * Converts `value` to a property path array.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Util
         * @param {*} value The value to convert.
         * @returns {Array} Returns the new property path array.
         * @example
         *
         * _.toPath('a.b.c');
         * // => ['a', 'b', 'c']
         *
         * _.toPath('a[0].b.c');
         * // => ['a', '0', 'b', 'c']
         */
        function toPath(value) {
          if (isArray(value)) {
            return arrayMap(value, toKey)
          }
          return isSymbol(value)
            ? [value]
            : copyArray(stringToPath(toString(value)))
        }

        /**
         * Generates a unique ID. If `prefix` is given, the ID is appended to it.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Util
         * @param {string} [prefix=''] The value to prefix the ID with.
         * @returns {string} Returns the unique ID.
         * @example
         *
         * _.uniqueId('contact_');
         * // => 'contact_104'
         *
         * _.uniqueId();
         * // => '105'
         */
        function uniqueId(prefix) {
          var id = ++idCounter
          return toString(prefix) + id
        }

        /*------------------------------------------------------------------------*/

        /**
         * Adds two numbers.
         *
         * @static
         * @memberOf _
         * @since 3.4.0
         * @category Math
         * @param {number} augend The first number in an addition.
         * @param {number} addend The second number in an addition.
         * @returns {number} Returns the total.
         * @example
         *
         * _.add(6, 4);
         * // => 10
         */
        var add = createMathOperation(function(augend, addend) {
          return augend + addend
        }, 0)

        /**
         * Computes `number` rounded up to `precision`.
         *
         * @static
         * @memberOf _
         * @since 3.10.0
         * @category Math
         * @param {number} number The number to round up.
         * @param {number} [precision=0] The precision to round up to.
         * @returns {number} Returns the rounded up number.
         * @example
         *
         * _.ceil(4.006);
         * // => 5
         *
         * _.ceil(6.004, 2);
         * // => 6.01
         *
         * _.ceil(6040, -2);
         * // => 6100
         */
        var ceil = createRound("ceil")

        /**
         * Divide two numbers.
         *
         * @static
         * @memberOf _
         * @since 4.7.0
         * @category Math
         * @param {number} dividend The first number in a division.
         * @param {number} divisor The second number in a division.
         * @returns {number} Returns the quotient.
         * @example
         *
         * _.divide(6, 4);
         * // => 1.5
         */
        var divide = createMathOperation(function(dividend, divisor) {
          return dividend / divisor
        }, 1)

        /**
         * Computes `number` rounded down to `precision`.
         *
         * @static
         * @memberOf _
         * @since 3.10.0
         * @category Math
         * @param {number} number The number to round down.
         * @param {number} [precision=0] The precision to round down to.
         * @returns {number} Returns the rounded down number.
         * @example
         *
         * _.floor(4.006);
         * // => 4
         *
         * _.floor(0.046, 2);
         * // => 0.04
         *
         * _.floor(4060, -2);
         * // => 4000
         */
        var floor = createRound("floor")

        /**
         * Computes the maximum value of `array`. If `array` is empty or falsey,
         * `undefined` is returned.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Math
         * @param {Array} array The array to iterate over.
         * @returns {*} Returns the maximum value.
         * @example
         *
         * _.max([4, 2, 8, 6]);
         * // => 8
         *
         * _.max([]);
         * // => undefined
         */
        function max(array) {
          return array && array.length
            ? baseExtremum(array, identity, baseGt)
            : undefined$1
        }

        /**
         * This method is like `_.max` except that it accepts `iteratee` which is
         * invoked for each element in `array` to generate the criterion by which
         * the value is ranked. The iteratee is invoked with one argument: (value).
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
         * @returns {*} Returns the maximum value.
         * @example
         *
         * var objects = [{ 'n': 1 }, { 'n': 2 }];
         *
         * _.maxBy(objects, function(o) { return o.n; });
         * // => { 'n': 2 }
         *
         * // The `_.property` iteratee shorthand.
         * _.maxBy(objects, 'n');
         * // => { 'n': 2 }
         */
        function maxBy(array, iteratee) {
          return array && array.length
            ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
            : undefined$1
        }

        /**
         * Computes the mean of the values in `array`.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @returns {number} Returns the mean.
         * @example
         *
         * _.mean([4, 2, 8, 6]);
         * // => 5
         */
        function mean(array) {
          return baseMean(array, identity)
        }

        /**
         * This method is like `_.mean` except that it accepts `iteratee` which is
         * invoked for each element in `array` to generate the value to be averaged.
         * The iteratee is invoked with one argument: (value).
         *
         * @static
         * @memberOf _
         * @since 4.7.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
         * @returns {number} Returns the mean.
         * @example
         *
         * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
         *
         * _.meanBy(objects, function(o) { return o.n; });
         * // => 5
         *
         * // The `_.property` iteratee shorthand.
         * _.meanBy(objects, 'n');
         * // => 5
         */
        function meanBy(array, iteratee) {
          return baseMean(array, getIteratee(iteratee, 2))
        }

        /**
         * Computes the minimum value of `array`. If `array` is empty or falsey,
         * `undefined` is returned.
         *
         * @static
         * @since 0.1.0
         * @memberOf _
         * @category Math
         * @param {Array} array The array to iterate over.
         * @returns {*} Returns the minimum value.
         * @example
         *
         * _.min([4, 2, 8, 6]);
         * // => 2
         *
         * _.min([]);
         * // => undefined
         */
        function min(array) {
          return array && array.length
            ? baseExtremum(array, identity, baseLt)
            : undefined$1
        }

        /**
         * This method is like `_.min` except that it accepts `iteratee` which is
         * invoked for each element in `array` to generate the criterion by which
         * the value is ranked. The iteratee is invoked with one argument: (value).
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
         * @returns {*} Returns the minimum value.
         * @example
         *
         * var objects = [{ 'n': 1 }, { 'n': 2 }];
         *
         * _.minBy(objects, function(o) { return o.n; });
         * // => { 'n': 1 }
         *
         * // The `_.property` iteratee shorthand.
         * _.minBy(objects, 'n');
         * // => { 'n': 1 }
         */
        function minBy(array, iteratee) {
          return array && array.length
            ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
            : undefined$1
        }

        /**
         * Multiply two numbers.
         *
         * @static
         * @memberOf _
         * @since 4.7.0
         * @category Math
         * @param {number} multiplier The first number in a multiplication.
         * @param {number} multiplicand The second number in a multiplication.
         * @returns {number} Returns the product.
         * @example
         *
         * _.multiply(6, 4);
         * // => 24
         */
        var multiply = createMathOperation(function(multiplier, multiplicand) {
          return multiplier * multiplicand
        }, 1)

        /**
         * Computes `number` rounded to `precision`.
         *
         * @static
         * @memberOf _
         * @since 3.10.0
         * @category Math
         * @param {number} number The number to round.
         * @param {number} [precision=0] The precision to round to.
         * @returns {number} Returns the rounded number.
         * @example
         *
         * _.round(4.006);
         * // => 4
         *
         * _.round(4.006, 2);
         * // => 4.01
         *
         * _.round(4060, -2);
         * // => 4100
         */
        var round = createRound("round")

        /**
         * Subtract two numbers.
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Math
         * @param {number} minuend The first number in a subtraction.
         * @param {number} subtrahend The second number in a subtraction.
         * @returns {number} Returns the difference.
         * @example
         *
         * _.subtract(6, 4);
         * // => 2
         */
        var subtract = createMathOperation(function(minuend, subtrahend) {
          return minuend - subtrahend
        }, 0)

        /**
         * Computes the sum of the values in `array`.
         *
         * @static
         * @memberOf _
         * @since 3.4.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @returns {number} Returns the sum.
         * @example
         *
         * _.sum([4, 2, 8, 6]);
         * // => 20
         */
        function sum(array) {
          return array && array.length ? baseSum(array, identity) : 0
        }

        /**
         * This method is like `_.sum` except that it accepts `iteratee` which is
         * invoked for each element in `array` to generate the value to be summed.
         * The iteratee is invoked with one argument: (value).
         *
         * @static
         * @memberOf _
         * @since 4.0.0
         * @category Math
         * @param {Array} array The array to iterate over.
         * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
         * @returns {number} Returns the sum.
         * @example
         *
         * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
         *
         * _.sumBy(objects, function(o) { return o.n; });
         * // => 20
         *
         * // The `_.property` iteratee shorthand.
         * _.sumBy(objects, 'n');
         * // => 20
         */
        function sumBy(array, iteratee) {
          return array && array.length
            ? baseSum(array, getIteratee(iteratee, 2))
            : 0
        }

        /*------------------------------------------------------------------------*/

        // Add methods that return wrapped values in chain sequences.
        lodash.after = after
        lodash.ary = ary
        lodash.assign = assign
        lodash.assignIn = assignIn
        lodash.assignInWith = assignInWith
        lodash.assignWith = assignWith
        lodash.at = at
        lodash.before = before
        lodash.bind = bind
        lodash.bindAll = bindAll
        lodash.bindKey = bindKey
        lodash.castArray = castArray
        lodash.chain = chain
        lodash.chunk = chunk
        lodash.compact = compact
        lodash.concat = concat
        lodash.cond = cond
        lodash.conforms = conforms
        lodash.constant = constant
        lodash.countBy = countBy
        lodash.create = create
        lodash.curry = curry
        lodash.curryRight = curryRight
        lodash.debounce = debounce
        lodash.defaults = defaults
        lodash.defaultsDeep = defaultsDeep
        lodash.defer = defer
        lodash.delay = delay
        lodash.difference = difference
        lodash.differenceBy = differenceBy
        lodash.differenceWith = differenceWith
        lodash.drop = drop
        lodash.dropRight = dropRight
        lodash.dropRightWhile = dropRightWhile
        lodash.dropWhile = dropWhile
        lodash.fill = fill
        lodash.filter = filter
        lodash.flatMap = flatMap
        lodash.flatMapDeep = flatMapDeep
        lodash.flatMapDepth = flatMapDepth
        lodash.flatten = flatten
        lodash.flattenDeep = flattenDeep
        lodash.flattenDepth = flattenDepth
        lodash.flip = flip
        lodash.flow = flow
        lodash.flowRight = flowRight
        lodash.fromPairs = fromPairs
        lodash.functions = functions
        lodash.functionsIn = functionsIn
        lodash.groupBy = groupBy
        lodash.initial = initial
        lodash.intersection = intersection
        lodash.intersectionBy = intersectionBy
        lodash.intersectionWith = intersectionWith
        lodash.invert = invert
        lodash.invertBy = invertBy
        lodash.invokeMap = invokeMap
        lodash.iteratee = iteratee
        lodash.keyBy = keyBy
        lodash.keys = keys
        lodash.keysIn = keysIn
        lodash.map = map
        lodash.mapKeys = mapKeys
        lodash.mapValues = mapValues
        lodash.matches = matches
        lodash.matchesProperty = matchesProperty
        lodash.memoize = memoize
        lodash.merge = merge
        lodash.mergeWith = mergeWith
        lodash.method = method
        lodash.methodOf = methodOf
        lodash.mixin = mixin
        lodash.negate = negate
        lodash.nthArg = nthArg
        lodash.omit = omit
        lodash.omitBy = omitBy
        lodash.once = once
        lodash.orderBy = orderBy
        lodash.over = over
        lodash.overArgs = overArgs
        lodash.overEvery = overEvery
        lodash.overSome = overSome
        lodash.partial = partial
        lodash.partialRight = partialRight
        lodash.partition = partition
        lodash.pick = pick
        lodash.pickBy = pickBy
        lodash.property = property
        lodash.propertyOf = propertyOf
        lodash.pull = pull
        lodash.pullAll = pullAll
        lodash.pullAllBy = pullAllBy
        lodash.pullAllWith = pullAllWith
        lodash.pullAt = pullAt
        lodash.range = range
        lodash.rangeRight = rangeRight
        lodash.rearg = rearg
        lodash.reject = reject
        lodash.remove = remove
        lodash.rest = rest
        lodash.reverse = reverse
        lodash.sampleSize = sampleSize
        lodash.set = set
        lodash.setWith = setWith
        lodash.shuffle = shuffle
        lodash.slice = slice
        lodash.sortBy = sortBy
        lodash.sortedUniq = sortedUniq
        lodash.sortedUniqBy = sortedUniqBy
        lodash.split = split
        lodash.spread = spread
        lodash.tail = tail
        lodash.take = take
        lodash.takeRight = takeRight
        lodash.takeRightWhile = takeRightWhile
        lodash.takeWhile = takeWhile
        lodash.tap = tap
        lodash.throttle = throttle
        lodash.thru = thru
        lodash.toArray = toArray
        lodash.toPairs = toPairs
        lodash.toPairsIn = toPairsIn
        lodash.toPath = toPath
        lodash.toPlainObject = toPlainObject
        lodash.transform = transform
        lodash.unary = unary
        lodash.union = union
        lodash.unionBy = unionBy
        lodash.unionWith = unionWith
        lodash.uniq = uniq
        lodash.uniqBy = uniqBy
        lodash.uniqWith = uniqWith
        lodash.unset = unset
        lodash.unzip = unzip
        lodash.unzipWith = unzipWith
        lodash.update = update
        lodash.updateWith = updateWith
        lodash.values = values
        lodash.valuesIn = valuesIn
        lodash.without = without
        lodash.words = words
        lodash.wrap = wrap
        lodash.xor = xor
        lodash.xorBy = xorBy
        lodash.xorWith = xorWith
        lodash.zip = zip
        lodash.zipObject = zipObject
        lodash.zipObjectDeep = zipObjectDeep
        lodash.zipWith = zipWith

        // Add aliases.
        lodash.entries = toPairs
        lodash.entriesIn = toPairsIn
        lodash.extend = assignIn
        lodash.extendWith = assignInWith

        // Add methods to `lodash.prototype`.
        mixin(lodash, lodash)

        /*------------------------------------------------------------------------*/

        // Add methods that return unwrapped values in chain sequences.
        lodash.add = add
        lodash.attempt = attempt
        lodash.camelCase = camelCase
        lodash.capitalize = capitalize
        lodash.ceil = ceil
        lodash.clamp = clamp
        lodash.clone = clone
        lodash.cloneDeep = cloneDeep
        lodash.cloneDeepWith = cloneDeepWith
        lodash.cloneWith = cloneWith
        lodash.conformsTo = conformsTo
        lodash.deburr = deburr
        lodash.defaultTo = defaultTo
        lodash.divide = divide
        lodash.endsWith = endsWith
        lodash.eq = eq
        lodash.escape = escape
        lodash.escapeRegExp = escapeRegExp
        lodash.every = every
        lodash.find = find
        lodash.findIndex = findIndex
        lodash.findKey = findKey
        lodash.findLast = findLast
        lodash.findLastIndex = findLastIndex
        lodash.findLastKey = findLastKey
        lodash.floor = floor
        lodash.forEach = forEach
        lodash.forEachRight = forEachRight
        lodash.forIn = forIn
        lodash.forInRight = forInRight
        lodash.forOwn = forOwn
        lodash.forOwnRight = forOwnRight
        lodash.get = get
        lodash.gt = gt
        lodash.gte = gte
        lodash.has = has
        lodash.hasIn = hasIn
        lodash.head = head
        lodash.identity = identity
        lodash.includes = includes
        lodash.indexOf = indexOf
        lodash.inRange = inRange
        lodash.invoke = invoke
        lodash.isArguments = isArguments
        lodash.isArray = isArray
        lodash.isArrayBuffer = isArrayBuffer
        lodash.isArrayLike = isArrayLike
        lodash.isArrayLikeObject = isArrayLikeObject
        lodash.isBoolean = isBoolean
        lodash.isBuffer = isBuffer
        lodash.isDate = isDate
        lodash.isElement = isElement
        lodash.isEmpty = isEmpty
        lodash.isEqual = isEqual
        lodash.isEqualWith = isEqualWith
        lodash.isError = isError
        lodash.isFinite = isFinite
        lodash.isFunction = isFunction
        lodash.isInteger = isInteger
        lodash.isLength = isLength
        lodash.isMap = isMap
        lodash.isMatch = isMatch
        lodash.isMatchWith = isMatchWith
        lodash.isNaN = isNaN
        lodash.isNative = isNative
        lodash.isNil = isNil
        lodash.isNull = isNull
        lodash.isNumber = isNumber
        lodash.isObject = isObject
        lodash.isObjectLike = isObjectLike
        lodash.isPlainObject = isPlainObject
        lodash.isRegExp = isRegExp
        lodash.isSafeInteger = isSafeInteger
        lodash.isSet = isSet
        lodash.isString = isString
        lodash.isSymbol = isSymbol
        lodash.isTypedArray = isTypedArray
        lodash.isUndefined = isUndefined
        lodash.isWeakMap = isWeakMap
        lodash.isWeakSet = isWeakSet
        lodash.join = join
        lodash.kebabCase = kebabCase
        lodash.last = last
        lodash.lastIndexOf = lastIndexOf
        lodash.lowerCase = lowerCase
        lodash.lowerFirst = lowerFirst
        lodash.lt = lt
        lodash.lte = lte
        lodash.max = max
        lodash.maxBy = maxBy
        lodash.mean = mean
        lodash.meanBy = meanBy
        lodash.min = min
        lodash.minBy = minBy
        lodash.stubArray = stubArray
        lodash.stubFalse = stubFalse
        lodash.stubObject = stubObject
        lodash.stubString = stubString
        lodash.stubTrue = stubTrue
        lodash.multiply = multiply
        lodash.nth = nth
        lodash.noConflict = noConflict
        lodash.noop = noop
        lodash.now = now
        lodash.pad = pad
        lodash.padEnd = padEnd
        lodash.padStart = padStart
        lodash.parseInt = parseInt
        lodash.random = random
        lodash.reduce = reduce
        lodash.reduceRight = reduceRight
        lodash.repeat = repeat
        lodash.replace = replace
        lodash.result = result
        lodash.round = round
        lodash.runInContext = runInContext
        lodash.sample = sample
        lodash.size = size
        lodash.snakeCase = snakeCase
        lodash.some = some
        lodash.sortedIndex = sortedIndex
        lodash.sortedIndexBy = sortedIndexBy
        lodash.sortedIndexOf = sortedIndexOf
        lodash.sortedLastIndex = sortedLastIndex
        lodash.sortedLastIndexBy = sortedLastIndexBy
        lodash.sortedLastIndexOf = sortedLastIndexOf
        lodash.startCase = startCase
        lodash.startsWith = startsWith
        lodash.subtract = subtract
        lodash.sum = sum
        lodash.sumBy = sumBy
        lodash.template = template
        lodash.times = times
        lodash.toFinite = toFinite
        lodash.toInteger = toInteger
        lodash.toLength = toLength
        lodash.toLower = toLower
        lodash.toNumber = toNumber
        lodash.toSafeInteger = toSafeInteger
        lodash.toString = toString
        lodash.toUpper = toUpper
        lodash.trim = trim
        lodash.trimEnd = trimEnd
        lodash.trimStart = trimStart
        lodash.truncate = truncate
        lodash.unescape = unescape
        lodash.uniqueId = uniqueId
        lodash.upperCase = upperCase
        lodash.upperFirst = upperFirst

        // Add aliases.
        lodash.each = forEach
        lodash.eachRight = forEachRight
        lodash.first = head

        mixin(
          lodash,
          (function() {
            var source = {}
            baseForOwn(lodash, function(func, methodName) {
              if (!hasOwnProperty.call(lodash.prototype, methodName)) {
                source[methodName] = func
              }
            })
            return source
          })(),
          { chain: false }
        )

        /*------------------------------------------------------------------------*/

        /**
         * The semantic version number.
         *
         * @static
         * @memberOf _
         * @type {string}
         */
        lodash.VERSION = VERSION

        // Assign default placeholders.
        arrayEach(
          ["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"],
          function(methodName) {
            lodash[methodName].placeholder = lodash
          }
        )

        // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
        arrayEach(["drop", "take"], function(methodName, index) {
          LazyWrapper.prototype[methodName] = function(n) {
            n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0)

            var result =
              this.__filtered__ && !index ? new LazyWrapper(this) : this.clone()

            if (result.__filtered__) {
              result.__takeCount__ = nativeMin(n, result.__takeCount__)
            } else {
              result.__views__.push({
                size: nativeMin(n, MAX_ARRAY_LENGTH),
                type: methodName + (result.__dir__ < 0 ? "Right" : ""),
              })
            }
            return result
          }

          LazyWrapper.prototype[methodName + "Right"] = function(n) {
            return this.reverse()
              [methodName](n)
              .reverse()
          }
        })

        // Add `LazyWrapper` methods that accept an `iteratee` value.
        arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
          var type = index + 1,
            isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG

          LazyWrapper.prototype[methodName] = function(iteratee) {
            var result = this.clone()
            result.__iteratees__.push({
              iteratee: getIteratee(iteratee, 3),
              type: type,
            })
            result.__filtered__ = result.__filtered__ || isFilter
            return result
          }
        })

        // Add `LazyWrapper` methods for `_.head` and `_.last`.
        arrayEach(["head", "last"], function(methodName, index) {
          var takeName = "take" + (index ? "Right" : "")

          LazyWrapper.prototype[methodName] = function() {
            return this[takeName](1).value()[0]
          }
        })

        // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
        arrayEach(["initial", "tail"], function(methodName, index) {
          var dropName = "drop" + (index ? "" : "Right")

          LazyWrapper.prototype[methodName] = function() {
            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1)
          }
        })

        LazyWrapper.prototype.compact = function() {
          return this.filter(identity)
        }

        LazyWrapper.prototype.find = function(predicate) {
          return this.filter(predicate).head()
        }

        LazyWrapper.prototype.findLast = function(predicate) {
          return this.reverse().find(predicate)
        }

        LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
          if (typeof path == "function") {
            return new LazyWrapper(this)
          }
          return this.map(function(value) {
            return baseInvoke(value, path, args)
          })
        })

        LazyWrapper.prototype.reject = function(predicate) {
          return this.filter(negate(getIteratee(predicate)))
        }

        LazyWrapper.prototype.slice = function(start, end) {
          start = toInteger(start)

          var result = this
          if (result.__filtered__ && (start > 0 || end < 0)) {
            return new LazyWrapper(result)
          }
          if (start < 0) {
            result = result.takeRight(-start)
          } else if (start) {
            result = result.drop(start)
          }
          if (end !== undefined$1) {
            end = toInteger(end)
            result = end < 0 ? result.dropRight(-end) : result.take(end - start)
          }
          return result
        }

        LazyWrapper.prototype.takeRightWhile = function(predicate) {
          return this.reverse()
            .takeWhile(predicate)
            .reverse()
        }

        LazyWrapper.prototype.toArray = function() {
          return this.take(MAX_ARRAY_LENGTH)
        }

        // Add `LazyWrapper` methods to `lodash.prototype`.
        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
          var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(
              methodName
            ),
            isTaker = /^(?:head|last)$/.test(methodName),
            lodashFunc =
              lodash[
                isTaker
                  ? "take" + (methodName == "last" ? "Right" : "")
                  : methodName
              ],
            retUnwrapped = isTaker || /^find/.test(methodName)

          if (!lodashFunc) {
            return
          }
          lodash.prototype[methodName] = function() {
            var value = this.__wrapped__,
              args = isTaker ? [1] : arguments,
              isLazy = value instanceof LazyWrapper,
              iteratee = args[0],
              useLazy = isLazy || isArray(value)

            var interceptor = function(value) {
              var result = lodashFunc.apply(lodash, arrayPush([value], args))
              return isTaker && chainAll ? result[0] : result
            }

            if (
              useLazy &&
              checkIteratee &&
              typeof iteratee == "function" &&
              iteratee.length != 1
            ) {
              // Avoid lazy use if the iteratee has a "length" value other than `1`.
              isLazy = useLazy = false
            }
            var chainAll = this.__chain__,
              isHybrid = !!this.__actions__.length,
              isUnwrapped = retUnwrapped && !chainAll,
              onlyLazy = isLazy && !isHybrid

            if (!retUnwrapped && useLazy) {
              value = onlyLazy ? value : new LazyWrapper(this)
              var result = func.apply(value, args)
              result.__actions__.push({
                func: thru,
                args: [interceptor],
                thisArg: undefined$1,
              })
              return new LodashWrapper(result, chainAll)
            }
            if (isUnwrapped && onlyLazy) {
              return func.apply(this, args)
            }
            result = this.thru(interceptor)
            return isUnwrapped
              ? isTaker
                ? result.value()[0]
                : result.value()
              : result
          }
        })

        // Add `Array` methods to `lodash.prototype`.
        arrayEach(
          ["pop", "push", "shift", "sort", "splice", "unshift"],
          function(methodName) {
            var func = arrayProto[methodName],
              chainName = /^(?:push|sort|unshift)$/.test(methodName)
                ? "tap"
                : "thru",
              retUnwrapped = /^(?:pop|shift)$/.test(methodName)

            lodash.prototype[methodName] = function() {
              var args = arguments
              if (retUnwrapped && !this.__chain__) {
                var value = this.value()
                return func.apply(isArray(value) ? value : [], args)
              }
              return this[chainName](function(value) {
                return func.apply(isArray(value) ? value : [], args)
              })
            }
          }
        )

        // Map minified method names to their real names.
        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
          var lodashFunc = lodash[methodName]
          if (lodashFunc) {
            var key = lodashFunc.name + ""
            if (!hasOwnProperty.call(realNames, key)) {
              realNames[key] = []
            }
            realNames[key].push({ name: methodName, func: lodashFunc })
          }
        })

        realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [
          {
            name: "wrapper",
            func: undefined$1,
          },
        ]

        // Add methods to `LazyWrapper`.
        LazyWrapper.prototype.clone = lazyClone
        LazyWrapper.prototype.reverse = lazyReverse
        LazyWrapper.prototype.value = lazyValue

        // Add chain sequence methods to the `lodash` wrapper.
        lodash.prototype.at = wrapperAt
        lodash.prototype.chain = wrapperChain
        lodash.prototype.commit = wrapperCommit
        lodash.prototype.next = wrapperNext
        lodash.prototype.plant = wrapperPlant
        lodash.prototype.reverse = wrapperReverse
        lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue

        // Add lazy aliases.
        lodash.prototype.first = lodash.prototype.head

        if (symIterator) {
          lodash.prototype[symIterator] = wrapperToIterator
        }
        return lodash
      }

      /*--------------------------------------------------------------------------*/

      // Export lodash.
      var _ = runInContext()

      // Some AMD build optimizers, like r.js, check for condition patterns like:
      if (freeModule) {
        // Export for Node.js.
        ;(freeModule.exports = _)._ = _
        // Export for CommonJS support.
        freeExports._ = _
      } else {
        // Export to the global object.
        root._ = _
      }
    }.call(commonjsGlobal))
  })
  var lodash_1 = lodash.flow
  var lodash_2 = lodash.head
  var lodash_3 = lodash.tail
  var lodash_4 = lodash.findIndex
  var lodash_5 = lodash.startsWith
  var lodash_6 = lodash.dropRight
  var lodash_7 = lodash.takeRight
  var lodash_8 = lodash.trim
  var lodash_9 = lodash.split
  var lodash_10 = lodash.replace
  var lodash_11 = lodash.merge
  var lodash_12 = lodash.assign

  const commonPlus = extra => fp_5(["onBegin", "onComplete", "onError"])(extra)

  const common = () => commonPlus([])

  const _events = {
    recordApi: {
      save: commonPlus(["onInvalid", "onRecordUpdated", "onRecordCreated"]),
      delete: common(),
      getContext: common(),
      getNew: common(),
      load: common(),
      validate: common(),
      uploadFile: common(),
      downloadFile: common(),
    },
    indexApi: {
      buildIndex: common(),
      listItems: common(),
      delete: common(),
      aggregates: common(),
    },
    collectionApi: {
      getAllowedRecordTypes: common(),
      initialise: common(),
      delete: common(),
    },
    authApi: {
      authenticate: common(),
      authenticateTemporaryAccess: common(),
      createTemporaryAccess: common(),
      createUser: common(),
      enableUser: common(),
      disableUser: common(),
      loadAccessLevels: common(),
      getNewAccessLevel: common(),
      getNewUser: common(),
      getNewUserAuth: common(),
      getUsers: common(),
      saveAccessLevels: common(),
      isAuthorized: common(),
      changeMyPassword: common(),
      setPasswordFromTemporaryCode: common(),
      scorePassword: common(),
      isValidPassword: common(),
      validateUser: common(),
      validateAccessLevels: common(),
      setUserAccessLevels: common(),
    },
    templateApi: {
      saveApplicationHierarchy: common(),
      saveActionsAndTriggers: common(),
    },
    actionsApi: {
      execute: common(),
    },
  }

  const _eventsList = []

  const makeEvent = (area, method, name) => `${area}:${method}:${name}`

  for (const areaKey in _events) {
    for (const methodKey in _events[areaKey]) {
      _events[areaKey][methodKey] = fp_6((obj, s) => {
        obj[s] = makeEvent(areaKey, methodKey, s)
        return obj
      }, {})(_events[areaKey][methodKey])
    }
  }

  for (const areaKey in _events) {
    for (const methodKey in _events[areaKey]) {
      for (const name in _events[areaKey][methodKey]) {
        _eventsList.push(_events[areaKey][methodKey][name])
      }
    }
  }

  const events = _events

  // Found this seed-based random generator somewhere
  // Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu)

  var seed = 1

  /**
   * return a random number based on a seed
   * @param seed
   * @returns {number}
   */
  function getNextValue() {
    seed = (seed * 9301 + 49297) % 233280
    return seed / 233280.0
  }

  function setSeed(_seed_) {
    seed = _seed_
  }

  var randomFromSeed = {
    nextValue: getNextValue,
    seed: setSeed,
  }

  var ORIGINAL =
    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"
  var alphabet
  var previousSeed

  var shuffled

  function reset() {
    shuffled = false
  }

  function setCharacters(_alphabet_) {
    if (!_alphabet_) {
      if (alphabet !== ORIGINAL) {
        alphabet = ORIGINAL
        reset()
      }
      return
    }

    if (_alphabet_ === alphabet) {
      return
    }

    if (_alphabet_.length !== ORIGINAL.length) {
      throw new Error(
        "Custom alphabet for shortid must be " +
          ORIGINAL.length +
          " unique characters. You submitted " +
          _alphabet_.length +
          " characters: " +
          _alphabet_
      )
    }

    var unique = _alphabet_.split("").filter(function(item, ind, arr) {
      return ind !== arr.lastIndexOf(item)
    })

    if (unique.length) {
      throw new Error(
        "Custom alphabet for shortid must be " +
          ORIGINAL.length +
          " unique characters. These characters were not unique: " +
          unique.join(", ")
      )
    }

    alphabet = _alphabet_
    reset()
  }

  function characters(_alphabet_) {
    setCharacters(_alphabet_)
    return alphabet
  }

  function setSeed$1(seed) {
    randomFromSeed.seed(seed)
    if (previousSeed !== seed) {
      reset()
      previousSeed = seed
    }
  }

  function shuffle() {
    if (!alphabet) {
      setCharacters(ORIGINAL)
    }

    var sourceArray = alphabet.split("")
    var targetArray = []
    var r = randomFromSeed.nextValue()
    var characterIndex

    while (sourceArray.length > 0) {
      r = randomFromSeed.nextValue()
      characterIndex = Math.floor(r * sourceArray.length)
      targetArray.push(sourceArray.splice(characterIndex, 1)[0])
    }
    return targetArray.join("")
  }

  function getShuffled() {
    if (shuffled) {
      return shuffled
    }
    shuffled = shuffle()
    return shuffled
  }

  /**
   * lookup shuffled letter
   * @param index
   * @returns {string}
   */
  function lookup(index) {
    var alphabetShuffled = getShuffled()
    return alphabetShuffled[index]
  }

  function get() {
    return alphabet || ORIGINAL
  }

  var alphabet_1 = {
    get: get,
    characters: characters,
    seed: setSeed$1,
    lookup: lookup,
    shuffled: getShuffled,
  }

  var crypto = typeof window === "object" && (window.crypto || window.msCrypto) // IE 11 uses window.msCrypto

  var randomByte

  if (!crypto || !crypto.getRandomValues) {
    randomByte = function(size) {
      var bytes = []
      for (var i = 0; i < size; i++) {
        bytes.push(Math.floor(Math.random() * 256))
      }
      return bytes
    }
  } else {
    randomByte = function(size) {
      return crypto.getRandomValues(new Uint8Array(size))
    }
  }

  var randomByteBrowser = randomByte

  /**
   * Secure random string generator with custom alphabet.
   *
   * Alphabet must contain 256 symbols or less. Otherwise, the generator
   * will not be secure.
   *
   * @param {generator} random The random bytes generator.
   * @param {string} alphabet Symbols to be used in new random string.
   * @param {size} size The number of symbols in new random string.
   *
   * @return {string} Random string.
   *
   * @example
   * const format = require('nanoid/format')
   *
   * function random (size) {
   *   const result = []
   *   for (let i = 0; i < size; i++) {
   *     result.push(randomByte())
   *   }
   *   return result
   * }
   *
   * format(random, "abcdef", 5) //=> "fbaef"
   *
   * @name format
   * @function
   */
  var format = function(random, alphabet, size) {
    var mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
    var step = Math.ceil((1.6 * mask * size) / alphabet.length)
    size = +size

    var id = ""
    while (true) {
      var bytes = random(step)
      for (var i = 0; i < step; i++) {
        var byte = bytes[i] & mask
        if (alphabet[byte]) {
          id += alphabet[byte]
          if (id.length === size) return id
        }
      }
    }
  }

  function generate(number) {
    var loopCounter = 0
    var done

    var str = ""

    while (!done) {
      str = str + format(randomByteBrowser, alphabet_1.get(), 1)
      done = number < Math.pow(16, loopCounter + 1)
      loopCounter++
    }
    return str
  }

  var generate_1 = generate

  // Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness.
  // This number should be updated every year or so to keep the generated id short.
  // To regenerate `new Date() - 0` and bump the version. Always bump the version!
  var REDUCE_TIME = 1567752802062

  // don't change unless we change the algos or REDUCE_TIME
  // must be an integer and less than 16
  var version = 7

  // Counter is used when shortid is called multiple times in one second.
  var counter

  // Remember the last time shortid was called in case counter is needed.
  var previousSeconds

  /**
   * Generate unique id
   * Returns string id
   */
  function build(clusterWorkerId) {
    var str = ""

    var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001)

    if (seconds === previousSeconds) {
      counter++
    } else {
      counter = 0
      previousSeconds = seconds
    }

    str = str + generate_1(version)
    str = str + generate_1(clusterWorkerId)
    if (counter > 0) {
      str = str + generate_1(counter)
    }
    str = str + generate_1(seconds)
    return str
  }

  var build_1 = build

  function isShortId(id) {
    if (!id || typeof id !== "string" || id.length < 6) {
      return false
    }

    var nonAlphabetic = new RegExp(
      "[^" + alphabet_1.get().replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&") + "]"
    )
    return !nonAlphabetic.test(id)
  }

  var isValid = isShortId

  var lib = createCommonjsModule(function(module) {
    // if you are using cluster or multiple servers use this to make each instance
    // has a unique value for worker
    // Note: I don't know if this is automatically set when using third
    // party cluster solutions such as pm2.
    var clusterWorkerId = 0

    /**
     * Set the seed.
     * Highly recommended if you don't want people to try to figure out your id schema.
     * exposed as shortid.seed(int)
     * @param seed Integer value to seed the random alphabet.  ALWAYS USE THE SAME SEED or you might get overlaps.
     */
    function seed(seedValue) {
      alphabet_1.seed(seedValue)
      return module.exports
    }

    /**
     * Set the cluster worker or machine id
     * exposed as shortid.worker(int)
     * @param workerId worker must be positive integer.  Number less than 16 is recommended.
     * returns shortid module so it can be chained.
     */
    function worker(workerId) {
      clusterWorkerId = workerId
      return module.exports
    }

    /**
     *
     * sets new characters to use in the alphabet
     * returns the shuffled alphabet
     */
    function characters(newCharacters) {
      if (newCharacters !== undefined) {
        alphabet_1.characters(newCharacters)
      }

      return alphabet_1.shuffled()
    }

    /**
     * Generate unique id
     * Returns string id
     */
    function generate() {
      return build_1(clusterWorkerId)
    }

    // Export all other functions as properties of the generate function
    module.exports = generate
    module.exports.generate = generate
    module.exports.seed = seed
    module.exports.worker = worker
    module.exports.characters = characters
    module.exports.isValid = isValid
  })
  var lib_1 = lib.generate
  var lib_2 = lib.seed
  var lib_3 = lib.worker
  var lib_4 = lib.characters
  var lib_5 = lib.isValid

  var shortid = lib
  var shortid_1 = shortid.generate

  class BadRequestError extends Error {
    constructor(message) {
      super(message)
      this.httpStatusCode = 400
    }
  }

  class UnauthorisedError extends Error {
    constructor(message) {
      super(message)
      this.httpStatusCode = 401
    }
  }

  const apiWrapperSync = (
    app,
    eventNamespace,
    isAuthorized,
    eventContext,
    func,
    ...params
  ) => {
    pushCallStack(app, eventNamespace)

    if (!isAuthorized(app)) {
      handleNotAuthorized(app, eventContext, eventNamespace)
      return
    }

    const startDate = Date.now()
    const elapsed = () => Date.now() - startDate

    try {
      app.publish(eventNamespace.onBegin, eventContext)

      const result = func(...params)

      publishComplete(app, eventContext, eventNamespace, elapsed, result)
      return result
    } catch (error) {
      publishError(app, eventContext, eventNamespace, elapsed, error)
      throw error
    }
  }

  const handleNotAuthorized = (app, eventContext, eventNamespace) => {
    const err = new UnauthorisedError(`Unauthorized: ${eventNamespace}`)
    publishError(app, eventContext, eventNamespace, () => 0, err)
    throw err
  }

  const pushCallStack = (app, eventNamespace, seedCallId) => {
    const callId = shortid_1()

    const createCallStack = () => ({
      seedCallId: !fp_2(seedCallId) ? seedCallId : callId,
      threadCallId: callId,
      stack: [],
    })

    if (fp_2(app.calls)) {
      app.calls = createCallStack()
    }

    app.calls.stack.push({
      namespace: eventNamespace,
      callId,
    })
  }

  const popCallStack = app => {
    app.calls.stack.pop()
    if (app.calls.stack.length === 0) {
      delete app.calls
    }
  }

  const publishError = async (
    app,
    eventContext,
    eventNamespace,
    elapsed,
    err
  ) => {
    const ctx = fp_8(eventContext)
    ctx.error = err
    ctx.elapsed = elapsed()
    await app.publish(eventNamespace.onError, ctx)
    popCallStack(app)
  }

  const publishComplete = async (
    app,
    eventContext,
    eventNamespace,
    elapsed,
    result
  ) => {
    const endcontext = fp_8(eventContext)
    endcontext.result = result
    endcontext.elapsed = elapsed()
    await app.publish(eventNamespace.onComplete, endcontext)
    popCallStack(app)
    return result
  }

  // this is the combinator function
  const $$ = (...funcs) => arg => lodash_1(funcs)(arg)

  // this is the pipe function
  const $ = (arg, funcs) => $$(...funcs)(arg)

  const keySep = "/"
  const trimKeySep = str => lodash_8(str, keySep)
  const splitByKeySep = str => fp_3(keySep)(str)
  const safeKey = key =>
    lodash_10(`${keySep}${trimKeySep(key)}`, `${keySep}${keySep}`, keySep)
  const joinKey = (...strs) => {
    const paramsOrArray = (strs.length === 1) & fp_10(strs[0]) ? strs[0] : strs
    return safeKey(fp_17(keySep)(paramsOrArray))
  }
  const splitKey = $$(trimKeySep, splitByKeySep)

  const configFolder = `${keySep}.config`
  const fieldDefinitions = joinKey(configFolder, "fields.json")
  const templateDefinitions = joinKey(configFolder, "templates.json")
  const appDefinitionFile = joinKey(configFolder, "appDefinition.json")

  const not = func => val => !func(val)
  const isDefined = not(fp_2)
  const isNonNull = not(fp_28)
  const isNotNaN = not(fp_35)

  const allTrue = (...funcArgs) => val =>
    fp_6(
      (result, conditionFunc) =>
        (fp_28(result) || result == true) && conditionFunc(val),
      null
    )(funcArgs)

  const isSomething = allTrue(isDefined, isNonNull, isNotNaN)
  const isNothing = not(isSomething)

  const none = predicate => collection => !fp_9(predicate)(collection)

  const all = predicate => collection => none(v => !predicate(v))(collection)

  const isNotEmpty = ob => !fp_15(ob)
  const isNonEmptyString = allTrue(fp_26, isNotEmpty)
  const tryOr = failFunc => (func, ...args) => {
    try {
      return func.apply(null, ...args)
    } catch (_) {
      return failFunc()
    }
  }
  const causesException = func => {
    try {
      func()
      return false
    } catch (e) {
      return true
    }
  }

  const executesWithoutException = func => !causesException(func)

  const handleErrorWith = returnValInError => tryOr(fp_20(returnValInError))

  const handleErrorWithUndefined = handleErrorWith(undefined)

  const switchCase = (...cases) => value => {
    const nextCase = () => lodash_2(cases)[0](value)
    const nextResult = () => lodash_2(cases)[1](value)

    if (fp_15(cases)) return // undefined
    if (nextCase() === true) return nextResult()
    return switchCase(...lodash_3(cases))(value)
  }
  const isOneOf = (...vals) => val => fp_18(val)(vals)
  const defaultCase = fp_20(true)

  const isSafeInteger = n =>
    fp_36(n) && n <= Number.MAX_SAFE_INTEGER && n >= 0 - Number.MAX_SAFE_INTEGER

  const toDateOrNull = s => (fp_28(s) ? null : fp_31(s) ? s : new Date(s))
  const toBoolOrNull = s => (fp_28(s) ? null : s === "true" || s === true)
  const toNumberOrNull = s => (fp_28(s) ? null : fp_37(s))

  const isArrayOfString = opts => fp_10(opts) && all(fp_26)(opts)

  const setState = (store, path, value) => {
    if (!path || path.length === 0) return

    const pathParts = path.split(".")
    const safeSetPath = (obj, currentPartIndex = 0) => {
      const currentKey = pathParts[currentPartIndex]

      if (pathParts.length - 1 == currentPartIndex) {
        obj[currentKey] = value
        return
      }

      if (
        obj[currentKey] === null ||
        obj[currentKey] === undefined ||
        !fp_7(obj.currentKey)
      ) {
        obj[currentKey] = {}
      }

      safeSetPath(obj[currentKey], currentPartIndex + 1)
    }

    store.update(s => {
      safeSetPath(s)
      return s
    })
  }

  const BB_STATE_BINDINGPATH = "##bbstate"
  const BB_STATE_BINDINGSOURCE = "##bbsource"
  const BB_STATE_FALLBACK = "##bbstatefallback"

  const isBound = prop => prop[BB_STATE_BINDINGPATH] !== undefined
  const takeStateFromStore = prop =>
    prop[BB_STATE_BINDINGSOURCE] === undefined ||
    prop[BB_STATE_BINDINGSOURCE] === "store"

  const takeStateFromContext = prop =>
    prop[BB_STATE_BINDINGSOURCE] === "context"

  const takeStateFromEventParameters = prop =>
    prop[BB_STATE_BINDINGSOURCE] === "event"

  const getState = (s, path, fallback) => {
    if (!path || path.length === 0) return fallback

    const pathParts = path.split(".")
    const safeGetPath = (obj, currentPartIndex = 0) => {
      const currentKey = pathParts[currentPartIndex]

      if (pathParts.length - 1 == currentPartIndex) {
        const value = obj[currentKey]
        if (fp_2(value)) return fallback
        else return value
      }

      if (
        obj[currentKey] === null ||
        obj[currentKey] === undefined ||
        !fp_7(obj[currentKey])
      ) {
        return fallback
      }

      return safeGetPath(obj[currentKey], currentPartIndex + 1)
    }

    return safeGetPath(s)
  }

  const getStateOrValue = (globalState, prop, currentContext) => {
    if (!isBound(prop)) return prop

    const stateToUse = takeStateFromStore(prop) ? globalState : currentContext

    return getState(
      stateToUse,
      prop[BB_STATE_BINDINGPATH],
      prop[BB_STATE_FALLBACK]
    )
  }

  const ERROR = "##error_message"

  const trimSlash = str => str.replace(/^\/+|\/+$/g, "")

  const loadRecord = api => async ({ recordKey, statePath }) => {
    if (!recordKey) {
      api.error("Load Record: record key not set")
      return
    }

    if (!statePath) {
      api.error("Load Record: state path not set")
      return
    }

    const record = await api.get({
      url: `/api/record/${trimSlash(key)}`,
    })

    if (api.isSuccess(record)) api.setState(statePath, record)
  }

  const listRecords = api => async ({ indexKey, statePath }) => {
    if (!indexKey) {
      api.error("Load Record: record key not set")
      return
    }

    if (!statePath) {
      api.error("Load Record: state path not set")
      return
    }

    const records = api.get({
      url: `/api/listRecords/${trimSlash(indexKey)}`,
    })

    if (api.isSuccess(records)) api.setState(statePath, records)
  }

  const USER_STATE_PATH = "_bbuser"

  const authenticate = api => async ({ username, password }) => {
    if (!username) {
      api.error("Authenticate: username not set")
      return
    }

    if (!password) {
      api.error("Authenticate: password not set")
      return
    }

    const user = await api.post({
      url: "/api/authenticate",
      body: { username, password },
    })

    // set user even if error - so it is defined at least
    api.setState(USER_STATE_PATH, user)
    localStorage.setItem("budibase:user", user)
  }

  const createApi = ({ rootPath, setState, getState }) => {
    const apiCall = method => ({
      url,
      body,
      notFound,
      badRequest,
      forbidden,
    }) => {
      fetch(`${rootPath}${url}`, {
        method: method,
        headers: {
          "Content-Type": "application/json",
        },
        body: body && JSON.stringify(body),
        credentials: "same-origin",
      }).then(r => {
        switch (r.status) {
          case 200:
            return r.json()
          case 404:
            return error(notFound || `${url} Not found`)
          case 400:
            return error(badRequest || `${url} Bad Request`)
          case 403:
            return error(forbidden || `${url} Forbidden`)
          default:
            if (
              r.status.toString().startsWith("2") ||
              r.status.toString().startsWith("3")
            )
              return r.json()
            else return error(`${url} - ${r.statusText}`)
        }
      })
    }

    const post = apiCall("POST")
    const get = apiCall("GET")
    const patch = apiCall("PATCH")
    const del = apiCall("DELETE")

    const ERROR_MEMBER = "##error"
    const error = message => {
      const e = {}
      e[ERROR_MEMBER] = message
      setState(ERROR, message)
      return e
    }

    const isSuccess = obj => !!obj[ERROR_MEMBER]

    const apiOpts = {
      rootPath,
      setState,
      getState,
      isSuccess,
      error,
      post,
      get,
      patch,
      delete: del,
    }

    return {
      loadRecord: loadRecord(apiOpts),
      listRecords: listRecords(apiOpts),
      authenticate: authenticate(apiOpts),
    }
  }

  const getNewChildRecordToState = (store, coreApi, setState) => ({
    recordKey,
    collectionName,
    childRecordType,
    statePath,
  }) => {
    const error = errorHandler(setState)
    try {
      if (!recordKey) {
        error("getNewChild > recordKey not set")
        return
      }

      if (!collectionName) {
        error("getNewChild > collectionName not set")
        return
      }

      if (!childRecordType) {
        error("getNewChild > childRecordType not set")
        return
      }

      if (!statePath) {
        error("getNewChild > statePath not set")
        return
      }

      const rec = coreApi.recordApi.getNewChild(
        recordKey,
        collectionName,
        childRecordType
      )
      setState(store, statePath, rec)
    } catch (e) {
      error(e.message)
    }
  }

  const getNewRecordToState = (store, coreApi, setState) => ({
    collectionKey,
    childRecordType,
    statePath,
  }) => {
    const error = errorHandler(setState)
    try {
      if (!collectionKey) {
        error("getNewChild > collectionKey not set")
        return
      }

      if (!childRecordType) {
        error("getNewChild > childRecordType not set")
        return
      }

      if (!statePath) {
        error("getNewChild > statePath not set")
        return
      }

      const rec = coreApi.recordApi.getNew(collectionKey, childRecordType)
      setState(store, statePath, rec)
    } catch (e) {
      error(e.message)
    }
  }

  const errorHandler = setState => message => setState(ERROR, message)

  const EVENT_TYPE_MEMBER_NAME = "##eventHandlerType"

  const eventHandlers = (store, coreApi, rootPath) => {
    const handler = (parameters, execute) => ({
      execute,
      parameters,
    })

    const setStateWithStore = (path, value) => setState(store, path, value)

    const api = createApi({
      rootPath: rootPath,
      setState: (path, value) => setStateWithStore,
      getState: (path, fallback) => getState(store, path, fallback),
    })

    const setStateHandler = ({ path, value }) => setState(store, path, value)

    return {
      "Set State": handler(["path", "value"], setStateHandler),
      "Load Record": handler(["recordKey", "statePath"], api.loadRecord),
      "List Records": handler(["indexKey", "statePath"], api.listRecords),
      "Save Record": handler(["statePath"], api.saveRecord),

      "Get New Child Record": handler(
        ["recordKey", "collectionName", "childRecordType", "statePath"],
        getNewChildRecordToState(store, coreApi, setStateWithStore)
      ),

      "Get New Record": handler(
        ["collectionKey", "childRecordType", "statePath"],
        getNewRecordToState(store, coreApi, setStateWithStore)
      ),

      Authenticate: handler(["username", "password"], api.authenticate),
    }
  }

  const isEventType = prop =>
    fp_10(prop) && prop.length > 0 && !fp_2(prop[0][EVENT_TYPE_MEMBER_NAME])

  const doNothing = () => {}
  doNothing.isPlaceholder = true

  const setupBinding = (store, rootProps, coreApi, context, rootPath) => {
    const rootInitialProps = { ...rootProps }

    const getBindings = (props, initialProps) => {
      const boundProps = []
      const componentEventHandlers = []
      const boundArrays = []

      for (let propName in props) {
        if (propName === "_component") continue

        const val = initialProps[propName]

        if (isBound(val) && takeStateFromStore(val)) {
          const binding = stateBinding(val)
          const fallback = stateFallback(val)

          boundProps.push({
            stateBinding: binding,
            fallback,
            propName,
          })

          initialProps[propName] = fallback
        } else if (isBound(val) && takeStateFromContext(val)) {
          const binding = stateBinding(val)
          const fallback = stateFallback(val)

          initialProps[propName] = getState(context || {}, binding, fallback)
        } else if (isEventType(val)) {
          const handlers = { propName, handlers: [] }
          componentEventHandlers.push(handlers)

          for (let e of val) {
            handlers.handlers.push({
              handlerType: e[EVENT_TYPE_MEMBER_NAME],
              parameters: e.parameters,
            })
          }

          initialProps[propName] = doNothing
        } else if (Array.isArray(val)) {
          const arrayOfBindings = []
          for (let element of val) {
            arrayOfBindings.push(getBindings(element, { ...element }))
          }

          boundArrays.push({
            arrayOfBindings,
            propName,
          })
        }
      }

      return { boundProps, componentEventHandlers, boundArrays, initialProps }
    }

    const bind = rootBindings => component => {
      if (
        rootBindings.boundProps.length === 0 &&
        rootBindings.componentEventHandlers.length === 0 &&
        rootBindings.boundArrays.length === 0
      )
        return

      const handlerTypes = eventHandlers(store, coreApi, rootPath)

      const unsubscribe = store.subscribe(rootState => {
        const getPropsFromBindings = (s, bindings) => {
          const { boundProps, componentEventHandlers, boundArrays } = bindings
          const newProps = { ...bindings.initialProps }

          for (let boundProp of boundProps) {
            const val = getState(s, boundProp.stateBinding, boundProp.fallback)

            if (
              val === undefined &&
              newProps[boundProp.propName] !== undefined
            ) {
              delete newProps[boundProp.propName]
            }

            if (val !== undefined) {
              newProps[boundProp.propName] = val
            }
          }

          for (let boundHandler of componentEventHandlers) {
            const closuredHandlers = []
            for (let h of boundHandler.handlers) {
              const handlerType = handlerTypes[h.handlerType]
              closuredHandlers.push(eventContext => {
                const parameters = {}
                for (let pname in h.parameters) {
                  const p = h.parameters[pname]
                  parameters[pname] = !isBound(p)
                    ? p
                    : takeStateFromStore(p)
                    ? getState(s, p[BB_STATE_BINDINGPATH], p[BB_STATE_FALLBACK])
                    : takeStateFromEventParameters(p)
                    ? getState(
                        eventContext,
                        p[BB_STATE_BINDINGPATH],
                        p[BB_STATE_FALLBACK]
                      )
                    : takeStateFromContext(p)
                    ? getState(
                        context,
                        p[BB_STATE_BINDINGPATH],
                        p[BB_STATE_FALLBACK]
                      )
                    : p[BB_STATE_FALLBACK]
                }
                handlerType.execute(parameters)
              })
            }

            newProps[boundHandler.propName] = async context => {
              for (let runHandler of closuredHandlers) {
                await runHandler(context)
              }
            }
          }

          for (let boundArray of boundArrays) {
            let index = 0
            if (!newProps[boundArray.propName])
              newProps[boundArray.propName] = []
            for (let bindings of boundArray.arrayOfBindings) {
              newProps[boundArray.propName][index] = getPropsFromBindings(
                s,
                bindings
              )
              index++
            }
          }

          return newProps
        }

        const rootNewProps = getPropsFromBindings(rootState, rootBindings)

        component.$set(rootNewProps)
      })

      return unsubscribe
    }

    const bindings = getBindings(rootProps, rootInitialProps)

    return {
      initialProps: rootInitialProps,
      bind: bind(bindings),
    }
  }

  const stateBinding = prop => prop[BB_STATE_BINDINGPATH]
  const stateFallback = prop => prop[BB_STATE_FALLBACK]

  const createCoreApp = (appDefinition, user) => {
    const app = {
      datastore: null,
      crypto: null,
      publish: () => {},
      hierarchy: appDefinition.hierarchy,
      actions: appDefinition.actions,
      user,
    }

    return app
  }

  const makerule = (field, error, isValid) => ({ field, error, isValid })

  var filters = new Map()
  var limiters = new Map()

  function compileRawExpression(src) {
    return new Function(
      "context",
      "tempVars", // eslint-disable-line
      "const sandbox = $nxCompileToSandbox(context, tempVars)\n    try { with (sandbox) { return " +
        src +
        " } } catch (err) {\n      if (!(err instanceof TypeError)) throw err\n    }\n    $nxClearSandbox()"
    )
  }

  function compileRawCode(src) {
    return new Function(
      "context",
      "tempVars", // eslint-disable-line
      "const sandbox = $nxCompileToSandbox(context, tempVars)\n    with (sandbox) { " +
        src +
        " }\n    $nxClearSandbox()"
    )
  }

  var filterRegex = /(?:[^\|]|\|\|)+/g
  var limiterRegex = /(?:[^&]|&&)+/g
  var argsRegex = /\S+/g

  function parseExpression(src) {
    var tokens = src.match(filterRegex)
    if (tokens.length === 1) {
      return compileRawExpression(tokens[0])
    }

    var expression = {
      exec: compileRawExpression(tokens[0]),
      filters: [],
    }
    for (var i = 1; i < tokens.length; i++) {
      var filterTokens = tokens[i].match(argsRegex)
      var filterName = filterTokens.shift()
      var effect = filters.get(filterName)
      if (!effect) {
        throw new Error("There is no filter named: " + filterName + ".")
      }
      expression.filters.push({
        effect: effect,
        argExpressions: filterTokens.map(compileRawExpression),
      })
    }
    return expression
  }

  function parseCode(src) {
    var tokens = src.match(limiterRegex)
    if (tokens.length === 1) {
      return compileRawCode(tokens[0])
    }

    var code = {
      exec: compileRawCode(tokens[0]),
      limiters: [],
    }
    for (var i = 1; i < tokens.length; i++) {
      var limiterTokens = tokens[i].match(argsRegex)
      var limiterName = limiterTokens.shift()
      var effect = limiters.get(limiterName)
      if (!effect) {
        throw new Error("There is no limiter named: " + limiterName + ".")
      }
      code.limiters.push({
        effect: effect,
        argExpressions: limiterTokens.map(compileRawExpression),
      })
    }
    return code
  }

  var expressionCache = new Map()
  var codeCache = new Map()

  function compileExpression(src) {
    if (typeof src !== "string") {
      throw new TypeError("First argument must be a string.")
    }
    var expression = expressionCache.get(src)
    if (!expression) {
      expression = parseExpression(src)
      expressionCache.set(src, expression)
    }

    if (typeof expression === "function") {
      return expression
    }

    return function evaluateExpression(context, tempVars) {
      var value = expression.exec(context, tempVars)
      for (var i = 0, list = expression.filters; i < list.length; i += 1) {
        var filter = list[i]

        var args = filter.argExpressions.map(evaluateArgExpression, context)
        value = filter.effect.apply(filter, [value].concat(args))
      }
      return value
    }
  }

  function compileCode(src) {
    if (typeof src !== "string") {
      throw new TypeError("First argument must be a string.")
    }
    var code = codeCache.get(src)
    if (!code) {
      code = parseCode(src)
      codeCache.set(src, code)
    }

    if (typeof code === "function") {
      return code
    }

    var context = {}
    return function evaluateCode(state, tempVars) {
      var i = 0
      function next() {
        Object.assign(context, tempVars)
        if (i < code.limiters.length) {
          var limiter = code.limiters[i++]
          var args = limiter.argExpressions.map(evaluateArgExpression, state)
          limiter.effect.apply(limiter, [next, context].concat(args))
        } else {
          code.exec(state, tempVars)
        }
      }
      next()
    }
  }

  function evaluateArgExpression(argExpression) {
    return argExpression(this)
  }

  var hasHandler = { has: has }
  var allHandlers = { has: has, get: get$1 }
  var globals$1 = new Set()
  var temp

  var globalObj
  if (typeof window !== "undefined") {
    globalObj = window
  } // eslint-disable-line
  else if (typeof global !== "undefined") {
    globalObj = global
  } // eslint-disable-line
  else if (typeof self !== "undefined") {
    globalObj = self
  } // eslint-disable-line
  globalObj.$nxCompileToSandbox = toSandbox
  globalObj.$nxClearSandbox = clearSandbox

  function has(target, key) {
    return globals$1.has(key) ? key in target : true
  }

  function get$1(target, key) {
    return key in temp ? temp[key] : target[key]
  }

  function toSandbox(obj, tempVars) {
    if (tempVars) {
      temp = tempVars
      return new Proxy(obj, allHandlers)
    }
    return new Proxy(obj, hasHandler)
  }

  function clearSandbox() {
    temp = undefined
  }

  const compileFilter = index => compileExpression(index.filter)

  const compileMap = index => compileCode(index.map)

  const indexTypes = { reference: "reference", ancestor: "ancestor" }

  const indexRuleSet = [
    makerule("map", "index has no map function", index =>
      isNonEmptyString(index.map)
    ),
    makerule(
      "map",
      "index's map function does not compile",
      index =>
        !isNonEmptyString(index.map) ||
        executesWithoutException(() => compileMap(index))
    ),
    makerule(
      "filter",
      "index's filter function does not compile",
      index =>
        !isNonEmptyString(index.filter) ||
        executesWithoutException(() => compileFilter(index))
    ),
    makerule("name", "must declare a name for index", index =>
      isNonEmptyString(index.name)
    ),
    makerule(
      "name",
      "there is a duplicate named index on this node",
      index =>
        fp_15(index.name) ||
        fp_16("name")(index.parent().indexes)[index.name] === 1
    ),
    makerule(
      "indexType",
      "reference index may only exist on a record node",
      index =>
        isRecord(index.parent()) || index.indexType !== indexTypes.reference
    ),
    makerule(
      "indexType",
      `index type must be one of: ${fp_17(", ")(fp_13(indexTypes))}`,
      index => fp_18(index.indexType)(fp_13(indexTypes))
    ),
  ]

  const getFlattenedHierarchy = (appHierarchy, useCached = true) => {
    if (isSomething(appHierarchy.getFlattenedHierarchy) && useCached) {
      return appHierarchy.getFlattenedHierarchy()
    }

    const flattenHierarchy = (currentNode, flattened) => {
      flattened.push(currentNode)
      if (
        (!currentNode.children || currentNode.children.length === 0) &&
        (!currentNode.indexes || currentNode.indexes.length === 0) &&
        (!currentNode.aggregateGroups ||
          currentNode.aggregateGroups.length === 0)
      ) {
        return flattened
      }

      const unionIfAny = l2 => l1 => fp_5(l1)(!l2 ? [] : l2)

      const children = $(
        [],
        [
          unionIfAny(currentNode.children),
          unionIfAny(currentNode.indexes),
          unionIfAny(currentNode.aggregateGroups),
        ]
      )

      for (const child of children) {
        flattenHierarchy(child, flattened)
      }
      return flattened
    }

    appHierarchy.getFlattenedHierarchy = () =>
      flattenHierarchy(appHierarchy, [])
    return appHierarchy.getFlattenedHierarchy()
  }

  const getExactNodeForPath = appHierarchy => key =>
    $(appHierarchy, [
      getFlattenedHierarchy,
      fp_1(n => new RegExp(`${n.pathRegx()}$`).test(key)),
    ])

  const getNodeForCollectionPath = appHierarchy => collectionKey =>
    $(appHierarchy, [
      getFlattenedHierarchy,
      fp_1(
        n =>
          isCollectionRecord(n) &&
          new RegExp(`${n.collectionPathRegx()}$`).test(collectionKey)
      ),
    ])

  const getNode = (appHierarchy, nodeKey) =>
    $(appHierarchy, [
      getFlattenedHierarchy,
      fp_1(
        n =>
          n.nodeKey() === nodeKey ||
          (isCollectionRecord(n) && n.collectionNodeKey() === nodeKey)
      ),
    ])

  const getNodeByKeyOrNodeKey = (appHierarchy, keyOrNodeKey) => {
    const nodeByKey = getExactNodeForPath(appHierarchy)(keyOrNodeKey)
    return isNothing(nodeByKey)
      ? getNode(appHierarchy, keyOrNodeKey)
      : nodeByKey
  }

  const isNode = (appHierarchy, key) =>
    isSomething(getExactNodeForPath(appHierarchy)(key))

  const isRecord = node => isSomething(node) && node.type === "record"
  const isCollectionRecord = node => isRecord(node) && !node.isSingle

  const getSafeFieldParser = (tryParse, defaultValueFunctions) => (
    field,
    record
  ) => {
    if (fp_24(field.name)(record)) {
      return getSafeValueParser(
        tryParse,
        defaultValueFunctions
      )(record[field.name])
    }
    return defaultValueFunctions[field.getUndefinedValue]()
  }

  const getSafeValueParser = (tryParse, defaultValueFunctions) => value => {
    const parsed = tryParse(value)
    if (parsed.success) {
      return parsed.value
    }
    return defaultValueFunctions.default()
  }

  const getNewValue = (tryParse, defaultValueFunctions) => field => {
    const getInitialValue =
      fp_2(field) || fp_2(field.getInitialValue)
        ? "default"
        : field.getInitialValue

    return fp_24(getInitialValue)(defaultValueFunctions)
      ? defaultValueFunctions[getInitialValue]()
      : getSafeValueParser(tryParse, defaultValueFunctions)(getInitialValue)
  }

  const typeFunctions = specificFunctions =>
    lodash_11(
      {
        value: fp_20,
        null: fp_20(null),
      },
      specificFunctions
    )

  const validateTypeConstraints = validationRules => async (
    field,
    record,
    context
  ) => {
    const fieldValue = record[field.name]
    const validateRule = async r =>
      !(await r.isValid(fieldValue, field.typeOptions, context))
        ? r.getMessage(fieldValue, field.typeOptions)
        : ""

    const errors = []
    for (const r of validationRules) {
      const err = await validateRule(r)
      if (isNotEmpty(err)) errors.push(err)
    }

    return errors
  }

  const getDefaultOptions = fp_25(v => v.defaultValue)

  const makerule$1 = (isValid, getMessage) => ({ isValid, getMessage })
  const parsedFailed = val => ({ success: false, value: val })
  const parsedSuccess = val => ({ success: true, value: val })
  const getDefaultExport = (
    name,
    tryParse,
    functions,
    options,
    validationRules,
    sampleValue,
    stringify
  ) => ({
    getNew: getNewValue(tryParse, functions),
    safeParseField: getSafeFieldParser(tryParse, functions),
    safeParseValue: getSafeValueParser(tryParse, functions),
    tryParse,
    name,
    getDefaultOptions: () => getDefaultOptions(fp_8(options)),
    optionDefinitions: options,
    validateTypeConstraints: validateTypeConstraints(validationRules),
    sampleValue,
    stringify: val => (val === null || val === undefined ? "" : stringify(val)),
    getDefaultValue: functions.default,
  })

  const stringFunctions = typeFunctions({
    default: fp_20(null),
  })

  const stringTryParse = switchCase(
    [fp_26, parsedSuccess],
    [fp_28, parsedSuccess],
    [defaultCase, v => parsedSuccess(v.toString())]
  )

  const options = {
    maxLength: {
      defaultValue: null,
      isValid: n => n === null || (isSafeInteger(n) && n > 0),
      requirementDescription:
        "max length must be null (no limit) or a greater than zero integer",
      parse: toNumberOrNull,
    },
    values: {
      defaultValue: null,
      isValid: v =>
        v === null || (isArrayOfString(v) && v.length > 0 && v.length < 10000),
      requirementDescription:
        "'values' must be null (no values) or an arry of at least one string",
      parse: s => s,
    },
    allowDeclaredValuesOnly: {
      defaultValue: false,
      isValid: fp_27,
      requirementDescription: "allowDeclaredValuesOnly must be true or false",
      parse: toBoolOrNull,
    },
  }

  const typeConstraints = [
    makerule$1(
      async (val, opts) =>
        val === null || opts.maxLength === null || val.length <= opts.maxLength,
      (val, opts) => `value exceeds maximum length of ${opts.maxLength}`
    ),
    makerule$1(
      async (val, opts) =>
        val === null ||
        opts.allowDeclaredValuesOnly === false ||
        fp_18(val)(opts.values),
      val => `"${val}" does not exist in the list of allowed values`
    ),
  ]

  var string = getDefaultExport(
    "string",
    stringTryParse,
    stringFunctions,
    options,
    typeConstraints,
    "abcde",
    str => str
  )

  const boolFunctions = typeFunctions({
    default: fp_20(null),
  })

  const boolTryParse = switchCase(
    [fp_27, parsedSuccess],
    [fp_28, parsedSuccess],
    [isOneOf("true", "1", "yes", "on"), () => parsedSuccess(true)],
    [isOneOf("false", "0", "no", "off"), () => parsedSuccess(false)],
    [defaultCase, parsedFailed]
  )

  const options$1 = {
    allowNulls: {
      defaultValue: true,
      isValid: fp_27,
      requirementDescription: "must be a true or false",
      parse: toBoolOrNull,
    },
  }

  const typeConstraints$1 = [
    makerule$1(
      async (val, opts) => opts.allowNulls === true || val !== null,
      () => "field cannot be null"
    ),
  ]

  var bool = getDefaultExport(
    "bool",
    boolTryParse,
    boolFunctions,
    options$1,
    typeConstraints$1,
    true,
    JSON.stringify
  )

  const numberFunctions = typeFunctions({
    default: fp_20(null),
  })

  const parseStringtoNumberOrNull = s => {
    const num = Number(s)
    return isNaN(num) ? parsedFailed(s) : parsedSuccess(num)
  }

  const numberTryParse = switchCase(
    [fp_29, parsedSuccess],
    [fp_26, parseStringtoNumberOrNull],
    [fp_28, parsedSuccess],
    [defaultCase, parsedFailed]
  )

  const options$2 = {
    maxValue: {
      defaultValue: Number.MAX_SAFE_INTEGER,
      isValid: isSafeInteger,
      requirementDescription: "must be a valid integer",
      parse: toNumberOrNull,
    },
    minValue: {
      defaultValue: 0 - Number.MAX_SAFE_INTEGER,
      isValid: isSafeInteger,
      requirementDescription: "must be a valid integer",
      parse: toNumberOrNull,
    },
    decimalPlaces: {
      defaultValue: 0,
      isValid: n => isSafeInteger(n) && n >= 0,
      requirementDescription: "must be a positive integer",
      parse: toNumberOrNull,
    },
  }

  const getDecimalPlaces = val => {
    const splitDecimal = val.toString().split(".")
    if (splitDecimal.length === 1) return 0
    return splitDecimal[1].length
  }

  const typeConstraints$2 = [
    makerule$1(
      async (val, opts) =>
        val === null || opts.minValue === null || val >= opts.minValue,
      (val, opts) =>
        `value (${val.toString()}) must be greater than or equal to ${
          opts.minValue
        }`
    ),
    makerule$1(
      async (val, opts) =>
        val === null || opts.maxValue === null || val <= opts.maxValue,
      (val, opts) =>
        `value (${val.toString()}) must be less than or equal to ${
          opts.minValue
        } options`
    ),
    makerule$1(
      async (val, opts) =>
        val === null || opts.decimalPlaces >= getDecimalPlaces(val),
      (val, opts) =>
        `value (${val.toString()}) must have ${
          opts.decimalPlaces
        } decimal places or less`
    ),
  ]

  var number = getDefaultExport(
    "number",
    numberTryParse,
    numberFunctions,
    options$2,
    typeConstraints$2,
    1,
    num => num.toString()
  )

  const dateFunctions = typeFunctions({
    default: fp_20(null),
    now: () => new Date(),
  })

  const isValidDate = d => d instanceof Date && !isNaN(d)

  const parseStringToDate = s =>
    switchCase(
      [isValidDate, parsedSuccess],
      [defaultCase, parsedFailed]
    )(new Date(s))

  const dateTryParse = switchCase(
    [fp_31, parsedSuccess],
    [fp_26, parseStringToDate],
    [fp_28, parsedSuccess],
    [defaultCase, parsedFailed]
  )

  const options$3 = {
    maxValue: {
      defaultValue: new Date(32503680000000),
      isValid: fp_31,
      requirementDescription: "must be a valid date",
      parse: toDateOrNull,
    },
    minValue: {
      defaultValue: new Date(-8520336000000),
      isValid: fp_31,
      requirementDescription: "must be a valid date",
      parse: toDateOrNull,
    },
  }

  const typeConstraints$3 = [
    makerule$1(
      async (val, opts) =>
        val === null || opts.minValue === null || val >= opts.minValue,
      (val, opts) =>
        `value (${val.toString()}) must be greater than or equal to ${
          opts.minValue
        }`
    ),
    makerule$1(
      async (val, opts) =>
        val === null || opts.maxValue === null || val <= opts.maxValue,
      (val, opts) =>
        `value (${val.toString()}) must be less than or equal to ${
          opts.minValue
        } options`
    ),
  ]

  var datetime = getDefaultExport(
    "datetime",
    dateTryParse,
    dateFunctions,
    options$3,
    typeConstraints$3,
    new Date(1984, 4, 1),
    date => JSON.stringify(date).replace(new RegExp('"', "g"), "")
  )

  const arrayFunctions = () =>
    typeFunctions({
      default: fp_20([]),
    })

  const mapToParsedArrary = type =>
    $$(
      fp_11(i => type.safeParseValue(i)),
      parsedSuccess
    )

  const arrayTryParse = type =>
    switchCase([fp_10, mapToParsedArrary(type)], [defaultCase, parsedFailed])

  const typeName = type => `array<${type}>`

  const options$4 = {
    maxLength: {
      defaultValue: 10000,
      isValid: isSafeInteger,
      requirementDescription: "must be a positive integer",
      parse: toNumberOrNull,
    },
    minLength: {
      defaultValue: 0,
      isValid: n => isSafeInteger(n) && n >= 0,
      requirementDescription: "must be a positive integer",
      parse: toNumberOrNull,
    },
  }

  const typeConstraints$4 = [
    makerule$1(
      async (val, opts) => val === null || val.length >= opts.minLength,
      (val, opts) => `must choose ${opts.minLength} or more options`
    ),
    makerule$1(
      async (val, opts) => val === null || val.length <= opts.maxLength,
      (val, opts) => `cannot choose more than ${opts.maxLength} options`
    ),
  ]

  var array = type =>
    getDefaultExport(
      typeName(type.name),
      arrayTryParse(type),
      arrayFunctions(),
      options$4,
      typeConstraints$4,
      [type.sampleValue],
      JSON.stringify
    )

  const referenceNothing = () => ({ key: "" })

  const referenceFunctions = typeFunctions({
    default: referenceNothing,
  })

  const hasStringValue = (ob, path) => fp_24(path)(ob) && fp_26(ob[path])

  const isObjectWithKey = v => fp_30(v) && hasStringValue(v, "key")

  const tryParseFromString = s => {
    try {
      const asObj = JSON.parse(s)
      if (isObjectWithKey) {
        return parsedSuccess(asObj)
      }
    } catch (_) {
      // EMPTY
    }

    return parsedFailed(s)
  }

  const referenceTryParse = v =>
    switchCase(
      [isObjectWithKey, parsedSuccess],
      [fp_26, tryParseFromString],
      [fp_28, () => parsedSuccess(referenceNothing())],
      [defaultCase, parsedFailed]
    )(v)

  const options$5 = {
    indexNodeKey: {
      defaultValue: null,
      isValid: isNonEmptyString,
      requirementDescription: "must be a non-empty string",
      parse: s => s,
    },
    displayValue: {
      defaultValue: "",
      isValid: isNonEmptyString,
      requirementDescription: "must be a non-empty string",
      parse: s => s,
    },
    reverseIndexNodeKeys: {
      defaultValue: null,
      isValid: v => isArrayOfString(v) && v.length > 0,
      requirementDescription: "must be a non-empty array of strings",
      parse: s => s,
    },
  }

  const isEmptyString = s => fp_26(s) && fp_15(s)

  const ensureReferenceExists = async (val, opts, context) =>
    isEmptyString(val.key) || (await context.referenceExists(opts, val.key))

  const typeConstraints$5 = [
    makerule$1(
      ensureReferenceExists,
      (val, opts) =>
        `"${val[opts.displayValue]}" does not exist in options list (key: ${
          val.key
        })`
    ),
  ]

  var reference = getDefaultExport(
    "reference",
    referenceTryParse,
    referenceFunctions,
    options$5,
    typeConstraints$5,
    { key: "key", value: "value" },
    JSON.stringify
  )

  const illegalCharacters = "*?\\/:<>|\0\b\f\v"

  const isLegalFilename = filePath => {
    const fn = fileName(filePath)
    return (
      fn.length <= 255 &&
      fp_22(fn.split(""))(illegalCharacters.split("")).length === 0 &&
      none(f => f === "..")(splitKey(filePath))
    )
  }

  const fileNothing = () => ({ relativePath: "", size: 0 })

  const fileFunctions = typeFunctions({
    default: fileNothing,
  })

  const fileTryParse = v =>
    switchCase(
      [isValidFile, parsedSuccess],
      [fp_28, () => parsedSuccess(fileNothing())],
      [defaultCase, parsedFailed]
    )(v)

  const fileName = filePath => $(filePath, [splitKey, fp_4])

  const isValidFile = f =>
    !fp_28(f) &&
    fp_24("relativePath")(f) &&
    fp_24("size")(f) &&
    fp_29(f.size) &&
    fp_26(f.relativePath) &&
    isLegalFilename(f.relativePath)

  const options$6 = {}

  const typeConstraints$6 = []

  var file$a = getDefaultExport(
    "file",
    fileTryParse,
    fileFunctions,
    options$6,
    typeConstraints$6,
    { relativePath: "some_file.jpg", size: 1000 },
    JSON.stringify
  )

  const allTypes = () => {
    const basicTypes = {
      string,
      number,
      datetime,
      bool,
      reference,
      file: file$a,
    }

    const arrays = $(basicTypes, [
      fp_13,
      fp_11(k => {
        const kvType = {}
        const concreteArray = array(basicTypes[k])
        kvType[concreteArray.name] = concreteArray
        return kvType
      }),
      types => lodash_12({}, ...types),
    ])

    return lodash_11({}, basicTypes, arrays)
  }

  const all$1 = allTypes()

  const getType = typeName => {
    if (!fp_24(typeName)(all$1))
      throw new BadRequestError(`Do not recognise type ${typeName}`)
    return all$1[typeName]
  }

  const getNewFieldValue = field => getType(field.type).getNew(field)

  const AUTH_FOLDER = "/.auth"
  const USERS_LIST_FILE = joinKey(AUTH_FOLDER, "users.json")
  const USERS_LOCK_FILE = joinKey(AUTH_FOLDER, "users_lock")
  const ACCESS_LEVELS_FILE = joinKey(AUTH_FOLDER, "access_levels.json")
  const ACCESS_LEVELS_LOCK_FILE = joinKey(AUTH_FOLDER, "access_levels_lock")

  const permissionTypes = {
    CREATE_RECORD: "create record",
    UPDATE_RECORD: "update record",
    READ_RECORD: "read record",
    DELETE_RECORD: "delete record",
    READ_INDEX: "read index",
    MANAGE_INDEX: "manage index",
    MANAGE_COLLECTION: "manage collection",
    WRITE_TEMPLATES: "write templates",
    CREATE_USER: "create user",
    SET_PASSWORD: "set password",
    CREATE_TEMPORARY_ACCESS: "create temporary access",
    ENABLE_DISABLE_USER: "enable or disable user",
    WRITE_ACCESS_LEVELS: "write access levels",
    LIST_USERS: "list users",
    LIST_ACCESS_LEVELS: "list access levels",
    EXECUTE_ACTION: "execute action",
    SET_USER_ACCESS_LEVELS: "set user access levels",
  }

  const isAuthorized = app => (permissionType, resourceKey) =>
    apiWrapperSync(
      app,
      events.authApi.isAuthorized,
      alwaysAuthorized,
      { resourceKey, permissionType },
      _isAuthorized,
      app,
      permissionType,
      resourceKey
    )

  const _isAuthorized = (app, permissionType, resourceKey) => {
    if (!app.user) {
      return false
    }

    const validType = $(permissionTypes, [fp_33, fp_18(permissionType)])

    if (!validType) {
      return false
    }

    const permMatchesResource = userperm => {
      const nodeKey = isNothing(resourceKey)
        ? null
        : isNode(app.hierarchy, resourceKey)
        ? getNodeByKeyOrNodeKey(app.hierarchy, resourceKey).nodeKey()
        : resourceKey

      return (
        userperm.type === permissionType &&
        (isNothing(resourceKey) || nodeKey === userperm.nodeKey)
      )
    }

    return $(app.user.permissions, [fp_9(permMatchesResource)])
  }

  const nodePermission = type => ({
    add: (nodeKey, accessLevel) =>
      accessLevel.permissions.push({ type, nodeKey }),
    isAuthorized: resourceKey => app => isAuthorized(app)(type, resourceKey),
    isNode: true,
    get: nodeKey => ({ type, nodeKey }),
  })

  const staticPermission = type => ({
    add: accessLevel => accessLevel.permissions.push({ type }),
    isAuthorized: app => isAuthorized(app)(type),
    isNode: false,
    get: () => ({ type }),
  })

  const createRecord = nodePermission(permissionTypes.CREATE_RECORD)

  const updateRecord = nodePermission(permissionTypes.UPDATE_RECORD)

  const deleteRecord = nodePermission(permissionTypes.DELETE_RECORD)

  const readRecord = nodePermission(permissionTypes.READ_RECORD)

  const writeTemplates = staticPermission(permissionTypes.WRITE_TEMPLATES)

  const createUser = staticPermission(permissionTypes.CREATE_USER)

  const setPassword = staticPermission(permissionTypes.SET_PASSWORD)

  const readIndex = nodePermission(permissionTypes.READ_INDEX)

  const manageIndex = staticPermission(permissionTypes.MANAGE_INDEX)

  const manageCollection = staticPermission(permissionTypes.MANAGE_COLLECTION)

  const createTemporaryAccess = staticPermission(
    permissionTypes.CREATE_TEMPORARY_ACCESS
  )

  const enableDisableUser = staticPermission(
    permissionTypes.ENABLE_DISABLE_USER
  )

  const writeAccessLevels = staticPermission(
    permissionTypes.WRITE_ACCESS_LEVELS
  )

  const listUsers = staticPermission(permissionTypes.LIST_USERS)

  const listAccessLevels = staticPermission(permissionTypes.LIST_ACCESS_LEVELS)

  const setUserAccessLevels = staticPermission(
    permissionTypes.SET_USER_ACCESS_LEVELS
  )

  const executeAction = nodePermission(permissionTypes.EXECUTE_ACTION)

  const alwaysAuthorized = () => true

  const permission = {
    createRecord,
    updateRecord,
    deleteRecord,
    readRecord,
    writeTemplates,
    createUser,
    setPassword,
    readIndex,
    createTemporaryAccess,
    enableDisableUser,
    writeAccessLevels,
    listUsers,
    listAccessLevels,
    manageIndex,
    manageCollection,
    executeAction,
    setUserAccessLevels,
  }

  const getNew = app => (collectionKey, recordTypeName) => {
    const recordNode = getRecordNode(app, collectionKey)
    collectionKey = safeKey(collectionKey)
    return apiWrapperSync(
      app,
      events.recordApi.getNew,
      permission.createRecord.isAuthorized(recordNode.nodeKey()),
      { collectionKey, recordTypeName },
      _getNew,
      recordNode,
      collectionKey
    )
  }

  const _getNew = (recordNode, collectionKey) =>
    constructRecord(recordNode, getNewFieldValue, collectionKey)

  const getRecordNode = (app, collectionKey) => {
    collectionKey = safeKey(collectionKey)
    return getNodeForCollectionPath(app.hierarchy)(collectionKey)
  }

  const getNewChild = app => (recordKey, collectionName, recordTypeName) =>
    getNew(app)(joinKey(recordKey, collectionName), recordTypeName)

  const constructRecord = (recordNode, getFieldValue, collectionKey) => {
    const record = $(recordNode.fields, [fp_34("name"), fp_25(getFieldValue)])

    record.id = `${recordNode.nodeId}-${shortid_1()}`
    record.key = joinKey(collectionKey, record.id)
    record.isNew = true
    record.type = recordNode.name
    return record
  }

  const createCoreApi = (appDefinition, user) => {
    const app = createCoreApp(appDefinition, user)

    return {
      recordApi: {
        getNew: getNew(app),
        getNewChild: getNewChild(app),
      },
    }
  }

  const createApp = (componentLibraries, appDefinition, user) => {
    const initialiseComponent = parentContext => (
      props,
      htmlElement,
      context
    ) => {
      const { componentName, libName } = splitName(props._component)

      if (!componentName || !libName) return

      const { initialProps, bind } = setupBinding(
        store,
        props,
        coreApi,
        context,
        appDefinition.appRootPath
      )

      const component = new componentLibraries[libName][componentName]({
        target: htmlElement,
        props: { ...initialProps, _bb: bbInContext(context || parentContext) },
        hydrate: true,
      })

      bind(component)

      return component
    }

    const coreApi = createCoreApi(appDefinition, user)
    const store = writable({
      _bbuser: user,
    })

    let globalState = null
    store.subscribe(s => {
      globalState = s
    })

    const relativeUrl = url =>
      appDefinition.appRootPath
        ? appDefinition.appRootPath + "/" + trimSlash(url)
        : url

    const apiCall = method => (url, body) =>
      fetch(relativeUrl(url), {
        method: method,
        headers: {
          "Content-Type": "application/json",
        },
        body: body && JSON.stringify(body),
      })

    const api = {
      post: apiCall("POST"),
      get: apiCall("GET"),
      patch: apiCall("PATCH"),
      delete: apiCall("DELETE"),
    }

    const bb = () => ({
      initialiseComponent: initialiseComponent(),
      store,
      relativeUrl,
      api,
      getStateOrValue: (prop, currentContext) =>
        getStateOrValue(globalState, prop, currentContext),
    })

    const bbRoot = bb()

    const bbInContext = context => {
      if (!context) return bbRoot
      const bbCxt = bb()
      bbCxt.context = context
      bbCxt.initialiseComponent = initialiseComponent(context)
      return bbCxt
    }

    return bbRoot
  }

  const splitName = fullname => {
    const componentName = $(fullname, [fp_3("/"), fp_4])

    const libName = fullname.substring(
      0,
      fullname.length - componentName.length - 1
    )

    return { libName, componentName }
  }

  var createApp$1 = async () => {
    const componentLibraries = {
      components: {
        login: Login,
        grid: Grid,
        form: Form,
        textbox: Textbox,
        text: Text,
        nav: Nav,
        panel: Panel,
        table: Table,
        stackpanel: StackPanel,
        button: Button,
      },
    }

    const appDef = { hierarchy: {}, actions: {} }
    const user = { name: "yeo", permissions: [] }

    var app = createApp(componentLibraries, appDef, user)
    app.store.update(s => {
      s.people = [
        { name: "bob", address: "123 Main Street", status: "Open" },
        { name: "poppy", address: "456 Side Road", status: "Closed" },
        { name: "Oscar", address: "678 Dodgy Alley", status: "Open" },
      ]
      return s
    })

    return app
  }

  const props = {
    login: { _component: "components/login" },

    form: {
      _component: "components/form",
      formControls: [
        {
          control: {
            _component: "components/textbox",
          },
          label: "First Name",
        },
        {
          control: {
            _component: "components/textbox",
          },
          label: "Last Name",
        },
      ],
    },

    nav: {
      _component: "components/nav",
      navBarBackground: "red",
      navBarBorder: "1px solid maroon",
      navBarColor: "black",
      selectedItemBackground: "maroon",
      selectedItemColor: "white",
      selectedItemBorder: "green",
      itemHoverBackground: "yellow",
      itemHoverColor: "pink",
      items: [
        {
          title: "People",
          component: {
            _component: "components/panel",
            text: "People Panel",
            padding: "40px",
            border: "2px solid pink",
            background: "mistyrose",
          },
        },
        {
          title: "Animals",
          component: {
            _component: "components/panel",
            text: "Animals Panel",
            padding: "40px",
            border: "2px solid green",
            background: "azure",
          },
        },
      ],
    },

    table: {
      _component: "components/table",
      columns: [
        {
          title: {
            "##bbstate": "NameColumnName",
            "##bbsource": "store",
            "##bbstatefallback": "Name",
          },
          value: {
            "##bbstate": "name",
            "##bbsource": "context",
          },
        },
        {
          title: "Address",
          value: {
            "##bbstate": "address",
            "##bbsource": "context",
          },
        },
        {
          title: "Status",
          value: {
            "##bbstate": "status",
            "##bbsource": "context",
          },
        },
      ],
      data: {
        "##bbstate": "people",
      },
      onRowClick: [
        {
          "##eventHandlerType": "Set State",
          parameters: {
            path: "NameColumnName",
            value: {
              "##bbstate": "name",
              "##bbsource": "context",
              "##bbstatefallback": "balls to that",
            },
          },
        },
      ],
      tableClass: "table-default",
      theadClass: "thead-default",
      tbodyClass: "tbody-default",
      trClass: "tr-default",
      thClass: "th-default",
    },

    grid: {
      _component: "components/grid",
      gridTemplateColumns: "[left] auto [center] auto [right] auto",
      gridTemplateRows: "[top] auto [middle] auto [bottom] auto",
      children: [
        {
          control: {
            _component: "components/text",
            value: "1",
            background: "blue",
            textAlign: "center",
            color: "white",
          },
          gridColumn: "left",
          gridRow: "top",
        },
        {
          control: {
            _component: "components/text",
            value: "2",
            background: "red",
            textAlign: "center",
            color: "white",
            padding: "10px",
          },
          gridColumn: "center",
          gridRow: "middle",
        },
        {
          control: {
            _component: "components/text",
            value: "3",
            background: "yellow",
            textAlign: "center",
            color: "black",
          },
          gridColumn: "right",
          gridRow: "bottom",
        },
      ],
    },
    boundStackPanel: {
      _component: "components/stackpanel",
      direction: "horizontal",
      children: [
        {
          control: {
            _component: "components/text",
            value: "STATIC",
          },
        },
      ],
      data: {
        "##bbstate": "people",
      },
      dataItemComponent: {
        _component: "components/panel",
        text: {
          "##bbstate": "name",
          "##bbsource": "context",
          "##bbstatefallback": "balls to that",
        },
        padding: "10px",
        border: "5px solid black",
        margin: "10px",
        hoverColor: "white",
        hoverBackground: "black",
        height: "200px",
        weight: "200px",
      },
    },
    hiddenNav: {
      _component: "components/stackpanel",
      children: [
        {
          control: {
            _component: "components/button",
            contentText: "Peep",
            onClick: [
              {
                "##eventHandlerType": "Set State",
                parameters: {
                  path: "selected",
                  value: "People",
                },
              },
            ],
          },
        },
        {
          control: {
            _component: "components/button",
            contentText: "Ani",
            onClick: [
              {
                "##eventHandlerType": "Set State",
                parameters: {
                  path: "selected",
                  value: "Animals",
                },
              },
            ],
          },
        },
        {
          control: {
            _component: "components/nav",
            hideNavBar: true,
            selectedItem: {
              "##bbstate": "selected",
              "##bbsource": "store",
              "##bbstatefallback": "Animals",
            },
            items: [
              {
                title: "People",
                component: {
                  _component: "components/panel",
                  text: "People Panel",
                  padding: "40px",
                  border: "2px solid pink",
                  background: "mistyrose",
                },
              },
              {
                title: "Animals",
                component: {
                  _component: "components/panel",
                  text: "Animals Panel",
                  padding: "40px",
                  border: "2px solid green",
                  background: "azure",
                },
              },
            ],
          },
        },
      ],
    },
  }

  /* src\Test\TestApp.svelte generated by Svelte v3.12.1 */

  const file$b = "src\\Test\\TestApp.svelte"

  // (1:0) <script> import createApp from "./createApp"; import { props }
  function create_catch_block(ctx) {
    const block = {
      c: noop,
      l: noop,
      m: noop,
      p: noop,
      d: noop,
    }
    dispatch_dev("SvelteRegisterBlock", {
      block,
      id: create_catch_block.name,
      type: "catch",
      source:
        '(1:0) <script> import createApp from "./createApp"; import { props }',
      ctx,
    })
    return block
  }

  // (26:0) {:then _bb}
  function create_then_block(ctx) {
    var div

    const block = {
      c: function create() {
        div = element("div")
        this.h()
      },

      l: function claim(nodes) {
        div = claim_element(nodes, "DIV", { id: true, class: true }, false)
        var div_nodes = children(div)

        div_nodes.forEach(detach_dev)
        this.h()
      },

      h: function hydrate() {
        attr_dev(div, "id", "current_component")
        attr_dev(div, "class", "svelte-1xqz9vm")
        add_location(div, file$b, 27, 0, 380)
      },

      m: function mount(target, anchor) {
        insert_dev(target, div, anchor)
        ctx.div_binding(div)
      },

      p: noop,

      d: function destroy(detaching) {
        if (detaching) {
          detach_dev(div)
        }

        ctx.div_binding(null)
      },
    }
    dispatch_dev("SvelteRegisterBlock", {
      block,
      id: create_then_block.name,
      type: "then",
      source: "(26:0) {:then _bb}",
      ctx,
    })
    return block
  }

  // (24:20)  loading {:then _bb}
  function create_pending_block(ctx) {
    var t

    const block = {
      c: function create() {
        t = text("loading")
      },

      l: function claim(nodes) {
        t = claim_text(nodes, "loading")
      },

      m: function mount(target, anchor) {
        insert_dev(target, t, anchor)
      },

      p: noop,

      d: function destroy(detaching) {
        if (detaching) {
          detach_dev(t)
        }
      },
    }
    dispatch_dev("SvelteRegisterBlock", {
      block,
      id: create_pending_block.name,
      type: "pending",
      source: "(24:20)  loading {:then _bb}",
      ctx,
    })
    return block
  }

  function create_fragment$a(ctx) {
    var await_block_anchor, promise

    let info = {
      ctx,
      current: null,
      token: null,
      pending: create_pending_block,
      then: create_then_block,
      catch: create_catch_block,
      value: "_bb",
      error: "null",
    }

    handle_promise((promise = ctx._appPromise), info)

    const block = {
      c: function create() {
        await_block_anchor = empty()

        info.block.c()
      },

      l: function claim(nodes) {
        await_block_anchor = empty()

        info.block.l(nodes)
      },

      m: function mount(target, anchor) {
        insert_dev(target, await_block_anchor, anchor)

        info.block.m(target, (info.anchor = anchor))
        info.mount = () => await_block_anchor.parentNode
        info.anchor = await_block_anchor
      },

      p: function update(changed, new_ctx) {
        ctx = new_ctx
        info.block.p(changed, assign(assign({}, ctx), info.resolved))
      },

      i: noop,
      o: noop,

      d: function destroy(detaching) {
        if (detaching) {
          detach_dev(await_block_anchor)
        }

        info.block.d(detaching)
        info.token = null
        info = null
      },
    }
    dispatch_dev("SvelteRegisterBlock", {
      block,
      id: create_fragment$a.name,
      type: "component",
      source: "",
      ctx,
    })
    return block
  }

  function instance$a($$self, $$props, $$invalidate) {
    let _bb

    const _appPromise = createApp$1()
    _appPromise.then(a => $$invalidate("_bb", (_bb = a)))

    const testProps = props.hiddenNav

    let currentComponent

    function div_binding($$value) {
      binding_callbacks[$$value ? "unshift" : "push"](() => {
        $$invalidate("currentComponent", (currentComponent = $$value))
      })
    }

    $$self.$capture_state = () => {
      return {}
    }

    $$self.$inject_state = $$props => {
      if ("_bb" in $$props) $$invalidate("_bb", (_bb = $$props._bb))
      if ("currentComponent" in $$props)
        $$invalidate(
          "currentComponent",
          (currentComponent = $$props.currentComponent)
        )
    }

    $$self.$$.update = ($$dirty = { _bb: 1, currentComponent: 1 }) => {
      if ($$dirty._bb || $$dirty.currentComponent) {
        {
          if (_bb && currentComponent) {
            _bb.initialiseComponent(testProps, currentComponent)
          }
        }
      }
    }

    return {
      _appPromise,
      currentComponent,
      div_binding,
    }
  }

  class TestApp extends SvelteComponentDev {
    constructor(options) {
      super(options)
      init(this, options, instance$a, create_fragment$a, safe_not_equal, [])
      dispatch_dev("SvelteRegisterComponent", {
        component: this,
        tagName: "TestApp",
        options,
        id: create_fragment$a.name,
      })
    }
  }

  const app = new TestApp({
    target: document.body,
  })

  return app
})()
//# sourceMappingURL=bundle.js.map