Edit File - File Manager

Edit File: 231.index.js

exports.id = 231;
exports.ids = [231];
exports.modules = {

/***/ 42869:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const json = __webpack_require__(29387);
const strings = __webpack_require__(13043);
const regex = __webpack_require__(13732);
const yaml = __webpack_require__(76050);

module.exports = {
  ...json,
  ...strings,
  ...regex,
  ...yaml,
};

/***/ }),

/***/ 29387:
/***/ ((module) => {

module.exports = {
  "json.is_valid": isValidJSON,
};

/***/ }),

/***/ 13732:
/***/ ((module) => {

const regexSplit = (pattern, s) => s.split(RegExp(pattern));

module.exports = { "regex.split": regexSplit };

/***/ }),

/***/ 13043:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const vsprintf = __webpack_require__(8975).vsprintf;

const sprintf = (s, values) => vsprintf(s, values);

module.exports = { sprintf };

/***/ }),

/***/ 76050:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const yaml = __webpack_require__(6792);

// see: https://eemeli.org/yaml/v1/#errors
const errors = new Set([
  "YAMLReferenceError",
  "YAMLSemanticError",
  "YAMLSyntaxError",
  "YAMLWarning",
]);

function parse(str) {
  if (typeof str !== "string") {
    return { ok: false, result: undefined };
  }

module.exports = {
  // is_valid is expected to return nothing if input is invalid otherwise
  // true/false for it being valid YAML.
  "yaml.is_valid": (str) => typeof str === "string" ? parse(str).ok : undefined,
  "yaml.marshal": (data) => yaml.stringify(data),
  "yaml.unmarshal": (str) => parse(str).result,
};

/***/ }),

/***/ 39026:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 The OPA Authors.  All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
const builtIns = __webpack_require__(42869);
const util = __webpack_require__(73837);

// NOTE: The util shim here exists for Node 10.x and can be removed
// when dropping support. Browsers and Node >= 11.x use the global.
const TextEncoder = typeof global.TextEncoder !== "undefined"
  ? global.TextEncoder
  : util.TextEncoder;
const TextDecoder = typeof global.TextDecoder !== "undefined"
  ? global.TextDecoder
  : util.TextDecoder;

/**
 * @param {WebAssembly.Memory} mem
 */
function stringDecoder(mem) {
  return function (addr) {
    const i8 = new Int8Array(mem.buffer);
    let s = "";
    while (i8[addr] !== 0) {
      s += String.fromCharCode(i8[addr++]);
    }
    return s;
  };
}

/**
 * Stringifies and loads an object into OPA's Memory
 * @param {WebAssembly.Instance} wasmInstance
 * @param {WebAssembly.Memory} memory
 * @param {any | ArrayBuffer} value data as `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
 * @returns {number}
 */
function _loadJSON(wasmInstance, memory, value) {
  if (value === undefined) {
    return 0;
  }

let valueBuf;
  if (value instanceof ArrayBuffer) {
    valueBuf = new Uint8Array(value);
  } else {
    const valueAsText = JSON.stringify(value);
    valueBuf = new TextEncoder().encode(valueAsText);
  }

const valueBufLen = valueBuf.byteLength;
  const rawAddr = wasmInstance.exports.opa_malloc(valueBufLen);
  const memoryBuffer = new Uint8Array(memory.buffer);
  memoryBuffer.set(valueBuf, rawAddr);

const parsedAddr = wasmInstance.exports.opa_json_parse(rawAddr, valueBufLen);

if (parsedAddr === 0) {
    throw "failed to parse json value";
  }
  return parsedAddr;
}

/**
 * Dumps and parses a JSON object from OPA's Memory
 * @param {WebAssembly.Instance} wasmInstance
 * @param {WebAssembly.Memory} memory
 * @param {number} addr
 * @returns {object}
 */
function _dumpJSON(wasmInstance, memory, addr) {
  const rawAddr = wasmInstance.exports.opa_json_dump(addr);
  return _dumpJSONRaw(memory, rawAddr);
}

/**
 * Parses a JSON object from wasm instance's memory
 * @param {WebAssembly.Memory} memory
 * @param {number} addr
 * @returns {object}
 */
function _dumpJSONRaw(memory, addr) {
  const buf = new Uint8Array(memory.buffer);

let idx = addr;

while (buf[idx] !== 0) {
    idx++;
  }

const utf8View = new Uint8Array(memory.buffer, addr, idx - addr);
  const jsonAsText = new TextDecoder().decode(utf8View);

return JSON.parse(jsonAsText);
}

const builtinFuncs = builtIns;

/**
 * _builtinCall dispatches the built-in function. The built-in function
 * arguments are loaded from Wasm and back in using JSON serialization.
 * @param {WebAssembly.Instance} wasmInstance
 * @param {WebAssembly.Memory} memory
 * @param {{ [builtinId: number]: string }} builtins
 * @param {string} builtin_id
 */
function _builtinCall(wasmInstance, memory, builtins, builtinId) {
  const builtInName = builtins[builtinId];
  const impl = builtinFuncs[builtInName];

if (impl === undefined) {
    throw {
      message: "not implemented: built-in function " +
        builtinId +
        ": " +
        builtins[builtinId],
    };
  }

const argArray = Array.prototype.slice.apply(arguments);
  const args = [];

for (let i = 4; i < argArray.length; i++) {
    const jsArg = _dumpJSON(wasmInstance, memory, argArray[i]);
    args.push(jsArg);
  }

const result = impl(...args);

return _loadJSON(wasmInstance, memory, result);
}

/**
 * _loadPolicy can take in either an ArrayBuffer or WebAssembly.Module
 * as its first argument, and a WebAssembly.Memory for the second parameter.
 * It will return a Promise, depending on the input type the promise
 * resolves to both a compiled WebAssembly.Module and its first WebAssembly.Instance
 * or to the WebAssemblyInstance.
 * @param {BufferSource | WebAssembly.Module} policyWasm
 * @param {WebAssembly.Memory} memory
 * @returns {Promise<{ policy: WebAssembly.WebAssemblyInstantiatedSource | WebAssembly.Instance, minorVersion: number }>}
 */
async function _loadPolicy(policyWasm, memory) {
  const addr2string = stringDecoder(memory);

const env = {};

// Note: On Node 10.x this value is a number on Node 12.x and up it is
  // an object with numberic `value` property.
  const abiVersionGlobal = wasm.instance.exports.opa_wasm_abi_version;
  if (abiVersionGlobal !== undefined) {
    const abiVersion = typeof abiVersionGlobal === "number"
      ? abiVersionGlobal
      : abiVersionGlobal.value;
    if (abiVersion !== 1) {
      throw `unsupported ABI version ${abiVersion}`;
    }
  } else {
    console.error("opa_wasm_abi_version undefined"); // logs to stderr
  }

const abiMinorVersionGlobal =
    wasm.instance.exports.opa_wasm_abi_minor_version;
  let abiMinorVersion;
  if (abiMinorVersionGlobal !== undefined) {
    abiMinorVersion = typeof abiMinorVersionGlobal === "number"
      ? abiMinorVersionGlobal
      : abiMinorVersionGlobal.value;
  } else {
    console.error("opa_wasm_abi_minor_version undefined");
  }

env.instance = wasm.instance ? wasm.instance : wasm;

const builtins = _dumpJSON(
    env.instance,
    memory,
    env.instance.exports.builtins(),
  );

/** @type {typeof builtIns} */
  env.builtins = {};

for (const key of Object.keys(builtins)) {
    env.builtins[builtins[key]] = key;
  }

return { policy: wasm, minorVersion: abiMinorVersion };
}

/**
 * LoadedPolicy is a wrapper around a WebAssembly.Instance and WebAssembly.Memory
 * for a compiled Rego policy. There are helpers to run the wasm instance and
 * handle the output from the policy wasm.
 */
class LoadedPolicy {
  /**
   * Loads and initializes a compiled Rego policy.
   * @param {WebAssembly.WebAssemblyInstantiatedSource} policy
   * @param {WebAssembly.Memory} memory
   */
  constructor(policy, memory, minorVersion) {
    this.minorVersion = minorVersion;
    this.mem = memory;

// Depending on how the wasm was instantiated "policy" might be a
    // WebAssembly Instance or be a wrapper around the Module and
    // Instance. We only care about the Instance.
    this.wasmInstance = policy.instance ? policy.instance : policy;

this.dataAddr = _loadJSON(this.wasmInstance, this.mem, {});
    this.baseHeapPtr = this.wasmInstance.exports.opa_heap_ptr_get();
    this.dataHeapPtr = this.baseHeapPtr;
    this.entrypoints = _dumpJSON(
      this.wasmInstance,
      this.mem,
      this.wasmInstance.exports.entrypoints(),
    );
  }

/**
   * Evaluates the loaded policy with the given input and
   * return the result set. This should be re-used for multiple evaluations
   * of the same policy with different inputs.
   *
   * To call a non-default entrypoint in your WASM specify it as the second
   * param. A list of entrypoints can be accessed with the `this.entrypoints`
   * property.
   * @param {any | ArrayBuffer} input input to be evaluated in form of `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
   * @param {number | string} entrypoint ID or name of the entrypoint to call (optional)
   */
  evaluate(input, entrypoint = 0) {
    // determine entrypoint ID
    if (typeof entrypoint === "number") {
      // used as-is
    } else if (typeof entrypoint === "string") {
      if (Object.prototype.hasOwnProperty.call(this.entrypoints, entrypoint)) {
        entrypoint = this.entrypoints[entrypoint];
      } else {
        throw `entrypoint ${entrypoint} is not valid in this instance`;
      }
    } else {
      throw `entrypoint value is an invalid type, must be either string or number`;
    }

// ABI 1.2 fastpath
    if (this.minorVersion >= 2) {
      // write input into memory, adjust heap pointer
      let inputBuf = null;
      let inputLen = 0;
      let inputAddr = 0;
      if (input) {
        if (input instanceof ArrayBuffer) {
          inputBuf = new Uint8Array(input);
        } else {
          const inputAsText = JSON.stringify(input);
          inputBuf = new TextEncoder().encode(inputAsText);
        }

inputAddr = this.dataHeapPtr;
        inputLen = inputBuf.byteLength;
        const delta = inputAddr + inputLen - this.mem.buffer.byteLength;
        if (delta > 0) {
          const pages = roundup(delta);
          this.mem.grow(pages);
        }
        const buf = new Uint8Array(this.mem.buffer);
        buf.set(inputBuf, this.dataHeapPtr);
        this.dataHeapPtr = inputAddr + inputLen;
      }

const ret = this.wasmInstance.exports.opa_eval(
        0,
        entrypoint,
        this.dataAddr,
        inputAddr,
        inputLen,
        this.dataHeapPtr,
        0,
      );
      return _dumpJSONRaw(this.mem, ret);
    }

// Reset the heap pointer before each evaluation
    this.wasmInstance.exports.opa_heap_ptr_set(this.dataHeapPtr);

// Load the input data
    const inputAddr = _loadJSON(this.wasmInstance, this.mem, input);

// Setup the evaluation context
    const ctxAddr = this.wasmInstance.exports.opa_eval_ctx_new();
    this.wasmInstance.exports.opa_eval_ctx_set_input(ctxAddr, inputAddr);
    this.wasmInstance.exports.opa_eval_ctx_set_data(ctxAddr, this.dataAddr);
    this.wasmInstance.exports.opa_eval_ctx_set_entrypoint(ctxAddr, entrypoint);

// Actually evaluate the policy
    this.wasmInstance.exports.eval(ctxAddr);

// Retrieve the result
    const resultAddr = this.wasmInstance.exports.opa_eval_ctx_get_result(
      ctxAddr,
    );
    return _dumpJSON(this.wasmInstance, this.mem, resultAddr);
  }

/**
   * evalBool will evaluate the policy and return a boolean answer
   * depending on the return code from the policy evaluation.
   * @deprecated Use `evaluate` instead.
   * @param {object} input
   */
  evalBool(input) {
    const rs = this.evaluate(input);
    return rs && rs.length === 1 && rs[0] === true;
  }

/**
   * Loads data for use in subsequent evaluations.
   * @param {object | ArrayBuffer} data  data in form of `object` or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
   */
  setData(data) {
    this.wasmInstance.exports.opa_heap_ptr_set(this.baseHeapPtr);
    this.dataAddr = _loadJSON(this.wasmInstance, this.mem, data);
    this.dataHeapPtr = this.wasmInstance.exports.opa_heap_ptr_get();
  }
}

function roundup(bytes) {
  const pageSize = 64 * 1024;
  return Math.ceil(bytes / pageSize);
}

module.exports = {
  /**
   * Takes in either an ArrayBuffer or WebAssembly.Module
   * and will return a LoadedPolicy object which can be used to evaluate
   * the policy.
   *
   * To set custom memory size specify number of memory pages
   * as second param.
   * Defaults to 5 pages (320KB).
   * @param {BufferSource | WebAssembly.Module} regoWasm
   * @param {number | WebAssembly.MemoryDescriptor} memoryDescriptor For backwards-compatibility, a 'number' argument is taken to be the initial memory size.
   */
  async loadPolicy(regoWasm, memoryDescriptor = {}) {
    // back-compat, second arg used to be a number: 'memorySize', with default of 5
    if (typeof memoryDescriptor === "number") {
      memoryDescriptor = { initial: memoryDescriptor };
    }
    memoryDescriptor.initial = memoryDescriptor.initial || 5;

const memory = new WebAssembly.Memory(memoryDescriptor);
    const { policy, minorVersion } = await _loadPolicy(regoWasm, memory);
    return new LoadedPolicy(policy, memory, minorVersion);
  },
};

/***/ }),

/***/ 98611:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
var types_1 = __webpack_require__(60442);
Object.defineProperty(exports, "CloudConfigFileTypes", ({ enumerable: true, get: function () { return types_1.CloudConfigFileTypes; } }));
var issue_to_line_1 = __webpack_require__(76932);
Object.defineProperty(exports, "issuesToLineNumbers", ({ enumerable: true, get: function () { return issue_to_line_1.issuesToLineNumbers; } }));
Object.defineProperty(exports, "getTrees", ({ enumerable: true, get: function () { return issue_to_line_1.getTrees; } }));
Object.defineProperty(exports, "getLineNumber", ({ enumerable: true, get: function () { return issue_to_line_1.getLineNumber; } }));
var yaml_parser_1 = __webpack_require__(54232);
Object.defineProperty(exports, "parseFileContent", ({ enumerable: true, get: function () { return yaml_parser_1.parseFileContent; } }));
var path_1 = __webpack_require__(89639);
Object.defineProperty(exports, "parsePath", ({ enumerable: true, get: function () { return path_1.parsePath; } }));
//# sourceMappingURL=index.js.map

/***/ }),

/***/ 76932:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getLineNumber = exports.getTrees = exports.issuesToLineNumbers = void 0;
var types = __webpack_require__(60442);
var utils_1 = __webpack_require__(95680);
function issuesToLineNumbers(fileContent, fileType, path) {
    var trees = getTrees(fileType, fileContent);
    return getLineNumber(path, fileType, trees);
}
exports.issuesToLineNumbers = issuesToLineNumbers;
function getTrees(fileType, fileContent) {
    assertFileType(fileType);
    var trees = utils_1.buildTreeForTypeMap[fileType](fileContent);
    if (Object.keys(trees).length === 0) {
        throw new Error('failed to create trees');
    }
    return trees;
}
exports.getTrees = getTrees;
function getLineNumber(path, fileType, trees) {
    assertFileType(fileType);
    var pathDetails = utils_1.getPathDetails(path.slice(), fileType);
    var treeNodes = trees[pathDetails.docId].nodes;
    return utils_1.findLineNumberOfGivenPath(treeNodes, pathDetails);
}
exports.getLineNumber = getLineNumber;
function assertFileType(fileType) {
    if (!Object.values(types.CloudConfigFileTypes).includes(fileType)) {
        throw new Error('Unknown format');
    }
}
//# sourceMappingURL=index.js.map

/***/ }),

/***/ 83686:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
var esprima_1 = __webpack_require__(31072);
var JsonIterator = /** @class */ (function () {
    function JsonIterator(fileContent) {
        this.tokens = [];
        this.i = -1;
        this.currentToken = {
            type: '',
            value: '',
            loc: undefined,
        };
        this.done = false;
        this.previousProps = [];
        this.lastProp = undefined;
        this.tokens = esprima_1.tokenize(fileContent, {
            comment: true,
            loc: true,
        });
        if (!this.tokens.length) {
            throw new SyntaxError('unexpected end of JSON input');
        }
    }
    JsonIterator.prototype[Symbol.iterator] = function () {
        return this;
    };
    JsonIterator.prototype.isCurrentType = function (type) {
        if (!this.currentToken) {
            throw new SyntaxError('unexpected end of JSON input');
        }
        return ((this.currentToken.type === 'Punctuator'
            ? this.currentToken.value
            : this.currentToken.type) === type);
    };
    JsonIterator.prototype.isCurrentValue = function (value) {
        if (!this.currentToken) {
            throw new SyntaxError('unexpected end of JSON input');
        }
        return (this.currentToken.type === 'Punctuator' &&
            this.currentToken.value === value);
    };
    JsonIterator.prototype.expectType = function (type) {
        if (this.isCurrentType(type)) {
            return;
        }
        var error = new SyntaxError("Unexpected type " + this.currentToken.type);
        Object.assign(error, this.currentToken.loc.start);
        throw error;
    };
    JsonIterator.prototype.expectValue = function (value) {
        if (this.isCurrentValue(value)) {
            return;
        }
        var error = new SyntaxError("Unexpected value " + this.currentToken.value);
        Object.assign(error, this.currentToken.loc.start);
        throw error;
    };
    JsonIterator.prototype.skipComments = function () {
        while (this.currentToken &&
            (this.isCurrentType('LineComment') || this.isCurrentType('BlockComment'))) {
            this.next();
        }
    };
    JsonIterator.prototype.next = function () {
        if (this.done) {
            throw new SyntaxError('Unexpected EOF');
        }
        var newToken = this.tokens[++this.i];
        this.currentToken = newToken;
        if (!this.currentToken) {
            this.done = true;
        }
    };
    JsonIterator.prototype.current = function () {
        return this.currentToken;
    };
    JsonIterator.prototype.getCurrentLocation = function () {
        return {
            line: this.currentToken ? this.currentToken.loc.start.line : 0,
            columnStart: this.currentToken ? this.currentToken.loc.start.column : 0,
            columnEnd: this.currentToken ? this.currentToken.loc.end.column : 0,
        };
    };
    //--------------- Prop Handling
    JsonIterator.prototype.setLastProp = function (prop) {
        this.lastProp = prop;
    };
    JsonIterator.prototype.pushLastProp = function () {
        this.previousProps.push(this.lastProp);
        this.lastProp = undefined;
    };
    JsonIterator.prototype.restoreProp = function () {
        this.lastProp = this.previousProps.pop();
    };
    JsonIterator.prototype.getLastProp = function () {
        return this.lastProp !== undefined ? this.lastProp.toString() : '';
    };
    return JsonIterator;
}());
exports["default"] = JsonIterator;
//# sourceMappingURL=iterator.js.map

/***/ }),

/***/ 25552:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.buildJsonTreeMap = void 0;
var tslib_1 = __webpack_require__(70655);
var iterator_1 = __webpack_require__(83686);
var COLON = ':';
var BRACKET_OPEN = '[';
var BRACKET_CLOSE = ']';
var CURLY_BRACKET_OPEN = '{';
var CURLY_BRACKET_CLOSE = '}';
var COMMA = ',';
var MINUS = '-';
var possibleValueTypes = ['String', 'Boolean', 'Null', 'Numeric'];
function buildJsonTreeMap(jsonContent) {
    var iter = new iterator_1.default(jsonContent);
    iter.next();
    iter.skipComments();
    var singleWalk = walk(iter);
    var tree = {
        nodes: singleWalk[0].values,
    };
    // JSON are always single doc
    return {
        0: tree,
    };
}
exports.buildJsonTreeMap = buildJsonTreeMap;
function skipCommentsAndParseObjectOrArray(iter, shouldParseObject) {
    iter.pushLastProp();
    iter.skipComments();
    var nodes = [];
    if (shouldParseObject) {
        nodes = parseObject(iter);
    }
    else {
        nodes = parseArray(iter);
    }
    // bypass }
    iter.next();
    iter.restoreProp();
    return nodes;
}
function parseObject(iter) {
    var nodes = [];
    var firstLoop = true;
    var name;
    while (!iter.isCurrentValue(CURLY_BRACKET_CLOSE)) {
        if (!firstLoop) {
            // key-value pair delimiter
            iter.expectValue(COMMA);
            iter.next();
            iter.skipComments();
            // If there is a trailing comma, we might reach the end
            // ```
            // {
            //   "a": 1,
            // }
            // ```
            if (iter.isCurrentValue(CURLY_BRACKET_CLOSE)) {
                break;
            }
        }
        firstLoop = false;
        iter.expectType('String');
        name = JSON.parse(iter.current().value);
        iter.setLastProp(name);
        iter.next();
        iter.expectValue(COLON);
        iter.next();
        nodes.push.apply(nodes, walk(iter));
    }
    return nodes;
}
function parseArray(iter) {
    var nodes = [];
    var firstLoop = true;
    var i = 0;
    while (!iter.isCurrentValue(BRACKET_CLOSE)) {
        if (!firstLoop) {
            iter.expectValue(COMMA);
            iter.next();
            iter.skipComments();
            if (iter.isCurrentValue(BRACKET_CLOSE)) {
                break;
            }
        }
        firstLoop = false;
        iter.setLastProp(i);
        nodes.push.apply(nodes, walk(iter));
        iter.skipComments();
        i++;
    }
    return nodes;
}
function handleNativeCase(iter) {
    if (!possibleValueTypes.includes(iter.current().type)) {
        throw new Error('failed to find type ' + iter.current().type);
    }
    // turn "apiVersion" -> apiVersion
    // turn 'apiVersion' -> apiVersion
    var currentValue = iter.current().value;
    if ((currentValue.startsWith('"') && currentValue.endsWith('"')) ||
        (currentValue.startsWith("'") && currentValue.endsWith("'"))) {
        currentValue = currentValue.substring(1, currentValue.length - 1);
    }
    var nativeNode = {
        key: iter.getLastProp(),
        lineLocation: iter.getCurrentLocation(),
        values: currentValue,
    };
    iter.next();
    return [nativeNode];
}
function walk(iter) {
    var currentNode = {
        key: iter.getLastProp(),
        lineLocation: iter.getCurrentLocation(),
        values: [],
    };
    switch (iter.current().value) {
        case CURLY_BRACKET_OPEN:
            iter.next();
            return [
                tslib_1.__assign(tslib_1.__assign({}, currentNode), { values: skipCommentsAndParseObjectOrArray(iter, true) }),
            ];
        case BRACKET_OPEN:
            iter.next();
            return skipCommentsAndParseObjectOrArray(iter, false).map(function (value, i) {
                return {
                    key: iter.getLastProp() + "[" + i + "]",
                    lineLocation: value.lineLocation,
                    values: value.values,
                };
            });
        case MINUS:
            iter.next();
            break;
    }
    return handleNativeCase(iter);
}
//# sourceMappingURL=parser.js.map

/***/ }),

/***/ 89179:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.buildTfTreeMap = void 0;
var types_1 = __webpack_require__(978);
var utils_1 = __webpack_require__(41904);
function buildTfTreeMap(tfContent) {
    var multiLineComment = false;
    var multiLinePhrase = { phrase: null };
    var nodes = [];
    var currNode = null;
    var stateQueue = [];
    var duringTypeParsing = false;
    var tfFileLines = tfContent.split('\n');
    for (var i = 0; i < tfFileLines.length; i++) {
        var line = { content: tfFileLines[i].trim(), number: i };
        var lineState = utils_1.getLineState(line, multiLineComment, multiLinePhrase);
        multiLineComment = lineState.multiCommentLine;
        if (lineState.ignoredLine) {
            continue;
        }
        if (multiLinePhrase.phrase) {
            //Multi-line phrase ended - line is not ignored any more
            multiLinePhrase.phrase = null;
            continue;
        }
        var topType = void 0;
        if (stateQueue.length > 0) {
            topType = stateQueue[stateQueue.length - 1].type;
        }
        var lineType = utils_1.getLineType(line, topType);
        // In case of array value where is multiline and not completed yet
        // or
        // Object inside array
        //   -> can skip this line
        if (topType === types_1.TFLineTypes.ARRAY_START &&
            ![
                types_1.TFLineTypes.ARRAY_END,
                types_1.TFLineTypes.OBJECT_START,
                types_1.TFLineTypes.OBJECT_START_AND_END,
            ].includes(lineType)) {
            continue;
        }
        switch (lineType) {
            case types_1.TFLineTypes.IGNORE:
                continue;
            case types_1.TFLineTypes.TYPE_START:
                currNode = getTypeDetailsFromLine(line, nodes, stateQueue);
                duringTypeParsing = true;
                continue;
            case types_1.TFLineTypes.TYPE_START_AND_END:
                currNode = getTypeDetailsFromLine(line, nodes, stateQueue);
                stateQueue = [];
                duringTypeParsing = false;
                continue;
            case types_1.TFLineTypes.TYPE_END:
                if (topType !== types_1.TFLineTypes.SUB_TYPE) {
                    throw new SyntaxError('Invalid TF Input - End of type object without sub type');
                }
                stateQueue = [];
                duringTypeParsing = false;
                continue;
            case types_1.TFLineTypes.OBJECT_START:
                currNode = getComplexObjectNode(line, stateQueue, utils_1.Charts.openBracketsObject, lineType);
                continue;
            case types_1.TFLineTypes.OBJECT_START_AND_END:
                getComplexObjectNode(line, stateQueue, utils_1.Charts.openBracketsObject, lineType);
                stateQueue.pop();
                continue;
            case types_1.TFLineTypes.OBJECT_END: {
                currNode = handleComplexObjectEnd(currNode, stateQueue, types_1.TFLineTypes.OBJECT_START);
                continue;
            }
            case types_1.TFLineTypes.FUNCTION_START:
                currNode = getComplexObjectNode(line, stateQueue, utils_1.Charts.openFunction, lineType);
                continue;
            case types_1.TFLineTypes.FUNCTION_START_AND_END:
                getComplexObjectNode(line, stateQueue, utils_1.Charts.openFunction, lineType);
                stateQueue.pop();
                continue;
            case types_1.TFLineTypes.FUNCTION_END:
                currNode = handleComplexObjectEnd(currNode, stateQueue, types_1.TFLineTypes.FUNCTION_START);
                continue;
            case types_1.TFLineTypes.STRING:
            case types_1.TFLineTypes.MULTILINE_STRING:
            case types_1.TFLineTypes.ARRAY_START_AND_END: {
                if (!currNode) {
                    throw new SyntaxError('Unexpected TF input - Simple object without parent node');
                }
                var simpleNode = getSimpleNode(line);
                currNode.values.push(simpleNode);
                if (lineType === types_1.TFLineTypes.MULTILINE_STRING) {
                    multiLinePhrase = utils_1.getMultiLinePhrase(line);
                }
                continue;
            }
            case types_1.TFLineTypes.ARRAY_START: {
                if (!currNode) {
                    throw new SyntaxError('Unexpected TF input - Simple object without parent node');
                }
                var simpleNode = getSimpleNode(line);
                if (simpleNode.values === utils_1.Charts.openBracketsArray) {
                    simpleNode.values = [];
                }
                currNode.values.push(simpleNode);
                stateQueue.push({
                    structure: simpleNode,
                    type: lineType,
                });
                continue;
            }
            case types_1.TFLineTypes.ARRAY_END: {
                stateQueue.pop();
                continue;
            }
            default:
                throw new SyntaxError("Invalid TF input - Unhandled line type " + types_1.TFLineTypes[lineType]);
        }
    }
    if (duringTypeParsing || stateQueue.length !== 0) {
        throw new SyntaxError('Invalid TF input - Broken file');
    }
    if (nodes.length === 0) {
        throw new SyntaxError('Invalid TF input - No nodes were parsed');
    }
    // TF are always single doc
    return {
        0: { nodes: nodes },
    };
}
exports.buildTfTreeMap = buildTfTreeMap;
function getTypeDetailsFromLine(currentLine, nodes, stateQueue) {
    var lineContent = currentLine.content.split(utils_1.Charts.space);
    var resourceType = lineContent[1].replace(/"/g, '');
    var objectType = lineContent[0];
    if (resourceType === utils_1.Charts.openBracketsObject) {
        if (types_1.TerraformValidConfigurationTypes.includes(objectType)) {
            //Support Terraform configurations settings object
            resourceType = '';
        }
        else {
            throw new SyntaxError('Invalid TF input - Type object without sub type');
        }
    }
    var headNode = getTypeNode(objectType, currentLine, nodes);
    if (lineContent[2] &&
        lineContent[2] !== null &&
        lineContent[2] !== utils_1.Charts.openBracketsObject) {
        var resourceName = lineContent[2].replace(/"/g, '');
        resourceType = resourceType + "[" + resourceName + "]";
    }
    var subHeadNode = getSubTypeNode(headNode, resourceType, currentLine);
    stateQueue.push({ structure: headNode, type: types_1.TFLineTypes.TYPE_START });
    stateQueue.push({ structure: subHeadNode, type: types_1.TFLineTypes.SUB_TYPE });
    return subHeadNode;
}
function getTypeNode(objectType, line, nodes) {
    var headNode = nodes.find(function (node) { return node.key === objectType; });
    if (!headNode) {
        headNode = utils_1.getNode(objectType, line, []);
        nodes.push(headNode);
    }
    return headNode;
}
function getSubTypeNode(headNode, resourceType, line) {
    var headerSubTypes = headNode.values;
    var subHeadNode = headerSubTypes.find(function (node) { return node.key === resourceType; });
    if (!subHeadNode) {
        subHeadNode = utils_1.getNode(resourceType, line);
        headNode.values.push(subHeadNode);
    }
    return subHeadNode;
}
function getComplexObjectNode(line, stateQueue, splitByChart, lineType) {
    var key = line.content
        .split(splitByChart)[0]
        .split(utils_1.Charts.equal)[0]
        .trim();
    var objectNode = utils_1.getNode(key, line);
    stateQueue.push({ structure: objectNode, type: lineType });
    return objectNode;
}
function getSimpleNode(line) {
    var _a = line.content.split(utils_1.Charts.equal), key = _a[0], value = _a[1];
    return utils_1.getNode(key.trim(), line, value.trim().replace(/"/g, ''));
}
function handleComplexObjectEnd(currNode, stateQueue, startLineType) {
    var topState = stateQueue[stateQueue.length - 1];
    if (topState.type !== startLineType || stateQueue.length === 0) {
        throw new SyntaxError('Invalid TF Input - Object end without start');
    }
    if (!currNode) {
        throw new SyntaxError('Invalid TF input - Object without parent');
    }
    stateQueue.pop();
    topState = stateQueue[stateQueue.length - 1];
    var topNode = topState.structure;
    topNode.values.push(currNode);
    return topNode;
}
//# sourceMappingURL=parser.js.map

/***/ }),

/***/ 978:
/***/ ((__unused_webpack_module, exports) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.TerraformValidConfigurationTypes = exports.TFLineTypes = void 0;
var TFLineTypes;
(function (TFLineTypes) {
    TFLineTypes[TFLineTypes["TYPE_START"] = 1] = "TYPE_START";
    TFLineTypes[TFLineTypes["TYPE_END"] = 2] = "TYPE_END";
    TFLineTypes[TFLineTypes["TYPE_START_AND_END"] = 3] = "TYPE_START_AND_END";
    TFLineTypes[TFLineTypes["SUB_TYPE"] = 4] = "SUB_TYPE";
    TFLineTypes[TFLineTypes["STRING"] = 5] = "STRING";
    TFLineTypes[TFLineTypes["MULTILINE_STRING"] = 6] = "MULTILINE_STRING";
    TFLineTypes[TFLineTypes["ARRAY_START_AND_END"] = 7] = "ARRAY_START_AND_END";
    TFLineTypes[TFLineTypes["ARRAY_START"] = 8] = "ARRAY_START";
    TFLineTypes[TFLineTypes["ARRAY_END"] = 9] = "ARRAY_END";
    TFLineTypes[TFLineTypes["OBJECT_START_AND_END"] = 10] = "OBJECT_START_AND_END";
    TFLineTypes[TFLineTypes["OBJECT_START"] = 11] = "OBJECT_START";
    TFLineTypes[TFLineTypes["OBJECT_END"] = 12] = "OBJECT_END";
    TFLineTypes[TFLineTypes["FUNCTION_START_AND_END"] = 13] = "FUNCTION_START_AND_END";
    TFLineTypes[TFLineTypes["FUNCTION_START"] = 14] = "FUNCTION_START";
    TFLineTypes[TFLineTypes["FUNCTION_END"] = 15] = "FUNCTION_END";
    TFLineTypes[TFLineTypes["IGNORE"] = 99] = "IGNORE";
})(TFLineTypes = exports.TFLineTypes || (exports.TFLineTypes = {}));
exports.TerraformValidConfigurationTypes = ['terraform', 'locals'];
//# sourceMappingURL=types.js.map

/***/ }),

/***/ 41904:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getNode = exports.getLineType = exports.getMultiLinePhrase = exports.getLineState = exports.Charts = void 0;
var types_1 = __webpack_require__(978);
exports.Charts = {
    space: ' ',
    equal: '=',
    commentHash: '#',
    commentDash: '//',
    multilineCommentStart: '/*',
    multilineCommentEnd: '*/',
    multilinePhrase: '<<',
    openBracketsObject: '{',
    closeBracketsObject: '}',
    openBracketsArray: '[',
    closeBracketsArray: ']',
    openFunction: '(',
    closeFunction: ')',
};
function getLineState(line, isMultiLineComment, multiLinePhrase) {
    var multiCommentLine = isMultiLineComment;
    var ignoredLine = false;
    if (line.content.startsWith(exports.Charts.multilineCommentStart)) {
        ignoredLine = true;
        multiCommentLine = true;
    }
    if (line.content.includes(exports.Charts.multilineCommentEnd)) {
        // Multiline comment ended - this is still a commented line
        ignoredLine = true;
        multiCommentLine = false;
    }
    if (line.content.startsWith(exports.Charts.commentHash) ||
        line.content.startsWith(exports.Charts.commentDash) ||
        line.content.length === 0 //Empty Line
    ) {
        ignoredLine = true;
    }
    // Inside a multiline comment
    if (isMultiLineComment && !ignoredLine) {
        ignoredLine = true;
    }
    // Inside a multiline phrase
    if (multiLinePhrase.phrase &&
        !line.content.includes(multiLinePhrase.phrase)) {
        ignoredLine = true;
    }
    return {
        ignoredLine: ignoredLine,
        multiCommentLine: multiCommentLine,
    };
}
exports.getLineState = getLineState;
function getMultiLinePhrase(line) {
    var phrase = line.content
        .split(exports.Charts.multilinePhrase)[1]
        .trim()
        .split(exports.Charts.space)[0];
    return { phrase: phrase };
}
exports.getMultiLinePhrase = getMultiLinePhrase;
function getLineType(line, currentObjectType) {
    if (!currentObjectType) {
        if (line.content.includes(exports.Charts.openBracketsObject)) {
            if (line.content.includes(exports.Charts.closeBracketsObject)) {
                return types_1.TFLineTypes.TYPE_START_AND_END;
            }
            return types_1.TFLineTypes.TYPE_START;
        }
        throw new SyntaxError('Invalid TF input - TF Object without parent Type');
    }
    if (line.content.includes(exports.Charts.openBracketsArray)) {
        if (line.content.includes(exports.Charts.closeBracketsArray)) {
            return types_1.TFLineTypes.ARRAY_START_AND_END;
        }
        return types_1.TFLineTypes.ARRAY_START;
    }
    if (line.content.includes(exports.Charts.closeBracketsArray)) {
        return types_1.TFLineTypes.ARRAY_END;
    }
    if (line.content.includes(exports.Charts.multilinePhrase)) {
        return types_1.TFLineTypes.MULTILINE_STRING;
    }
    if (line.content.includes(exports.Charts.openFunction)) {
        if (line.content.includes(exports.Charts.closeFunction)) {
            return types_1.TFLineTypes.FUNCTION_START_AND_END;
        }
        return types_1.TFLineTypes.FUNCTION_START;
    }
    if (line.content.includes(exports.Charts.openBracketsObject)) {
        if (line.content.includes(exports.Charts.closeBracketsObject)) {
            if (line.content.includes(exports.Charts.equal)) {
                return types_1.TFLineTypes.STRING;
            }
            return types_1.TFLineTypes.OBJECT_START_AND_END;
        }
        return types_1.TFLineTypes.OBJECT_START;
    }
    if (line.content.includes(exports.Charts.closeFunction)) {
        if (currentObjectType != types_1.TFLineTypes.FUNCTION_START) {
            throw new SyntaxError('Invalid TF input - Close function sign without open function');
        }
        return types_1.TFLineTypes.FUNCTION_END;
    }
    if (currentObjectType === types_1.TFLineTypes.FUNCTION_START) {
        if (line.content.split(exports.Charts.space).length === 1) {
            return types_1.TFLineTypes.IGNORE;
        }
        return types_1.TFLineTypes.STRING;
    }
    if (line.content.includes(exports.Charts.equal)) {
        return types_1.TFLineTypes.STRING;
    }
    if (line.content.includes(exports.Charts.closeBracketsObject)) {
        if (currentObjectType === types_1.TFLineTypes.SUB_TYPE) {
            return types_1.TFLineTypes.TYPE_END;
        }
        return types_1.TFLineTypes.OBJECT_END;
    }
    if (line.content.startsWith(exports.Charts.multilinePhrase)) {
        return types_1.TFLineTypes.MULTILINE_STRING;
    }
    if (currentObjectType === types_1.TFLineTypes.ARRAY_START) {
        // Handling case of multi-line array object where the content is not yet finished.
        // Those lines will be skipped as part of
        // https://github.com/snyk/cloud-config-parser/blob/b5f5bdd8dd60cb3ad9c110bb6c640f08db0e108b/lib/issue-to-line/tf/parser.ts#L44
        return types_1.TFLineTypes.STRING;
    }
    throw new SyntaxError("Invalid TF input - Unknown line type - " + line.content);
}
exports.getLineType = getLineType;
function getNode(key, line, values) {
    var node = {
        key: key,
        lineLocation: {
            line: line.number + 1,
            columnStart: 0,
            columnEnd: line.content.length,
        },
        values: values ? values : [],
    };
    return node;
}
exports.getNode = getNode;
//# sourceMappingURL=utils.js.map

/***/ }),

/***/ 95680:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

var _a;
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getLineLocationForYamlElement = exports.findLineNumberOfGivenPath = exports.removeInputPathPrefix = exports.getPathDetails = exports.buildTreeForTypeMap = void 0;
var types_1 = __webpack_require__(60442);
var parser_1 = __webpack_require__(59559);
var parser_2 = __webpack_require__(25552);
var parser_3 = __webpack_require__(89179);
exports.buildTreeForTypeMap = (_a = {},
    _a[types_1.CloudConfigFileTypes.YAML] = parser_1.buildYamlTreeMap,
    _a[types_1.CloudConfigFileTypes.JSON] = parser_2.buildJsonTreeMap,
    _a[types_1.CloudConfigFileTypes.TF] = parser_3.buildTfTreeMap,
    _a);
function getPathDetails(path, fileType) {
    if (fileType === types_1.CloudConfigFileTypes.YAML) {
        return parser_1.getPathDetailsForYamlFile(path);
    }
    return {
        docId: 0,
        path: removeInputPathPrefix(path),
    };
}
exports.getPathDetails = getPathDetails;
function removeInputPathPrefix(path) {
    if (path[0] === 'input') {
        return path.splice(1);
    }
    return path;
}
exports.removeInputPathPrefix = removeInputPathPrefix;
function findLineNumberOfGivenPath(nodes, pathDetails) {
    var filteredNodes = nodes.filter(function (node) { return node.key === pathDetails.path[0]; });
    if (filteredNodes.length === 0) {
        // If the path does not exist, we will return '-1'
        return -1;
    }
    if (pathDetails.path.length === 1) {
        return filteredNodes[0].lineLocation.line;
    }
    return getLineNumberForSingleNode(filteredNodes[0], pathDetails.path.splice(1));
}
exports.findLineNumberOfGivenPath = findLineNumberOfGivenPath;
function getLineNumberForSingleNode(baseNode, remainingPath) {
    var node = baseNode;
    while (remainingPath.length) {
        if (typeof node.values === 'string') {
            return node.lineLocation.line;
        }
        var nodeForPath = getNodeForPath(node.values, remainingPath[0]);
        if (!nodeForPath) {
            //Not exists
            return node.lineLocation.line;
        }
        node = nodeForPath;
        remainingPath = remainingPath.splice(1);
    }
    return node.lineLocation.line;
}
function getNodeForPath(nodeValues, path) {
    if (!path.includes('[')) {
        return nodeValues.find(function (currNode) {
            return currNode.key.startsWith(path + "[") || currNode.key === path;
        });
    }
    var _a = path.replace(']', '').split('['), nodeName = _a[0], subNodeName = _a[1];
    var subNodeId = parseInt(subNodeName);
    if (!isNaN(subNodeId) && Number.isInteger(subNodeId)) {
        return nodeValues.find(function (currNode) { return currNode.key === path; });
    }
    return nodeValues.find(function (currNode) {
        var values = currNode.values;
        if (typeof values !== 'string') {
            return (currNode.key === path ||
                (currNode.key.startsWith(nodeName) &&
                    values.filter(function (value) {
                        return value.key === 'name' && value.values === subNodeName;
                    }).length > 0));
        }
        return false;
    });
}
function getLineLocationForYamlElement(nodeElement) {
    return {
        line: nodeElement.startMark.line + 1,
        columnStart: nodeElement.startMark.pointer,
        columnEnd: nodeElement.endMark.pointer,
    };
}
exports.getLineLocationForYamlElement = getLineLocationForYamlElement;
//# sourceMappingURL=utils.js.map

/***/ }),

/***/ 59559:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getPathDetailsForYamlFile = exports.buildYamlTreeMap = void 0;
var yamlJs = __webpack_require__(87736);
var utils_1 = __webpack_require__(95680);
var NULL_TAG = 'tag:yaml.org,2002:null';
var STR_TAG = 'tag:yaml.org,2002:str';
var INT_TAG = 'tag:yaml.org,2002:int';
var FLOAT_TAG = 'tag:yaml.org,2002:float';
var BOOL_TAG = 'tag:yaml.org,2002:bool';
var MAP_TAG = 'tag:yaml.org,2002:map';
var SEQ_TAG = 'tag:yaml.org,2002:seq';
var TIMESTAMP_TAG = 'tag:yaml.org,2002:timestamp';
var KEY_NODE_INDEX = 0;
var VAL_NODE_INDEX = 1;
var COMMENT_CHAR = '#';
var MULTI_DOC_SEPARATOR = '---';
function buildYamlTreeMap(yamlContent) {
    var yamlTrees = {};
    var docsArray = [];
    try {
        docsArray = yamlJs.compose_all(yamlContent);
    }
    catch (error) {
        throw new Error('failed to compose_all for given yaml');
    }
    // Edge case that yamlJs does not handle -
    // The first lines, before the first doc separator (---) are comments
    // The yamlJs will ignore this lines and will have 1 less document than expected.
    // This will only happen for the first document which document object will not be added for
    if (yamlContent.startsWith(COMMENT_CHAR) &&
        yamlContent.split(MULTI_DOC_SEPARATOR).length === docsArray.length + 1) {
        /* eslint-disable @typescript-eslint/camelcase */
        // Disable camelcase  - object structure from yamlJs
        var commentObject = {
            start_mark: { line: 0, column: 0, pointer: 0, buffer: yamlContent },
            end_mark: { line: 0, column: 0, pointer: 0, buffer: yamlContent },
            style: undefined,
            tag: NULL_TAG,
            unique_id: 'node_0',
            value: '',
        };
        /* eslint-enable @typescript-eslint/camelcase */
        docsArray.unshift(commentObject);
    }
    for (var i = 0; i < docsArray.length; i++) {
        var yamlDoc = convertComposeElementToType(docsArray[i]);
        // Handle case of empty document - the tag will be null
        // No need to build tree for this document
        if (yamlDoc.tag !== NULL_TAG) {
            yamlTrees[i] = buildTree(yamlDoc);
        }
    }
    return yamlTrees;
}
exports.buildYamlTreeMap = buildYamlTreeMap;
function buildTree(yamlDoc) {
    var _a;
    var tree = { nodes: [] };
    if (yamlDoc.tag !== MAP_TAG) {
        throw new Error('Invalid tree - cannot build from map');
    }
    for (var _i = 0, _b = yamlDoc.value; _i < _b.length; _i++) {
        var yamlElementValues = _b[_i];
        var values = [
            convertComposeElementToType(yamlElementValues[KEY_NODE_INDEX]),
            convertComposeElementToType(yamlElementValues[VAL_NODE_INDEX]),
        ];
        (_a = tree.nodes).push.apply(_a, buildTreeBranch(values, []));
    }
    return tree;
}
function buildTreeBranch(yamlElements, path) {
    //We are checking on the valNode - which is the second element in the yamlElements array ([1])
    switch (yamlElements[VAL_NODE_INDEX].tag) {
        case NULL_TAG:
        case STR_TAG:
        case INT_TAG:
        case FLOAT_TAG:
        case BOOL_TAG:
        case TIMESTAMP_TAG:
            return buildPrimitiveLeaf(yamlElements);
        case MAP_TAG:
            return buildMapBranch(yamlElements, path);
        case SEQ_TAG:
            return buildSeqBranch(yamlElements, path);
        default:
            return [];
    }
}
function buildPrimitiveLeaf(yamlElements) {
    var keyNode = yamlElements[0], valNode = yamlElements[1];
    var key = keyNode.value;
    var values = valNode.value;
    var lineLocation = utils_1.getLineLocationForYamlElement(keyNode);
    return [
        {
            key: key,
            lineLocation: lineLocation,
            values: values,
        },
    ];
}
function buildMapBranch(yamlElements, path) {
    var keyNode = yamlElements[KEY_NODE_INDEX];
    var fullPath = path.concat([keyNode.value]);
    return [
        getFileStructureNodesForYamlElement(yamlElements, keyNode.value, fullPath),
    ];
}
function buildSeqBranch(yamlElements, path) {
    var keyNode = yamlElements[0], valNode = yamlElements[1];
    var seqNodes = [];
    for (var i = 0; i < valNode.value.length; i++) {
        var nodeElement = convertComposeElementToType(valNode.value[i]);
        var key = keyNode.value + "[" + i + "]";
        var fullPath = path.concat(key);
        if (typeof nodeElement.value === 'string') {
            var lineLocation = utils_1.getLineLocationForYamlElement(nodeElement);
            var node = {
                key: key,
                lineLocation: lineLocation,
                values: nodeElement.value,
            };
            seqNodes.push(node);
        }
        else {
            seqNodes.push(getFileStructureNodesForYamlElement([nodeElement, nodeElement], key, fullPath));
        }
    }
    return seqNodes;
}
function convertComposeElementToType(yamlElement) {
    return {
        id: yamlElement.id,
        tag: yamlElement.tag,
        startMark: {
            line: yamlElement.start_mark.line,
            column: yamlElement.start_mark.column,
            Buffer: yamlElement.start_mark.buffer,
            pointer: yamlElement.start_mark.pointer,
        },
        endMark: {
            line: yamlElement.end_mark.line,
            column: yamlElement.end_mark.column,
            Buffer: yamlElement.end_mark.buffer,
            pointer: yamlElement.end_mark.pointer,
        },
        value: yamlElement.value,
    };
}
function getFileStructureNodesForYamlElement(yamlElements, key, fullPath) {
    var keyNode = yamlElements[0], valNode = yamlElements[1];
    var nodes = [];
    var lineLocation = utils_1.getLineLocationForYamlElement(keyNode);
    for (var _i = 0, _a = valNode.value; _i < _a.length; _i++) {
        var yamlElementValues = _a[_i];
        var values = [
            convertComposeElementToType(yamlElementValues[KEY_NODE_INDEX]),
            convertComposeElementToType(yamlElementValues[VAL_NODE_INDEX]),
        ];
        nodes.push.apply(nodes, buildTreeBranch(values, fullPath));
    }
    return {
        key: key,
        lineLocation: lineLocation,
        values: nodes,
    };
}
function getPathDetailsForYamlFile(path) {
    var firstPath = path[0];
    if (firstPath.includes('[DocId:')) {
        var docId = firstPath.replace('[DocId: ', '').replace(']', '');
        var pathWithoutDocId = path.splice(1);
        return {
            docId: parseInt(docId),
            path: utils_1.removeInputPathPrefix(pathWithoutDocId),
        };
    }
    return {
        docId: 0,
        path: utils_1.removeInputPathPrefix(path),
    };
}
exports.getPathDetailsForYamlFile = getPathDetailsForYamlFile;
//# sourceMappingURL=parser.js.map

/***/ }),

/***/ 89639:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.parsePath = void 0;
var peggy = __webpack_require__(4193);
var grammar = "\n// Documentation, specifically for parsing delimited lists.\n// https://peggyjs.org/documentation#parsing-lists\n\n// A path is a dot delimeted list of identifiers.\npath = head:segment tail:(\".\" @segment)* { return [head, ...tail]; }\n\n// Segments consist of an identifier and an optional index.\n// e.g. hello or hello[world]\nsegment = $(identifier index?)\n\n// An identifier is a string of consecutive characters not consisting of dots, quotes or brackets. \nidentifier = [^'\"\\[\\]\\.]+\n\n// An index consists of square brackets containing a quoted or unquoted value.\n// e.g. hello['world'] or hello[world]\nindex = \"[\" $( unquoted_index / single_quoted_index / double_quoted_index) \"]\"\n\nunquoted_index = [^'\"\\]\\[]+\nsingle_quoted_index = \"'\" [^']+ \"'\"\ndouble_quoted_index = '\"' [^\"]+ '\"'\n";
exports.parsePath = createPathParser();
function createPathParser() {
    var parser = peggy.generate(grammar);
    return function (expr) {
        try {
            return parser.parse(expr);
        }
        catch (e) {
            return expr.split('.');
        }
    };
}
//# sourceMappingURL=path.js.map

/***/ }),

/***/ 60442:
/***/ ((__unused_webpack_module, exports) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.CloudConfigFileTypes = void 0;
var CloudConfigFileTypes;
(function (CloudConfigFileTypes) {
    CloudConfigFileTypes[CloudConfigFileTypes["YAML"] = 1] = "YAML";
    CloudConfigFileTypes[CloudConfigFileTypes["JSON"] = 2] = "JSON";
    CloudConfigFileTypes[CloudConfigFileTypes["TF"] = 3] = "TF";
})(CloudConfigFileTypes = exports.CloudConfigFileTypes || (exports.CloudConfigFileTypes = {}));
//# sourceMappingURL=types.js.map

/***/ }),

/***/ 54232:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.parseFileContent = void 0;
var YAML = __webpack_require__(6792);
function parseFileContent(fileContent, fileType) {
    if (fileType === void 0) { fileType = 'yaml'; }
    // the YAML library can parse both YAML and JSON content, as well as content with singe/multiple YAMLs
    // but the YAML library uses a lot of memory which could cause the Node heap to run out of memory: https://snyk.zendesk.com/agent/tickets/35401
    if (fileType === 'json') {
        return [JSON.parse(fileContent)];
    }
    return YAML.parseAllDocuments(fileContent).map(function (doc) {
        if (shouldThrowErrorFor(doc)) {
            throw doc.errors[0];
        }
        if (showThrowWarningFor(doc)) {
            throw doc.warnings[0];
        }
        return doc.toJSON();
    });
}
exports.parseFileContent = parseFileContent;
function shouldThrowErrorFor(doc) {
    var errorsToSkip = [
        'Insufficient indentation in flow collection',
        'Map keys must be unique',
    ];
    return (doc.errors.length !== 0 &&
        !errorsToSkip.some(function (e) { return doc.errors[0].message.includes(e); }));
}
function showThrowWarningFor(doc) {
    var warningsToInclude = [
        'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.',
    ];
    return (doc.warnings.length !== 0 &&
        warningsToInclude.some(function (e) { return doc.warnings[0].message.includes(e); }));
}
//# sourceMappingURL=index.js.map

/***/ }),

/***/ 21766:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

const path = __webpack_require__(71017);
const os = __webpack_require__(22037);

const homedir = os.homedir();
const tmpdir = os.tmpdir();
const {env} = process;

const macos = name => {
	const library = path.join(homedir, 'Library');

return {
		data: path.join(library, 'Application Support', name),
		config: path.join(library, 'Preferences', name),
		cache: path.join(library, 'Caches', name),
		log: path.join(library, 'Logs', name),
		temp: path.join(tmpdir, name)
	};
};

const windows = name => {
	const appData = env.APPDATA || path.join(homedir, 'AppData', 'Roaming');
	const localAppData = env.LOCALAPPDATA || path.join(homedir, 'AppData', 'Local');

return {
		// Data/config/cache/log are invented by me as Windows isn't opinionated about this
		data: path.join(localAppData, name, 'Data'),
		config: path.join(appData, name, 'Config'),
		cache: path.join(localAppData, name, 'Cache'),
		log: path.join(localAppData, name, 'Log'),
		temp: path.join(tmpdir, name)
	};
};

// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
const linux = name => {
	const username = path.basename(homedir);

return {
		data: path.join(env.XDG_DATA_HOME || path.join(homedir, '.local', 'share'), name),
		config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, '.config'), name),
		cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, '.cache'), name),
		// https://wiki.debian.org/XDGBaseDirectorySpecification#state
		log: path.join(env.XDG_STATE_HOME || path.join(homedir, '.local', 'state'), name),
		temp: path.join(tmpdir, username, name)
	};
};

const envPaths = (name, options) => {
	if (typeof name !== 'string') {
		throw new TypeError(`Expected string, got ${typeof name}`);
	}

options = Object.assign({suffix: 'nodejs'}, options);

if (options.suffix) {
		// Add suffix to prevent possible conflict with native apps
		name += `-${options.suffix}`;
	}

if (process.platform === 'darwin') {
		return macos(name);
	}

if (process.platform === 'win32') {
		return windows(name);
	}

return linux(name);
};

module.exports = envPaths;
// TODO: Remove this for the next major release
module.exports["default"] = envPaths;

/***/ }),

/***/ 51633:
/***/ ((module) => {

/**
 * lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';

/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
    rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
    rsComboSymbolsRange = '\\u20d0-\\u20f0',
    rsVarRange = '\\ufe0e\\ufe0f';

/** Used to compose unicode capture groups. */
var rsAstral = '[' + rsAstralRange + ']',
    rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
    rsFitz = '\\ud83c[\\udffb-\\udfff]',
    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
    rsNonAstral = '[^' + rsAstralRange + ']',
    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */
var reOptMod = rsModifier + '?',
    rsOptVar = '[' + rsVarRange + ']?',
    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
    rsSeq = rsOptVar + reOptMod + rsOptJoin,
    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, '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  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/**
 * 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('');
}

/**
 * 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);
}

/**
 * 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);
}

/**
 * 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) || [];
}

/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var objectToString = objectProto.toString;

/** Built-in value references. */
var Symbol = root.Symbol;

/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
    symbolToString = symbolProto ? symbolProto.toString : undefined;

/**
 * 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 `_.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 (isSymbol(value)) {
    return symbolToString ? symbolToString.call(value) : '';
  }
  var result = (value + '');
  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}

/**
 * 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 ? length : end;
  return (!start && end >= length) ? array : baseSlice(array, start, end);
}

/**
 * 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;

var chr = strSymbols
      ? strSymbols[0]
      : string.charAt(0);

var trailing = strSymbols
      ? castSlice(strSymbols, 1).join('')
      : string.slice(1);

return chr[methodName]() + trailing;
  };
}

/**
 * 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 && typeof value == 'object';
}

/**
 * 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) && objectToString.call(value) == symbolTag);
}

/**
 * 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 process.
 * @returns {string} Returns the string.
 * @example
 *
 * _.toString(null);
 * // => ''
 *
 * _.toString(-0);
 * // => '-0'
 *
 * _.toString([1, 2, 3]);
 * // => '1,2,3'
 */
function toString(value) {
  return value == null ? '' : baseToString(value);
}

/**
 * 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());
}

/**
 * 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');

module.exports = capitalize;

/***/ }),

/***/ 75316:
/***/ ((module, exports, __webpack_require__) => {

/* module decorator */ module = __webpack_require__.nmd(module);
/**
 * lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used to compose bitmasks for comparison styles. */
var UNORDERED_COMPARE_FLAG = 1,
    PARTIAL_COMPARE_FLAG = 2;

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
    MAX_SAFE_INTEGER = 9007199254740991;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    promiseTag = '[object Promise]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]',
    weakMapTag = '[object WeakMap]';

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 property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
    reIsPlainProp = /^\w*$/,
    reLeadingDot = /^\./,
    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;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\$\$?/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/** 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;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/** Detect free variable `exports`. */
var freeExports =  true && 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 {
    return freeProcess && freeProcess.binding('util');
  } catch (e) {}
}());

/* Node.js helper references. */
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/**
 * 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 ? array.length : 0,
      result = Array(length);

while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
}

/**
 * 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 ? array.length : 0;

while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

/**
 * 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 : object[key];
  };
}

/**
 * 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 `_.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 `_.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);
  };
}

/**
 * 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 : object[key];
}

/**
 * Checks if `value` is a host object in IE < 9.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
 */
function isHostObject(value) {
  // Many host objects are `Object` objects that can coerce to strings
  // despite having improperly defined `toString` methods.
  var result = false;
  if (value != null && typeof value.toString != 'function') {
    try {
      result = !!(value + '');
    } catch (e) {}
  }
  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));
  };
}

/**
 * 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;
}

/** 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 = root['__core-js_shared__'];

/** 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 decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var objectToString = objectProto.toString;

/** 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 Symbol = root.Symbol,
    Uint8Array = root.Uint8Array,
    propertyIsEnumerable = objectProto.propertyIsEnumerable,
    splice = arrayProto.splice;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeKeys = overArg(Object.keys, Object);

/* Built-in method references that are verified to be native. */
var DataView = getNative(root, 'DataView'),
    Map = getNative(root, 'Map'),
    Promise = getNative(root, 'Promise'),
    Set = getNative(root, 'Set'),
    WeakMap = getNative(root, 'WeakMap'),
    nativeCreate = getNative(Object, 'create');

/** 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,
    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
    symbolToString = symbolProto ? symbolProto.toString : undefined;

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Hash(entries) {
  var index = -1,
      length = entries ? entries.length : 0;

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) : {};
}

/**
 * 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) {
  return this.has(key) && delete this.__data__[key];
}

/**
 * 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 : result;
  }
  return hasOwnProperty.call(data, key) ? data[key] : undefined;
}

/**
 * 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 : 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__;
  data[key] = (nativeCreate && value === undefined) ? 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 ? entries.length : 0;

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__ = [];
}

/**
 * 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);
  }
  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 : 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) {
    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 ? entries.length : 0;

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.__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) {
  return getMapData(this, key)['delete'](key);
}

/**
 * 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) {
  getMapData(this, key).set(key, value);
  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 ? values.length : 0;

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) {
  this.__data__ = new ListCache(entries);
}

/**
 * Removes all key-value entries from the stack.
 *
 * @private
 * @name clear
 * @memberOf Stack
 */
function stackClear() {
  this.__data__ = new ListCache;
}

/**
 * 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) {
  return this.__data__['delete'](key);
}

/**
 * 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 cache = this.__data__;
  if (cache instanceof ListCache) {
    var pairs = cache.__data__;
    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
      pairs.push([key, value]);
      return this;
    }
    cache = this.__data__ = new MapCache(pairs);
  }
  cache.set(key, value);
  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) {
  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
  // Safari 9 makes `arguments.length` enumerable in strict mode.
  var result = (isArray(value) || isArguments(value))
    ? baseTimes(value.length, String)
    : [];

var length = result.length,
      skipIndexes = !!length;

for (var key in value) {
    if ((inherited || hasOwnProperty.call(value, key)) &&
        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
      result.push(key);
    }
  }
  return result;
}

/**
 * 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;
}

/**
 * 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 `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();

/**
 * 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 `_.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 = isKey(path, object) ? [path] : castPath(path);

var index = 0,
      length = path.length;

while (object != null && index < length) {
    object = object[toKey(path[index++])];
  }
  return (index && index == length) ? object : undefined;
}

/**
 * The base implementation of `getTag`.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  return objectToString.call(value);
}

/**
 * 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 `_.isEqual` which supports partial comparisons
 * and tracks traversed objects.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {Function} [customizer] The function to customize comparisons.
 * @param {boolean} [bitmask] The bitmask of comparison flags.
 *  The bitmask may be composed of the following flags:
 *     1 - Unordered comparison
 *     2 - Partial comparison
 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function baseIsEqual(value, other, customizer, bitmask, stack) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, 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 {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparisons.
 * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
 *  for more details.
 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = arrayTag,
      othTag = arrayTag;

if (!objIsArr) {
    objTag = getTag(object);
    objTag = objTag == argsTag ? objectTag : objTag;
  }
  if (!othIsArr) {
    othTag = getTag(other);
    othTag = othTag == argsTag ? objectTag : othTag;
  }
  var objIsObj = objTag == objectTag && !isHostObject(object),
      othIsObj = othTag == objectTag && !isHostObject(other),
      isSameTag = objTag == othTag;

if (isSameTag && !objIsObj) {
    stack || (stack = new Stack);
    return (objIsArr || isTypedArray(object))
      ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
      : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
  }
  if (!(bitmask & PARTIAL_COMPARE_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, customizer, bitmask, stack);
    }
  }
  if (!isSameTag) {
    return false;
  }
  stack || (stack = new Stack);
  return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
}

/**
 * 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 && !(key in object)) {
        return false;
      }
    } else {
      var stack = new Stack;
      if (customizer) {
        var result = customizer(objValue, srcValue, key, object, source, stack);
      }
      if (!(result === undefined
            ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, 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) || isHostObject(value)) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
}

/**
 * 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[objectToString.call(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 `_.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 && objValue === srcValue)
      ? hasIn(object, path)
      : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
  };
}

/**
 * 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(baseIteratee));

return baseSortBy(result, function(object, other) {
    return compareMultiple(object, other, orders);
  });
}

/**
 * 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);
  };
}

/**
 * Casts `value` to a path array if it's not one.
 *
 * @private
 * @param {*} value The value to inspect.
 * @returns {Array} Returns the cast property path array.
 */
function castPath(value) {
  return isArray(value) ? value : stringToPath(value);
}

/**
 * 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,
        valIsNull = value === null,
        valIsReflexive = value === value,
        valIsSymbol = isSymbol(value);

var othIsDefined = other !== undefined,
        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 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;
  };
}

/**
 * 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 {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} customizer The function to customize comparisons.
 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
 *  for more details.
 * @param {Object} stack Tracks traversed `array` and `other` objects.
 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
 */
function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
  var isPartial = bitmask & PARTIAL_COMPARE_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 & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;

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) {
      if (compared) {
        continue;
      }
      result = false;
      break;
    }
    // Recursively compare arrays (susceptible to call stack limits).
    if (seen) {
      if (!arraySome(other, function(othValue, othIndex) {
            if (!seen.has(othIndex) &&
                (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
              return seen.add(othIndex);
            }
          })) {
        result = false;
        break;
      }
    } else if (!(
          arrValue === othValue ||
            equalFunc(arrValue, othValue, customizer, bitmask, 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 {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} customizer The function to customize comparisons.
 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
 *  for more details.
 * @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, equalFunc, customizer, bitmask, 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 & PARTIAL_COMPARE_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 |= UNORDERED_COMPARE_FLAG;

// Recursively compare objects (susceptible to call stack limits).
      stack.set(object, other);
      var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, 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 {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} customizer The function to customize comparisons.
 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
 *  for more details.
 * @param {Object} stack Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
      objProps = keys(object),
      objLength = objProps.length,
      othProps = keys(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
          ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, 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;
}

/**
 * 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;
}

/**
 * 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,
// for data views in Edge < 14, and promises in Node.js.
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 = objectToString.call(value),
        Ctor = result == objectTag ? value.constructor : undefined,
        ctorString = Ctor ? toSource(Ctor) : undefined;

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;
  };
}

/**
 * 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 = isKey(path, object) ? [path] : castPath(path);

var result,
      index = -1,
      length = path.length;

while (++index < length) {
    var key = toKey(path[index]);
    if (!(result = object != null && hasFunc(object, key))) {
      break;
    }
    object = object[key];
  }
  if (result) {
    return result;
  }
  var length = object ? object.length : 0;
  return !!length && isLength(length) && isIndex(key, length) &&
    (isArray(object) || isArguments(object));
}

/**
 * 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) {
  length = length == null ? MAX_SAFE_INTEGER : length;
  return !!length &&
    (typeof value == 'number' || reIsUint.test(value)) &&
    (value > -1 && value % 1 == 0 && value < length);
}

/**
 * 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 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 `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 || (key in Object(object)));
  };
}

/**
 * Converts `string` to a property path array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the property path array.
 */
var stringToPath = memoize(function(string) {
  string = toString(string);

var result = [];
  if (reLeadingDot.test(string)) {
    result.push('');
  }
  string.replace(rePropName, function(match, number, quote, string) {
    result.push(quote ? string.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 process.
 * @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 '';
}

/**
 * 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 : orders;
  if (!isArray(orders)) {
    orders = orders == null ? [] : [orders];
  }
  return baseOrderBy(collection, iteratees, orders);
}

/**
 * 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 `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 && 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);
    return result;
  };
  memoized.cache = new (memoize.Cache || MapCache);
  return memoized;
}

// Assign cache to `_.memoize`.
memoize.Cache = MapCache;

/**
 * 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 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
 */
function isArguments(value) {
  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
}

/**
 * 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 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 `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) {
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 8-9 which returns 'object' for typed array and other constructors.
  var tag = isObject(value) ? objectToString.call(value) : '';
  return tag == funcTag || tag == genTag;
}

/**
 * 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 && (type == 'object' || type == 'function');
}

/**
 * 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;

/**
 * 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 : baseGet(object, path);
  return result === undefined ? defaultValue : result;
}

/**
 * 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 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);
}

/**
 * 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 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);
}

module.exports = orderBy;

/***/ }),

/***/ 90039:
/***/ ((module) => {