@datagrok/sequence-translator 1.3.1 → 1.3.2

package/dist/package-test.js.map

@@ -1 +1 @@
-{"version":3,"file":"package-test.js","mappings":"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EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAEjD,EAASm8D,YAAcG,UAAUt8D,KAAK,EACjC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC9C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAEjD,EAASq8D,WAAaC,UAAUt8D,KAAK,EAChC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC9C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAC7C,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,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","sources":["webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/dataframe-utils.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/test.js","webpack://sequencetranslator/./src/apps/common/view/components/colored-input/style.css","webpack://sequencetranslator/./src/apps/pattern/view/style.css","webpack://sequencetranslator/./src/apps/structure/view/style.css","webpack://sequencetranslator/./src/apps/translator/view/style.css","webpack://sequencetranslator/./node_modules/css-loader/dist/runtime/api.js","webpack://sequencetranslator/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://sequencetranslator/./node_modules/fast-sha256/sha256.js","webpack://sequencetranslator/./node_modules/lodash/lodash.js","webpack://sequencetranslator/./node_modules/object-hash/dist/object_hash.js","webpack://sequencetranslator/./node_modules/save-svg-as-png/lib/saveSvgAsPng.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://sequencetranslator/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://sequencetranslator/./src/apps/common/model/const.ts","webpack://sequencetranslator/./src/apps/common/model/data-loader/const.ts","webpack://sequencetranslator/./src/apps/common/model/data-loader/json-loader.ts","webpack://sequencetranslator/./src/apps/common/model/helpers.ts","webpack://sequencetranslator/./src/apps/common/model/monomer-lib/lib-wrapper.ts","webpack://sequencetranslator/./src/apps/common/model/parsing-validation/sequence-validator.ts","webpack://sequencetranslator/./src/apps/structure/model/mol-transformations.ts","webpack://sequencetranslator/./src/apps/translator/model/const.ts","webpack://sequencetranslator/./src/apps/translator/model/conversion-utils.ts","webpack://sequencetranslator/./src/apps/common/model/parsing-validation/format-handler.ts","webpack://sequencetranslator/./src/apps/translator/model/format-converter.ts","webpack://sequencetranslator/./src/apps/translator/view/const.ts","webpack://sequencetranslator/./node_modules/@datagrok-libraries/ml/src/typed-metrics/consts.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/bit-array.js","webpack://sequencetranslator/./node_modules/fastest-levenshtein/esm/mod.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/ml/src/macromolecule-distance-functions/macromolecule-distance-functions.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/ml/src/distance-metrics-methods.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/utils/const.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/types.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/consts.js","webpack://sequencetranslator/external var \"wu\"","webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/type-declarations.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/seq-palettes.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/aminoacids.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/nucleotides.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/unknown.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/utils/seq-handler.js","webpack://sequencetranslator/./src/apps/common/model/oligo-toolkit-package.ts","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/monomer-works/monomer-utils.js","webpack://sequencetranslator/external var \"ui\"","webpack://sequencetranslator/./src/apps/pattern/model/const.ts","webpack://sequencetranslator/./src/apps/pattern/model/types.ts","webpack://sequencetranslator/external var \"rxjs\"","webpack://sequencetranslator/./src/apps/pattern/model/utils.ts","webpack://sequencetranslator/external var \"rxjs.operators\"","webpack://sequencetranslator/external var \"$\"","webpack://sequencetranslator/./src/apps/pattern/view/style.css?1882","webpack://sequencetranslator/./src/apps/pattern/view/components/strand-editor/header-controls.ts","webpack://sequencetranslator/./src/apps/pattern/view/components/strand-editor/strand-controls.ts","webpack://sequencetranslator/./src/apps/pattern/model/subscription-manager.ts","webpack://sequencetranslator/./src/apps/pattern/view/components/strand-editor/dialog.ts","webpack://sequencetranslator/./src/apps/pattern/view/components/terminal-modification-editor.ts","webpack://sequencetranslator/./src/apps/structure/view/style.css?055e","webpack://sequencetranslator/./node_modules/@datagrok-libraries/chem-meta/src/formats/molfile-const.js","webpack://sequencetranslator/./src/apps/common/view/components/colored-input/style.css?d242","webpack://sequencetranslator/./src/apps/common/view/components/molecule-img.ts","webpack://sequencetranslator/./src/apps/translator/view/style.css?30b4","webpack://sequencetranslator/./src/package.ts","webpack://sequencetranslator/external var \"DG\"","webpack://sequencetranslator/external var \"grok\"","webpack://sequencetranslator/webpack/bootstrap","webpack://sequencetranslator/webpack/runtime/compat get default export","webpack://sequencetranslator/webpack/runtime/define property getters","webpack://sequencetranslator/webpack/runtime/global","webpack://sequencetranslator/webpack/runtime/hasOwnProperty shorthand","webpack://sequencetranslator/webpack/runtime/make namespace object","webpack://sequencetranslator/webpack/runtime/node module decorator","webpack://sequencetranslator/webpack/runtime/nonce","webpack://sequencetranslator/./src/tests/const.ts","webpack://sequencetranslator/./src/tests/formats-to-helm.ts","webpack://sequencetranslator/./src/tests/helm-to-nucleotides.ts","webpack://sequencetranslator/./src/tests/formats-support.ts","webpack://sequencetranslator/./src/package-test.ts"],"sourcesContent":["/* eslint-disable max-len */\nimport * as DG from 'datagrok-api/dg';\nimport * as sha256 from 'fast-sha256';\n/**\n * For columns of string type. Checks whether column contains empty values and removes corresponding rows in case user selects to remove.\n *\n */\nexport function removeEmptyStringRows(table, col) {\n    const cats = col.categories;\n    const emptyRawInd = cats.map((val, ind) => !val ? ind : null).filter((it) => it !== null);\n    const rawData = [...col.getRawData()];\n    const emptyRawsIndexes = [];\n    let removedRowsCounter = 0;\n    for (let i = 0; i < table.rowCount; i++) {\n        if (emptyRawInd.includes(rawData[i])) {\n            table.rows.removeAt(i - removedRowsCounter);\n            emptyRawsIndexes.push(i);\n            removedRowsCounter += 1;\n        }\n    }\n    return emptyRawsIndexes;\n}\nexport function hashDataFrame(table, names) {\n    names !== null && names !== void 0 ? names : (names = table.columns.names());\n    const hasher = new sha256.Hash();\n    const order = table.getSortedOrder(names);\n    const encoder = new TextEncoder();\n    for (const name of names) {\n        const column = table.columns.byName(name);\n        const dataArray = column.getRawData();\n        const isString = column.type == DG.TYPE.STRING;\n        const cats = column.categories;\n        for (let i = 0; i < dataArray.length; i++) {\n            if (isString) {\n                const data = cats[dataArray[order[i]]];\n                hasher.update(encoder.encode(data));\n            }\n            else {\n                const data = dataArray[order[i]];\n                hasher.update(Uint8Array.from([data]));\n            }\n        }\n    }\n    return hasher.digest();\n}\nexport const testData = DG.DataFrame.fromCsv(`countries,fasta,smiles,molregno,LON,Zip Code,Street Address Line 1,ImageUrl,user_id,error_message,xray,flag,magnitude,CS-id,pdb_id,accel_a,time_offset,chart,fit,Questions,empty_number,empty_string\nBelgium,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C(=O)OCCCc1cccnc1)c2cccc(c2)C(=O)c3ccccc3,1480014,36.276729583740234,995042300,14016 ROUTE 31W,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,1,1,1QBS,1,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.497360340644872, 1.7058694986686864, 5.278052678195135, 0.16000320889028383],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.374499797821045},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.6242473125457764},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.367267608642578},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.6723148822784424},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.6537344455718994},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.3651671409606934},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.5654284954071045},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.4160959720611572},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.286726713180542},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.5100042819976807},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6676985025405884},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.680136501789093},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3391543924808502},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.09038983285427094},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.19802775979042053}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[7.525235855508179, 1.3186911876809984, 5.335672608564294, 0.7860743343958098],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":7.988070487976074},{\"\"x\"\":0.6000000238418579,\"\"y\"\":7.018453121185303},{\"\"x\"\":1.100000023841858,\"\"y\"\":8.115279197692871},{\"\"x\"\":1.600000023841858,\"\"y\"\":7.486658096313477},{\"\"x\"\":2.0999999046325684,\"\"y\"\":7.396438121795654},{\"\"x\"\":2.5999999046325684,\"\"y\"\":7.477052211761475},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.913095474243164},{\"\"x\"\":3.5999999046325684,\"\"y\"\":8.01385498046875},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.985900402069092},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.970335960388184},{\"\"x\"\":5.099999904632568,\"\"y\"\":5.448817253112793},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.5534818172454834},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.893947958946228},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6340042352676392},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8403874039649963}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,100,abc\nBurundi,MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW,COc1ccc2cc(ccc2c1)C(C)C(=O)Oc3ccc(C)cc3OC,1480015,36.276729583740234,995073444,80 STATE HIGHWAY 310,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,2,2,1ZP8,2,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.431460753103398, 2.1691498799246745, 5.266445597102774, 0.7825762827017926],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.751083850860596},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.203000068664551},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.415858745574951},{\"\"x\"\":1.600000023841858,\"\"y\"\":4.68414306640625},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.198400974273682},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.179222106933594},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.638473987579346},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.708553314208984},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.291589260101318},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.038082599639893},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4349939823150635},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.2194708585739136},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.1920831203460693},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.5352635979652405},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.3346920311450958}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.339458017970126, -1.0734184310171178, 4.746332950550934, 0.2482416857595658],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.2139337658882141},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.4269562065601349},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.2441573292016983},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.146635964512825},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.08818462491035461},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.2560656666755676},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.42434045672416687},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.37111231684684753},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.5581737160682678},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.183590054512024},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.5629843473434448},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3211288452148438},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.229961633682251},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.2560226917266846},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.2142398357391357}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCameroon,MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL,COc1ccc2cc(ccc2c1)C(C)C(=O)OCCCc3cccnc3,1480016,36.26095962524414,995153596,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,3,3,2BDJ,3,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.6760652578642325, 0.9046956320756703, 5.651408971856738, 0.07738846012184185],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.32425594329834},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.668442249298096},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.379785060882568},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.0345139503479},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.878653526306152},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.3451313972473145},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.336992263793945},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.037430286407471},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.0092692375183105},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.151902675628662},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4066951274871826},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3732759952545166},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.673728108406067},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48574790358543396},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.2783052325248718}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.938395863010111, -1.4658480661392117, 5.462702751996584, 0.3473139023615039],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.4941710829734802},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.15323974192142487},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.46373432874679565},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.3370431363582611},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.5179030299186707},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.27899765968322754},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.22075064480304718},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.5789918899536133},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.21169911324977875},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.27857646346092224},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0906332731246948},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8520300388336182},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.7177059650421143},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.8680918216705322},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.2413077354431152}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCanada,MMELVLKTIIGPIVVGVVLRIVDKWLNKDK,CC(C(=O)NCCS)c1cccc(c1)C(=O)c2ccccc2,1480017,36.26095962524414,99515,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,4,4,1IAN,4,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[0.8597390975430008, 1.0957625732481946, 5.260537067987958, 0.07974187998177736],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.8190152645111084},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.8421689867973328},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.8740922212600708},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.8924275040626526},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.8249067664146423},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.9327669143676758},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.8522974252700806},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.8174492716789246},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.8394647240638733},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.7139387726783752},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.5561167597770691},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3276226818561554},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.12479474395513535},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.13006797432899475},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.059702079743146896}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.760930219582546, 1.6591793293833013, 4.667155929720851, 0.7858109544121652],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.156993389129639},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.236701965332031},{\"\"x\"\":1.100000023841858,\"\"y\"\":6.010560512542725},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.495512962341309},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.087770462036133},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.79986572265625},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.597546577453613},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.520902156829834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.360654354095459},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.5539746284484863},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.577236294746399},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.0001264810562134},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.9305797815322876},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6033638715744019},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.4203685522079468}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nColombia,MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN,FC(F)(F)c1ccc(OC2CCNCC2)cc1,1480029,36.3309440612793,995152050,1 COURT HOUSE SQUARE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,5,5,4UJ1,5,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[6.4995088314153655, 2.4270351004539914, 5.178659535348579, 0.625653346241577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.496231555938721},{\"\"x\"\":0.6000000238418579,\"\"y\"\":6.42543363571167},{\"\"x\"\":1.100000023841858,\"\"y\"\":7.040063858032227},{\"\"x\"\":1.600000023841858,\"\"y\"\":6.1115403175354},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.680728435516357},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.406774520874023},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.611269474029541},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.889094352722168},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.75344705581665},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.361435890197754},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.1666975021362305},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.172118902206421},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.801048994064331},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.4640021026134491},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.0010357667924836278}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.4734381347446401, 1.1649805188074196, 4.82958608866421, 0.09500545496710007],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.5279096364974976},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.3559974431991577},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.5246378183364868},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.5567657947540283},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.4114240407943726},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.4045010805130005},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.4769829511642456},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.4875500202178955},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.2991987466812134},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.922961413860321},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.6520044803619385},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.15350978076457977},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1078903079032898},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.17276449501514435},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.14066608250141144}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCosta Rica,MKSTKEEIQTIKTLLKDSRTAKYHKRLQIVL,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCCc3ccccc3,1480018,36.3309440612793,995084218,4041 SOUTHWESTERN BLVD,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,6,6,2BPW,6,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.4833641843311227, -1.8945978742090062, 4.671127708092568, 0.24159861311815153],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.0969524160027504},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.028483040630817413},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.22087176144123077},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.0068915546871721745},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.4305879771709442},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.44774115085601807},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.45346319675445557},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.2370593100786209},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.4657953977584839},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.155200719833374},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.2294070720672607},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.4311530590057373},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.33846116065979},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.608201026916504},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.8136143684387207}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.224573521642033, 1.4454033924198528, 5.6014197746076535, 0.2823216054197577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.95027494430542},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.1754679679870605},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.276752948760986},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.589294910430908},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.616994857788086},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.120813846588135},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.340766906738281},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.876471042633057},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.94999361038208},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.162564754486084},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.399557590484619},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.7977969646453857},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.0229872465133667},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48275601863861084},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.10408931970596313}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCuba,MHAILRYFIRRLFYHIFYKIYSLISKKHQSLPSDVRQF,COc1ccc2c(c1)c(CC(=O)N3CCCC3C(=O)Oc4ccc(C)cc4OC)c(C)n2C(=O)c5ccc(Cl)cc5,1480019,36.33115768432617,995081928,1227 US HIGHWAY 11,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,7,7,1QBS,7,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.320838679713925, -1.2421619987316728, 4.831325425225256, 0.3236011098403072],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.3727470338344574},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.12365014106035233},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.48422467708587646},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.2264465093612671},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.16821794211864471},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.3879014551639557},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.5470244884490967},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.3419053554534912},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.7655120491981506},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.2346516847610474},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.453336715698242},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.9565491676330566},{\"\"x\"\":6.099999904632568,\"\"y\"\":3.335299491882324},{\"\"x\"\":6.599999904632568,\"\"y\"\":3.240290880203247},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.1107218265533447}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.6401853521511094, 1.26211588875013, 5.399028074402744, 0.5089580830068091],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.8585598468780518},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.6077206134796143},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.855252265930176},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.619039297103882},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.839388370513916},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.335283041000366},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.571141481399536},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.4155046939849854},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7316646575927734},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.0680155754089355},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.891066551208496},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.6022753715515137},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.7652576565742493},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6875326037406921},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5828871726989746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nItaly,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO[N+](=O)[O-],1480020,36.33115768432617,99502,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,8,8,1ZP8,8,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.293592105923809, 1.3781586549141835, 5.1025898038676605, 0.03493851245291291],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.1287283897399902},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.267972230911255},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.398442506790161},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.5130622386932373},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.3255116939544678},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.127340793609619},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.47259783744812},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.131181478500366},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.090421438217163},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.02299165725708},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.1105059385299683},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.4494485855102539},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1375635862350464},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.036351121962070465},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.1619771122932434}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.953125499439879, 1.2528620255306528, 5.187637440149802, 0.3110348753260886],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.6585283279418945},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.911152362823486},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.924920082092285},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.8469438552856445},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.929472923278809},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.190037727355957},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.236179828643799},{\"\"x\"\":3.5999999046325684,\"\"y\"\":6.141019344329834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.295210838317871},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.265801906585693},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.3722851276397705},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8299226760864258},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.32690900564193726},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6274543404579163},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8441857099533081}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nRwanda,MPNSEPASLLELFNSIATQGELVRSLKAGNASK,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO,1480021,36.33137130737305,995037247,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,9,2BDJ,9,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.8209972202654474, 1.3779216716448506, 5.299882228439686, 0.06040645519069608],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.7821109294891357},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.542433023452759},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.7008674144744873},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.717301607131958},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.024452209472656},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.013899326324463},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.945094347000122},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.866621971130371},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7461626529693604},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.3454740047454834},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.61944317817688},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.999405026435852},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.46259793639183044},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.054134611040353775},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.05711187422275543}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.6318079657726035, 1.8495493770000595, 5.391793312471116, 0.17060707587348442],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.458079814910889},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.554427146911621},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.799983024597168},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.364140033721924},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.864485740661621},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.4509806632995605},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.702574729919434},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.7314534187316895},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.5123443603515625},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.724395751953125},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.354506969451904},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.7307666540145874},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.6305936574935913},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.035183437168598175},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.7575169205665588}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nSwitzerland,IRVVGRYLIEVWKAAGMDMDKVLFLWSSDEI,CN1CCC(CC1)Oc2ccc(cc2)C(F)(F)F,1480028,36.33137130737305,99504,92-11 179TH PLACE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,10,1IAN,10,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.1190255865097471, 2.3163895161544437, 5.4968866182279195, 0.2035204047289052],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.1057683229446411},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.1019697189331055},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.0818607807159424},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.062997817993164},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.046447515487671},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.1217249631881714},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.2166996002197266},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.215477705001831},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.0581893920898438},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.1747995615005493},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0181127786636353},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.5344523191452026},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.2569526433944702},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.1912207305431366},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.15060538053512573}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.1038581025805785, 2.0032224204185245, 5.087602825989163, 0.13277988512492753],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.0498509407043457},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.805217742919922},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.3415253162384033},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.0549843311309814},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.250074863433838},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.0432586669921875},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.265852451324463},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.9475724697113037},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.1929898262023926},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.7460060119628906},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6175861358642578},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3006608486175537},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3444803059101105},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.015537971630692482},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5527358055114746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\n,,,,,,,,,,,,,,,,,,,,,`);\ntestData.columns.add(DG.Column.fromList(DG.TYPE.BYTE_ARRAY, 'BinaryImage', Array.from(new Uint8Array(11))));\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dataframe-utils.js","sourceRoot":"","sources":["dataframe-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport * as DG from 'datagrok-api/dg';\nimport * as sha256 from 'fast-sha256';\n/**\n * For columns of string type. Checks whether column contains empty values and removes corresponding rows in case user selects to remove.\n *\n */\nexport function removeEmptyStringRows(table: DG.DataFrame, col: DG.Column): number[] {\n  const cats = col.categories;\n  const emptyRawInd = cats.map((val, ind) => !val ? ind : null).filter((it) => it !== null);\n  const rawData = [...col.getRawData()];\n  const emptyRawsIndexes = [];\n  let removedRowsCounter = 0;\n  for (let i = 0; i < table.rowCount; i++) {\n    if (emptyRawInd.includes(rawData[i])) {\n      table.rows.removeAt(i - removedRowsCounter);\n      emptyRawsIndexes.push(i);\n      removedRowsCounter += 1;\n    }\n  }\n  return emptyRawsIndexes;\n}\n\nexport function hashDataFrame(table: DG.DataFrame, names?: string[]): Uint8Array {\n  names ??= table.columns.names();\n  const hasher = new sha256.Hash();\n  const order = table.getSortedOrder(names);\n  const encoder = new TextEncoder();\n  for (const name of names) {\n    const column = table.columns.byName(name);\n    const dataArray = column.getRawData();\n    const isString = column.type == DG.TYPE.STRING;\n    const cats = column.categories;\n    for (let i = 0; i < dataArray.length; i++) {\n      if (isString) {\n        const data = cats[dataArray[order[i]]];\n        hasher.update(encoder.encode(data));\n      } else {\n        const data = dataArray[order[i]];\n        hasher.update(Uint8Array.from([data]));\n      }\n    }\n  }\n  return hasher.digest();\n}\n\nexport const testData = DG.DataFrame.fromCsv(`countries,fasta,smiles,molregno,LON,Zip Code,Street Address Line 1,ImageUrl,user_id,error_message,xray,flag,magnitude,CS-id,pdb_id,accel_a,time_offset,chart,fit,Questions,empty_number,empty_string\nBelgium,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C(=O)OCCCc1cccnc1)c2cccc(c2)C(=O)c3ccccc3,1480014,36.276729583740234,995042300,14016 ROUTE 31W,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,1,1,1QBS,1,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.497360340644872, 1.7058694986686864, 5.278052678195135, 0.16000320889028383],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.374499797821045},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.6242473125457764},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.367267608642578},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.6723148822784424},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.6537344455718994},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.3651671409606934},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.5654284954071045},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.4160959720611572},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.286726713180542},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.5100042819976807},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6676985025405884},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.680136501789093},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3391543924808502},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.09038983285427094},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.19802775979042053}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[7.525235855508179, 1.3186911876809984, 5.335672608564294, 0.7860743343958098],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":7.988070487976074},{\"\"x\"\":0.6000000238418579,\"\"y\"\":7.018453121185303},{\"\"x\"\":1.100000023841858,\"\"y\"\":8.115279197692871},{\"\"x\"\":1.600000023841858,\"\"y\"\":7.486658096313477},{\"\"x\"\":2.0999999046325684,\"\"y\"\":7.396438121795654},{\"\"x\"\":2.5999999046325684,\"\"y\"\":7.477052211761475},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.913095474243164},{\"\"x\"\":3.5999999046325684,\"\"y\"\":8.01385498046875},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.985900402069092},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.970335960388184},{\"\"x\"\":5.099999904632568,\"\"y\"\":5.448817253112793},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.5534818172454834},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.893947958946228},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6340042352676392},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8403874039649963}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,100,abc\nBurundi,MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW,COc1ccc2cc(ccc2c1)C(C)C(=O)Oc3ccc(C)cc3OC,1480015,36.276729583740234,995073444,80 STATE HIGHWAY 310,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,2,2,1ZP8,2,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.431460753103398, 2.1691498799246745, 5.266445597102774, 0.7825762827017926],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.751083850860596},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.203000068664551},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.415858745574951},{\"\"x\"\":1.600000023841858,\"\"y\"\":4.68414306640625},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.198400974273682},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.179222106933594},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.638473987579346},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.708553314208984},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.291589260101318},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.038082599639893},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4349939823150635},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.2194708585739136},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.1920831203460693},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.5352635979652405},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.3346920311450958}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.339458017970126, -1.0734184310171178, 4.746332950550934, 0.2482416857595658],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.2139337658882141},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.4269562065601349},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.2441573292016983},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.146635964512825},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.08818462491035461},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.2560656666755676},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.42434045672416687},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.37111231684684753},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.5581737160682678},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.183590054512024},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.5629843473434448},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3211288452148438},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.229961633682251},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.2560226917266846},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.2142398357391357}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCameroon,MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL,COc1ccc2cc(ccc2c1)C(C)C(=O)OCCCc3cccnc3,1480016,36.26095962524414,995153596,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,3,3,2BDJ,3,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.6760652578642325, 0.9046956320756703, 5.651408971856738, 0.07738846012184185],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.32425594329834},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.668442249298096},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.379785060882568},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.0345139503479},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.878653526306152},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.3451313972473145},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.336992263793945},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.037430286407471},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.0092692375183105},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.151902675628662},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4066951274871826},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3732759952545166},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.673728108406067},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48574790358543396},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.2783052325248718}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.938395863010111, -1.4658480661392117, 5.462702751996584, 0.3473139023615039],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.4941710829734802},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.15323974192142487},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.46373432874679565},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.3370431363582611},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.5179030299186707},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.27899765968322754},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.22075064480304718},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.5789918899536133},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.21169911324977875},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.27857646346092224},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0906332731246948},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8520300388336182},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.7177059650421143},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.8680918216705322},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.2413077354431152}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCanada,MMELVLKTIIGPIVVGVVLRIVDKWLNKDK,CC(C(=O)NCCS)c1cccc(c1)C(=O)c2ccccc2,1480017,36.26095962524414,99515,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,4,4,1IAN,4,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[0.8597390975430008, 1.0957625732481946, 5.260537067987958, 0.07974187998177736],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.8190152645111084},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.8421689867973328},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.8740922212600708},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.8924275040626526},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.8249067664146423},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.9327669143676758},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.8522974252700806},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.8174492716789246},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.8394647240638733},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.7139387726783752},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.5561167597770691},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3276226818561554},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.12479474395513535},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.13006797432899475},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.059702079743146896}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.760930219582546, 1.6591793293833013, 4.667155929720851, 0.7858109544121652],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.156993389129639},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.236701965332031},{\"\"x\"\":1.100000023841858,\"\"y\"\":6.010560512542725},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.495512962341309},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.087770462036133},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.79986572265625},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.597546577453613},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.520902156829834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.360654354095459},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.5539746284484863},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.577236294746399},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.0001264810562134},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.9305797815322876},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6033638715744019},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.4203685522079468}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nColombia,MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN,FC(F)(F)c1ccc(OC2CCNCC2)cc1,1480029,36.3309440612793,995152050,1 COURT HOUSE SQUARE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,5,5,4UJ1,5,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[6.4995088314153655, 2.4270351004539914, 5.178659535348579, 0.625653346241577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.496231555938721},{\"\"x\"\":0.6000000238418579,\"\"y\"\":6.42543363571167},{\"\"x\"\":1.100000023841858,\"\"y\"\":7.040063858032227},{\"\"x\"\":1.600000023841858,\"\"y\"\":6.1115403175354},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.680728435516357},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.406774520874023},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.611269474029541},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.889094352722168},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.75344705581665},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.361435890197754},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.1666975021362305},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.172118902206421},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.801048994064331},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.4640021026134491},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.0010357667924836278}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.4734381347446401, 1.1649805188074196, 4.82958608866421, 0.09500545496710007],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.5279096364974976},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.3559974431991577},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.5246378183364868},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.5567657947540283},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.4114240407943726},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.4045010805130005},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.4769829511642456},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.4875500202178955},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.2991987466812134},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.922961413860321},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.6520044803619385},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.15350978076457977},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1078903079032898},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.17276449501514435},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.14066608250141144}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCosta Rica,MKSTKEEIQTIKTLLKDSRTAKYHKRLQIVL,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCCc3ccccc3,1480018,36.3309440612793,995084218,4041 SOUTHWESTERN BLVD,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,6,6,2BPW,6,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.4833641843311227, -1.8945978742090062, 4.671127708092568, 0.24159861311815153],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.0969524160027504},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.028483040630817413},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.22087176144123077},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.0068915546871721745},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.4305879771709442},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.44774115085601807},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.45346319675445557},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.2370593100786209},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.4657953977584839},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.155200719833374},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.2294070720672607},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.4311530590057373},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.33846116065979},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.608201026916504},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.8136143684387207}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.224573521642033, 1.4454033924198528, 5.6014197746076535, 0.2823216054197577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.95027494430542},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.1754679679870605},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.276752948760986},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.589294910430908},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.616994857788086},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.120813846588135},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.340766906738281},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.876471042633057},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.94999361038208},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.162564754486084},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.399557590484619},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.7977969646453857},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.0229872465133667},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48275601863861084},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.10408931970596313}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCuba,MHAILRYFIRRLFYHIFYKIYSLISKKHQSLPSDVRQF,COc1ccc2c(c1)c(CC(=O)N3CCCC3C(=O)Oc4ccc(C)cc4OC)c(C)n2C(=O)c5ccc(Cl)cc5,1480019,36.33115768432617,995081928,1227 US HIGHWAY 11,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,7,7,1QBS,7,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.320838679713925, -1.2421619987316728, 4.831325425225256, 0.3236011098403072],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.3727470338344574},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.12365014106035233},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.48422467708587646},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.2264465093612671},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.16821794211864471},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.3879014551639557},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.5470244884490967},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.3419053554534912},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.7655120491981506},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.2346516847610474},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.453336715698242},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.9565491676330566},{\"\"x\"\":6.099999904632568,\"\"y\"\":3.335299491882324},{\"\"x\"\":6.599999904632568,\"\"y\"\":3.240290880203247},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.1107218265533447}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.6401853521511094, 1.26211588875013, 5.399028074402744, 0.5089580830068091],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.8585598468780518},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.6077206134796143},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.855252265930176},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.619039297103882},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.839388370513916},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.335283041000366},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.571141481399536},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.4155046939849854},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7316646575927734},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.0680155754089355},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.891066551208496},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.6022753715515137},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.7652576565742493},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6875326037406921},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5828871726989746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nItaly,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO[N+](=O)[O-],1480020,36.33115768432617,99502,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,8,8,1ZP8,8,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.293592105923809, 1.3781586549141835, 5.1025898038676605, 0.03493851245291291],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.1287283897399902},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.267972230911255},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.398442506790161},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.5130622386932373},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.3255116939544678},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.127340793609619},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.47259783744812},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.131181478500366},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.090421438217163},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.02299165725708},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.1105059385299683},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.4494485855102539},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1375635862350464},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.036351121962070465},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.1619771122932434}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.953125499439879, 1.2528620255306528, 5.187637440149802, 0.3110348753260886],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.6585283279418945},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.911152362823486},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.924920082092285},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.8469438552856445},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.929472923278809},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.190037727355957},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.236179828643799},{\"\"x\"\":3.5999999046325684,\"\"y\"\":6.141019344329834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.295210838317871},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.265801906585693},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.3722851276397705},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8299226760864258},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.32690900564193726},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6274543404579163},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8441857099533081}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nRwanda,MPNSEPASLLELFNSIATQGELVRSLKAGNASK,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO,1480021,36.33137130737305,995037247,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,9,2BDJ,9,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.8209972202654474, 1.3779216716448506, 5.299882228439686, 0.06040645519069608],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.7821109294891357},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.542433023452759},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.7008674144744873},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.717301607131958},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.024452209472656},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.013899326324463},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.945094347000122},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.866621971130371},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7461626529693604},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.3454740047454834},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.61944317817688},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.999405026435852},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.46259793639183044},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.054134611040353775},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.05711187422275543}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.6318079657726035, 1.8495493770000595, 5.391793312471116, 0.17060707587348442],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.458079814910889},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.554427146911621},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.799983024597168},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.364140033721924},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.864485740661621},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.4509806632995605},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.702574729919434},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.7314534187316895},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.5123443603515625},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.724395751953125},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.354506969451904},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.7307666540145874},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.6305936574935913},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.035183437168598175},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.7575169205665588}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nSwitzerland,IRVVGRYLIEVWKAAGMDMDKVLFLWSSDEI,CN1CCC(CC1)Oc2ccc(cc2)C(F)(F)F,1480028,36.33137130737305,99504,92-11 179TH PLACE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,10,1IAN,10,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.1190255865097471, 2.3163895161544437, 5.4968866182279195, 0.2035204047289052],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.1057683229446411},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.1019697189331055},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.0818607807159424},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.062997817993164},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.046447515487671},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.1217249631881714},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.2166996002197266},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.215477705001831},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.0581893920898438},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.1747995615005493},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0181127786636353},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.5344523191452026},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.2569526433944702},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.1912207305431366},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.15060538053512573}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.1038581025805785, 2.0032224204185245, 5.087602825989163, 0.13277988512492753],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.0498509407043457},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.805217742919922},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.3415253162384033},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.0549843311309814},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.250074863433838},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.0432586669921875},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.265852451324463},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.9475724697113037},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.1929898262023926},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.7460060119628906},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6175861358642578},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3006608486175537},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3444803059101105},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.015537971630692482},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5527358055114746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\n,,,,,,,,,,,,,,,,,,,,,`);\ntestData.columns.add(DG.Column.fromList(DG.TYPE.BYTE_ARRAY, 'BinaryImage', Array.from(new Uint8Array(11))));\n"]}","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\nimport { testData } from './dataframe-utils';\nconst STANDART_TIMEOUT = 30000;\nconst BENCHMARK_TIMEOUT = 10800000;\nconst stdLog = console.log.bind(console);\nconst stdInfo = console.info.bind(console);\nconst stdWarn = console.warn.bind(console);\nconst stdError = console.error.bind(console);\nexport const tests = {};\nconst autoTestsCatName = 'Auto Tests';\nconst demoCatName = 'Demo';\nconst detectorsCatName = 'Detectors';\nconst coreCatName = 'Core';\nconst wasRegistered = {};\nexport let currentCategory;\nexport var assure;\n(function (assure) {\n    function notNull(value, name) {\n        if (value == null)\n            throw new Error(`${name == null ? 'Value' : name} not defined`);\n    }\n    assure.notNull = notNull;\n})(assure || (assure = {}));\nexport class TestContext {\n    constructor(catchUnhandled, report) {\n        this.catchUnhandled = true;\n        this.report = false;\n        if (catchUnhandled !== undefined)\n            this.catchUnhandled = catchUnhandled;\n        if (report !== undefined)\n            this.report = report;\n    }\n    ;\n}\nexport class Test {\n    constructor(category, name, test, options) {\n        var _a;\n        this.category = category;\n        this.name = name;\n        options !== null && options !== void 0 ? options : (options = {});\n        (_a = options.timeout) !== null && _a !== void 0 ? _a : (options.timeout = STANDART_TIMEOUT);\n        this.options = options;\n        this.test = () => __awaiter(this, void 0, void 0, function* () {\n            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {\n                let result = '';\n                try {\n                    result = yield test();\n                }\n                catch (e) {\n                    reject(e);\n                }\n                resolve(result);\n            }));\n        });\n    }\n}\nexport function testEvent(event, handler, trigger, ms = 0, reason = `timeout`) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return new Promise((resolve, reject) => {\n            const sub = event.subscribe((args) => {\n                try {\n                    handler(args);\n                    resolve('OK');\n                }\n                catch (e) {\n                    reject(e);\n                }\n                // Do not clearTimeout or event sub if handler fails\n                sub.unsubscribe();\n                clearTimeout(timeout);\n            });\n            const timeout = setTimeout(() => {\n                sub.unsubscribe();\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject(reason);\n            }, ms);\n            trigger();\n        });\n    });\n}\nexport function test(name, test, options) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    if (tests[currentCategory].tests == undefined)\n        tests[currentCategory].tests = [];\n    tests[currentCategory].tests.push(new Test(currentCategory, name, test, options));\n}\n/* Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual, expected = true, error) {\n    if (error)\n        error = `${error}, `;\n    else\n        error = '';\n    if (actual !== expected)\n        throw new Error(`${error}Expected \"${expected}\", got \"${actual}\"`);\n}\nexport function expectFloat(actual, expected, tolerance = 0.001, error) {\n    if ((actual === Number.POSITIVE_INFINITY && expected === Number.POSITIVE_INFINITY) ||\n        (actual === Number.NEGATIVE_INFINITY && expected === Number.NEGATIVE_INFINITY) ||\n        (actual === Number.NaN && expected === Number.NaN) || (isNaN(actual) && isNaN(expected)))\n        return;\n    const areEqual = Math.abs(actual - expected) < tolerance;\n    expect(areEqual, true, `${error !== null && error !== void 0 ? error : ''} (tolerance = ${tolerance})`);\n    if (!areEqual)\n        throw new Error(`Expected ${expected}, got ${actual} (tolerance = ${tolerance})`);\n}\nexport function expectTable(actual, expected, error) {\n    const expectedRowCount = expected.rowCount;\n    const actualRowCount = actual.rowCount;\n    expect(actualRowCount, expectedRowCount, `${error !== null && error !== void 0 ? error : ''}, row count`);\n    for (const column of expected.columns) {\n        const actualColumn = actual.columns.byName(column.name);\n        if (actualColumn == null)\n            throw new Error(`Column ${column.name} not found`);\n        if (actualColumn.type != column.type)\n            throw new Error(`Column ${column.name} type expected ${column.type} got ${actualColumn.type}`);\n        for (let i = 0; i < expectedRowCount; i++) {\n            const value = column.get(i);\n            const actualValue = actualColumn.get(i);\n            if (column.type == DG.TYPE.FLOAT)\n                expectFloat(actualValue, value, 0.0001, error);\n            else if (column.type == DG.TYPE.DATE_TIME)\n                expect(actualValue.isSame(value), true, error);\n            else\n                expect(actualValue, value, error);\n        }\n    }\n}\nexport function expectObject(actual, expected) {\n    for (const [expectedKey, expectedValue] of Object.entries(expected)) {\n        if (!actual.hasOwnProperty(expectedKey))\n            throw new Error(`Expected property \"${expectedKey}\" not found`);\n        const actualValue = actual[expectedKey];\n        if (actualValue instanceof Array && expectedValue instanceof Array)\n            expectArray(actualValue, expectedValue);\n        else if (actualValue instanceof Object && expectedValue instanceof Object)\n            expectObject(actualValue, expectedValue);\n        else if (Number.isFinite(actualValue) && Number.isFinite(expectedValue))\n            expectFloat(actualValue, expectedValue);\n        else if (actualValue != expectedValue)\n            throw new Error(`Expected (${expectedValue}) for key '${expectedKey}', got (${actualValue})`);\n    }\n}\nexport function expectArray(actual, expected) {\n    const actualLength = actual.length;\n    const expectedLength = expected.length;\n    if (actualLength != expectedLength) {\n        throw new Error(`Arrays are of different length: actual array length is ${actualLength} ` +\n            `and expected array length is ${expectedLength}`);\n    }\n    for (let i = 0; i < actualLength; i++) {\n        if (actual[i] instanceof Array && expected[i] instanceof Array)\n            expectArray(actual[i], expected[i]);\n        else if (actual[i] instanceof Object && expected[i] instanceof Object)\n            expectObject(actual[i], expected[i]);\n        else if (actual[i] != expected[i])\n            throw new Error(`Expected ${expected[i]} at position ${i}, got ${actual[i]}`);\n    }\n}\n/* Defines a test suite. */\nexport function category(category, tests_, options) {\n    var _a;\n    currentCategory = category;\n    tests_();\n    if (tests[currentCategory]) {\n        tests[currentCategory].clear = (_a = options === null || options === void 0 ? void 0 : options.clear) !== null && _a !== void 0 ? _a : true;\n        tests[currentCategory].timeout = options === null || options === void 0 ? void 0 : options.timeout;\n    }\n}\n/* Defines a function to be executed before the tests in this category are executed. */\nexport function before(before) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    tests[currentCategory].before = before;\n}\n/* Defines a function to be executed after the tests in this category are executed. */\nexport function after(after) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    tests[currentCategory].after = after;\n}\nfunction addNamespace(s, f) {\n    return s.replace(new RegExp(f.name, 'gi'), f.nqName);\n}\nexport function initAutoTests(package_, module) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function* () {\n        const packageId = package_.id;\n        if (wasRegistered[packageId])\n            return;\n        const moduleTests = module ? module.tests : tests;\n        if (moduleTests[autoTestsCatName] !== undefined ||\n            moduleTests[demoCatName] !== undefined ||\n            Object.keys(moduleTests).find((c) => c.startsWith(autoTestsCatName) || c.startsWith(coreCatName))) {\n            wasRegistered[packageId] = true;\n            return;\n        }\n        if (package_.name === 'DevTools' || (!!module && module._package.name === 'DevTools')) {\n            const testFunctions = DG.Func.find({ tags: ['dartTest'] });\n            for (const f of testFunctions) {\n                const arr = f.name.split(/\\s*\\|\\s*/g);\n                const name = (_a = arr.pop()) !== null && _a !== void 0 ? _a : f.name;\n                const cat = arr.length ? coreCatName + ': ' + arr.join(': ') : coreCatName;\n                if (moduleTests[cat] === undefined)\n                    moduleTests[cat] = { tests: [], clear: true };\n                moduleTests[cat].tests.push(new Test(cat, name, () => __awaiter(this, void 0, void 0, function* () { return yield f.apply(); }), { isAggregated: f.outputs.length > 0, timeout: 300000 }));\n            }\n        }\n        const moduleAutoTests = [];\n        const moduleDemo = [];\n        const moduleDetectors = [];\n        const packFunctions = yield grok.dapi.functions.filter(`package.id = \"${packageId}\"`).list();\n        const reg = new RegExp(/skip:\\s*([^,\\s]+)|wait:\\s*(\\d+)|cat:\\s*([^,\\s]+)|timeout:\\s*(\\d+)/g);\n        for (const f of packFunctions) {\n            const tests = f.options['test'];\n            const demo = f.options['demoPath'];\n            if ((tests && Array.isArray(tests) && tests.length)) {\n                for (let i = 0; i < tests.length; i++) {\n                    const res = tests[i].matchAll(reg);\n                    const map = {};\n                    Array.from(res).forEach((arr) => {\n                        if (arr[0].startsWith('skip'))\n                            map['skip'] = arr[1];\n                        else if (arr[0].startsWith('wait'))\n                            map['wait'] = parseInt(arr[2]);\n                        else if (arr[0].startsWith('cat'))\n                            map['cat'] = arr[3];\n                        else if (arr[0].startsWith('timeout'))\n                            map['timeout'] = parseInt(arr[4]);\n                    });\n                    const test = new Test(autoTestsCatName, tests.length === 1 ? f.name : `${f.name} ${i + 1}`, () => __awaiter(this, void 0, void 0, function* () {\n                        const res = yield grok.functions.eval(addNamespace(tests[i], f));\n                        if (map.wait)\n                            yield delay(map.wait);\n                        // eslint-disable-next-line no-throw-literal\n                        if (typeof res === 'boolean' && !res)\n                            throw `Failed: ${tests[i]}, expected true, got ${res}`;\n                    }), { skipReason: map.skip, timeout: map.timeout });\n                    if (map.cat) {\n                        const cat = autoTestsCatName + ': ' + map.cat;\n                        test.category = cat;\n                        if (moduleTests[cat] === undefined)\n                            moduleTests[cat] = { tests: [], clear: true };\n                        moduleTests[cat].tests.push(test);\n                    }\n                    else\n                        moduleAutoTests.push(test);\n                }\n            }\n            if (demo) {\n                const wait = f.options['demoWait'] ? parseInt(f.options['demoWait']) : undefined;\n                const test = new Test(demoCatName, f.friendlyName, () => __awaiter(this, void 0, void 0, function* () {\n                    grok.shell.lastError = '';\n                    yield f.apply();\n                    yield delay(wait ? wait : 2000);\n                    if (grok.shell.lastError)\n                        throw new Error(grok.shell.lastError);\n                }), { skipReason: f.options['demoSkip'] });\n                moduleDemo.push(test);\n            }\n            if (f.hasTag('semTypeDetector')) {\n                const test = new Test(detectorsCatName, f.friendlyName, () => __awaiter(this, void 0, void 0, function* () {\n                    const arr = [];\n                    for (const col of testData.clone().columns) {\n                        const res = yield f.apply([col]);\n                        arr.push(res || col.semType);\n                    }\n                    expect(arr.filter((i) => i).length, 1);\n                }), { skipReason: f.options['skipTest'] });\n                moduleDetectors.push(test);\n            }\n        }\n        wasRegistered[packageId] = true;\n        if (moduleAutoTests.length)\n            moduleTests[autoTestsCatName] = { tests: moduleAutoTests, clear: true };\n        if (moduleDemo.length)\n            moduleTests[demoCatName] = { tests: moduleDemo, clear: true };\n        if (moduleDetectors.length)\n            moduleTests[detectorsCatName] = { tests: moduleDetectors, clear: false };\n    });\n}\nfunction redefineConsole() {\n    const logs = [];\n    console.log = (...args) => {\n        logs.push(...args);\n        stdLog(...args);\n    };\n    console.info = (...args) => {\n        logs.push(...args);\n        stdInfo(...args);\n    };\n    console.warn = (...args) => {\n        logs.push(...args);\n        stdWarn(...args);\n    };\n    console.error = (...args) => {\n        logs.push(...args);\n        stdError(...args);\n    };\n    return logs;\n}\nfunction resetConsole() {\n    console.log = stdLog;\n    console.info = stdInfo;\n    console.warn = stdWarn;\n    console.error = stdError;\n}\nexport function runTests(options) {\n    var _a, _b, _c, _d, _e, _f;\n    var _g;\n    return __awaiter(this, void 0, void 0, function* () {\n        const package_ = (_b = (_a = grok.functions.getCurrentCall()) === null || _a === void 0 ? void 0 : _a.func) === null || _b === void 0 ? void 0 : _b.package;\n        yield initAutoTests(package_);\n        const results = [];\n        console.log(`Running tests`);\n        options !== null && options !== void 0 ? options : (options = {});\n        (_c = (_g = options).testContext) !== null && _c !== void 0 ? _c : (_g.testContext = new TestContext());\n        grok.shell.lastError = '';\n        const categories = [];\n        const logs = redefineConsole();\n        try {\n            for (const [key, value] of Object.entries(tests)) {\n                if ((!!(options === null || options === void 0 ? void 0 : options.category) && !key.toLowerCase().startsWith(options === null || options === void 0 ? void 0 : options.category.toLowerCase())) ||\n                    ((_d = options.exclude) === null || _d === void 0 ? void 0 : _d.some((c) => key.startsWith(c))))\n                    continue;\n                stdLog(`Started ${key} category`);\n                categories.push(key);\n                const skipped = (_e = value.tests) === null || _e === void 0 ? void 0 : _e.every((t) => { var _a; return (_a = t.options) === null || _a === void 0 ? void 0 : _a.skipReason; });\n                try {\n                    if (value.before && !skipped)\n                        yield value.before();\n                }\n                catch (x) {\n                    value.beforeStatus = getResult(x);\n                }\n                const t = (_f = value.tests) !== null && _f !== void 0 ? _f : [];\n                const res = [];\n                if (value.clear) {\n                    for (let i = 0; i < t.length; i++) {\n                        res.push(yield execTest(t[i], options === null || options === void 0 ? void 0 : options.test, logs, value.timeout, package_.name, options.verbose));\n                        grok.shell.closeAll();\n                        DG.Balloon.closeAll();\n                    }\n                }\n                else {\n                    for (let i = 0; i < t.length; i++)\n                        res.push(yield execTest(t[i], options === null || options === void 0 ? void 0 : options.test, logs, value.timeout, package_.name, options.verbose));\n                }\n                const data = res.filter((d) => d.result != 'skipped');\n                try {\n                    if (value.after && !skipped)\n                        yield value.after();\n                }\n                catch (x) {\n                    value.afterStatus = getResult(x);\n                }\n                // Clear after category\n                // grok.shell.closeAll();\n                // DG.Balloon.closeAll();\n                if (value.afterStatus)\n                    data.push({ category: key, name: 'after', result: value.afterStatus, success: false, ms: 0, skipped: false });\n                if (value.beforeStatus)\n                    data.push({ category: key, name: 'before', result: value.beforeStatus, success: false, ms: 0, skipped: false });\n                results.push(...data);\n            }\n        }\n        finally {\n            resetConsole();\n        }\n        if (options.testContext.catchUnhandled) {\n            yield delay(1000);\n            if (grok.shell.lastError.length > 0) {\n                results.push({\n                    category: 'Unhandled exceptions',\n                    name: 'exceptions',\n                    result: grok.shell.lastError, success: false, ms: 0, skipped: false\n                });\n            }\n        }\n        if (!options.test && results.length) {\n            const successful = results.filter((r) => r.success).length;\n            const skipped = results.filter((r) => r.skipped).length;\n            const failed = results.filter((r) => !r.success);\n            const packageName = package_.name;\n            for (const cat of categories) {\n                const res = results.filter((r) => r.category === cat);\n                const failed_ = res.filter((r) => !r.success).length;\n                const params = { success: failed_ === 0,\n                    passed: res.filter((r) => r.success).length,\n                    skipped: res.filter((r) => r.skipped).length,\n                    failed: failed_,\n                    type: 'package', packageName, category: cat };\n                grok.log.usage(`${packageName}: ${cat}`, params, `category-package ${packageName}: ${cat}`);\n            }\n            if (!options.category) {\n                const params = { success: failed.length === 0, passed: successful, skipped, failed: failed.length,\n                    type: 'package', packageName };\n                grok.log.usage(packageName, params, `package-package ${packageName}`);\n            }\n            if (options.testContext.report) {\n                const logger = new DG.Logger();\n                const description = 'Package @package tested: @successful successful, @skipped skipped, @failed failed tests';\n                const params = {\n                    successful: successful,\n                    skipped: skipped,\n                    failed: failed.length,\n                    package: package_\n                };\n                for (const r of failed)\n                    Object.assign(params, { [`${r.category} | ${r.name}`]: r.result });\n                logger.log(description, params, 'package-tested');\n            }\n        }\n        return results;\n    });\n}\nfunction getResult(x) {\n    return `${x.toString()}\\n${x.stack ? DG.Logger.translateStackTrace(x.stack) : ''}`;\n}\nfunction execTest(t, predicate, logs, categoryTimeout, packageName, verbose) {\n    var _a, _b, _c, _d, _e, _f;\n    return __awaiter(this, void 0, void 0, function* () {\n        logs.length = 0;\n        let r;\n        let type = 'package';\n        const filter = predicate != undefined && (t.name.toLowerCase() !== predicate.toLowerCase());\n        const skip = ((_a = t.options) === null || _a === void 0 ? void 0 : _a.skipReason) || filter;\n        const skipReason = filter ? 'skipped' : (_b = t.options) === null || _b === void 0 ? void 0 : _b.skipReason;\n        if (!skip)\n            stdLog(`Started ${t.category} ${t.name}`);\n        const start = Date.now();\n        try {\n            if (skip)\n                r = { success: true, result: skipReason, ms: 0, skipped: true };\n            else {\n                let timeout_ = ((_c = t.options) === null || _c === void 0 ? void 0 : _c.timeout) === STANDART_TIMEOUT &&\n                    categoryTimeout ? categoryTimeout : (_d = t.options) === null || _d === void 0 ? void 0 : _d.timeout;\n                timeout_ = DG.Test.isInBenchmark && timeout_ === STANDART_TIMEOUT ? BENCHMARK_TIMEOUT : timeout_;\n                r = { success: true, result: (_e = yield timeout(t.test, timeout_)) !== null && _e !== void 0 ? _e : 'OK', ms: 0, skipped: false };\n            }\n        }\n        catch (x) {\n            r = { success: false, result: getResult(x), ms: 0, skipped: false };\n        }\n        if (((_f = t.options) === null || _f === void 0 ? void 0 : _f.isAggregated) && r.result.constructor === DG.DataFrame) {\n            const col = r.result.col('success');\n            type = 'core';\n            if (col)\n                r.success = col.stats.sum === col.length;\n            if (!verbose) {\n                const df = r.result;\n                df.columns.remove('stack');\n                df.rows.removeWhere((r) => r.get('success'));\n                r.result = df;\n            }\n            r.result = r.result.toCsv();\n        }\n        r.logs = logs.join('\\n');\n        r.ms = Date.now() - start;\n        if (!skip)\n            stdLog(`Finished ${t.category} ${t.name} for ${r.ms} ms`);\n        r.category = t.category;\n        r.name = t.name;\n        if (!filter) {\n            let params = { 'success': r.success, 'result': r.result, 'ms': r.ms, 'skipped': r.skipped,\n                'type': type, packageName, 'category': t.category, 'test': t.name, 'logs': r.logs };\n            if (r.result.constructor == Object) {\n                const res = Object.keys(r.result).reduce((acc, k) => (Object.assign(Object.assign({}, acc), { ['result.' + k]: r.result[k] })), {});\n                params = Object.assign(Object.assign({}, params), res);\n            }\n            grok.log.usage(`${packageName}: ${t.category}: ${t.name}`, params, `test-${type} ${packageName}: ${t.category}: ${t.name}`);\n        }\n        return r;\n    });\n}\n/* Waits [ms] milliseconds */\nexport function delay(ms) {\n    return __awaiter(this, void 0, void 0, function* () {\n        yield new Promise((r) => setTimeout(r, ms));\n    });\n}\nexport function awaitCheck(checkHandler, error = 'Timeout exceeded', wait = 500, interval = 50) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return new Promise((resolve, reject) => {\n            setTimeout(() => {\n                clearInterval(intervalId);\n                reject(new Error(error));\n            }, wait);\n            // @ts-ignore\n            const intervalId = setInterval(() => {\n                if (checkHandler()) {\n                    clearInterval(intervalId);\n                    resolve();\n                }\n            }, interval);\n        });\n    });\n}\n// Returns test execution result or an error in case of timeout\nfunction timeout(func, testTimeout) {\n    return __awaiter(this, void 0, void 0, function* () {\n        let timeout = null;\n        const timeoutPromise = new Promise((_, reject) => {\n            timeout = setTimeout(() => {\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject('EXECUTION TIMEOUT');\n            }, testTimeout);\n        });\n        try {\n            return yield Promise.race([func(), timeoutPromise]);\n        }\n        finally {\n            if (timeout)\n                clearTimeout(timeout);\n        }\n    });\n}\nexport function isDialogPresent(dialogTitle) {\n    const dialogs = DG.Dialog.getOpenDialogs();\n    for (let i = 0; i < dialogs.length; i++) {\n        if (dialogs[i].title == dialogTitle)\n            return true;\n    }\n    return false;\n}\n/** Expects an asynchronous {@link action} to throw an exception. Use {@link check} to perform\n * deeper inspection of the exception if necessary.\n * @param  {function(): Promise<void>} action\n * @param  {function(any): boolean} check\n * @return {Promise<void>}\n */\nexport function expectExceptionAsync(action, check) {\n    return __awaiter(this, void 0, void 0, function* () {\n        let caught = false;\n        let checked = false;\n        try {\n            yield action();\n        }\n        catch (e) {\n            caught = true;\n            checked = !check || check(e);\n        }\n        finally {\n            if (!caught)\n                throw new Error('An exception is expected but not thrown');\n            if (!checked)\n                throw new Error('An expected exception is thrown, but it does not satisfy the condition');\n        }\n    });\n}\nconst catDF = DG.DataFrame.fromColumns([DG.Column.fromStrings('col', ['val1', 'val2', 'val3'])]);\n/**\n * Universal test for viewers. It search viewers in DOM by tags: canvas, svg, img, input, h1, a\n * @param  {string} v Viewer name\n * @param  {DG.DataFrame} df Dataframe to use. Should have at least 3 rows\n * @param  {boolean} options.detectSemanticTypes Specify whether to detect semantic types or not\n * @param  {boolean} options.readOnly If set to true, the dataframe will not be modified during the test\n * @param  {boolean} options.arbitraryDfTest If set to false, test on arbitrary dataframe\n * (one categorical column) will not be performed\n * @param  {object} options List of options (optional)\n * @return {Promise<void>} The test is considered successful if it completes without errors\n */\nexport function testViewer(v, df, options) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function* () {\n        const createViewer = (tv, v, packageName) => __awaiter(this, void 0, void 0, function* () {\n            let res;\n            if (packageName) {\n                res = (yield tv.dataFrame.plot.fromType(v));\n                tv.dockManager.dock(res);\n            }\n            else\n                res = tv.addViewer(v);\n            return res;\n        });\n        if (options === null || options === void 0 ? void 0 : options.detectSemanticTypes)\n            yield grok.data.detectSemanticTypes(df);\n        let tv = grok.shell.addTableView(df);\n        const viewerName = `[name=viewer-${v.replace(/\\s+/g, '-')} i]`;\n        // const selector = `${viewerName} canvas,${viewerName} svg,${viewerName} img,\n        //   ${viewerName} input,${viewerName} h1,${viewerName} a,${viewerName} .d4-viewer-error`;\n        const selector = ['div.ui-box' /* root */, 'canvas', 'svg', 'img', 'input', 'h1', 'a', '.d4-viewer-error']\n            .map((selTag) => `${viewerName} ${selTag}`).join(', ');\n        const res = [];\n        try {\n            let viewer = yield createViewer(tv, v, options === null || options === void 0 ? void 0 : options.packageName);\n            yield awaitCheck(() => document.querySelector(selector) !== null, 'cannot load viewer', 3000);\n            const tag = (_a = document.querySelector(selector)) === null || _a === void 0 ? void 0 : _a.tagName;\n            res.push(Array.from(tv.viewers).length);\n            if (!(options === null || options === void 0 ? void 0 : options.readOnly)) {\n                Array.from(df.row(0).cells).forEach((c) => c.value = null);\n                const num = df.rowCount < 20 ? Math.floor(df.rowCount / 2) : 10;\n                df.rows.select((row) => row.idx >= 0 && row.idx < num);\n                yield delay(50);\n                for (let i = num; i < num * 2; i++)\n                    df.filter.set(i, false);\n                yield delay(50);\n                df.currentRowIdx = 1;\n                const df1 = df.clone();\n                df.columns.names().slice(0, Math.ceil(df.columns.length / 2)).forEach((c) => df.columns.remove(c));\n                yield delay(100);\n                tv.dataFrame = df1;\n            }\n            let optns;\n            try {\n                optns = viewer.getOptions(true).look;\n            }\n            catch (err) {\n                throw new Error(`Viewer's .getOptions() error.`, { cause: err });\n            }\n            let props;\n            try {\n                props = viewer.getProperties();\n            }\n            catch (err) {\n                throw new Error(`Viewer's .getProperties() error.`, { cause: err });\n            }\n            const newProps = {};\n            Object.keys(optns).filter((k) => typeof optns[k] === 'boolean').forEach((k) => newProps[k] = !optns[k]);\n            props.filter((p) => p.choices !== null)\n                .forEach((p) => newProps[p.name] = p.choices.find((c) => c !== optns[p.name]));\n            viewer.setOptions(newProps);\n            yield delay(300);\n            const layout = tv.saveLayout();\n            const oldProps = viewer.getOptions().look;\n            tv.resetLayout();\n            res.push(Array.from(tv.viewers).length);\n            tv.loadLayout(layout);\n            const selector1 = `${viewerName} ${tag}`;\n            yield awaitCheck(() => document.querySelector(selector1) !== null, 'cannot load viewer from layout', 3000);\n            res.push(Array.from(tv.viewers).length);\n            viewer = Array.from(tv.viewers).find((v) => v.type !== 'Grid');\n            expectArray(res, [2, 1, 2]);\n            expect(JSON.stringify(viewer.getOptions().look), JSON.stringify(oldProps));\n            if ((options === null || options === void 0 ? void 0 : options.arbitraryDfTest) !== false) {\n                if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                    yield options.awaitViewer(viewer);\n                grok.shell.closeAll();\n                yield delay(100);\n                tv = grok.shell.addTableView(catDF);\n                try {\n                    viewer = yield createViewer(tv, v, options === null || options === void 0 ? void 0 : options.packageName);\n                }\n                catch (e) {\n                    grok.shell.closeAll();\n                    DG.Balloon.closeAll();\n                    return;\n                }\n                yield awaitCheck(() => document.querySelector(selector) !== null, 'cannot load viewer on arbitrary dataset', 3000);\n            }\n            if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                yield options.awaitViewer(viewer);\n        }\n        finally {\n            // closeAll() is handling by common test workflow\n            // grok.shell.closeAll();\n            // DG.Balloon.closeAll();\n        }\n    });\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAG3C,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAC/B,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACzC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAE7C,MAAM,CAAC,MAAM,KAAK,GAKd,EAAE,CAAC;AAEP,MAAM,gBAAgB,GAAG,YAAY,CAAC;AACtC,MAAM,WAAW,GAAG,MAAM,CAAC;AAC3B,MAAM,gBAAgB,GAAG,WAAW,CAAC;AACrC,MAAM,WAAW,GAAG,MAAM,CAAC;AAC3B,MAAM,aAAa,GAA6B,EAAE,CAAC;AACnD,MAAM,CAAC,IAAI,eAAuB,CAAC;AAEnC,MAAM,KAAW,MAAM,CAKtB;AALD,WAAiB,MAAM;IACrB,SAAgB,OAAO,CAAC,KAAU,EAAE,IAAa;QAC/C,IAAI,KAAK,IAAI,IAAI;YACf,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;IACpE,CAAC;IAHe,cAAO,UAGtB,CAAA;AACH,CAAC,EALgB,MAAM,KAAN,MAAM,QAKtB;AAcD,MAAM,OAAO,WAAW;IAItB,YAAY,cAAwB,EAAE,MAAgB;QAHtD,mBAAc,GAAG,IAAI,CAAC;QACtB,WAAM,GAAG,KAAK,CAAC;QAGb,IAAI,cAAc,KAAK,SAAS;YAAE,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACvE,IAAI,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACjD,CAAC;IAAA,CAAC;CACH;AAED,MAAM,OAAO,IAAI;IAMf,YAAY,QAAgB,EAAE,IAAY,EAAE,IAAwB,EAAE,OAAqB;;QACzF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,OAAO,aAAP,OAAO,cAAP,OAAO,IAAP,OAAO,GAAK,EAAE,EAAC;QACf,MAAA,OAAO,CAAC,OAAO,oCAAf,OAAO,CAAC,OAAO,GAAK,gBAAgB,EAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,GAAuB,EAAE;YACnC,OAAO,IAAI,OAAO,CAAC,CAAO,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC3C,IAAI,MAAM,GAAG,EAAE,CAAC;gBAChB,IAAI;oBACF,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;iBACvB;gBAAC,OAAO,CAAM,EAAE;oBACf,MAAM,CAAC,CAAC,CAAC,CAAC;iBACX;gBACD,OAAO,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC,CAAA,CAAC,CAAC;QACL,CAAC,CAAA,CAAC;IACJ,CAAC;CACF;AAED,MAAM,UAAgB,SAAS,CAAI,KAAoB,EACrD,OAA0B,EAAE,OAAmB,EAAE,KAAa,CAAC,EAAE,SAAiB,SAAS;;QAE3F,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAO,EAAE,EAAE;gBACtC,IAAI;oBACF,OAAO,CAAC,IAAI,CAAC,CAAC;oBACd,OAAO,CAAC,IAAI,CAAC,CAAC;iBACf;gBAAC,OAAO,CAAC,EAAE;oBACV,MAAM,CAAC,CAAC,CAAC,CAAC;iBACX;gBACD,oDAAoD;gBACpD,GAAG,CAAC,WAAW,EAAE,CAAC;gBAClB,YAAY,CAAC,OAAO,CAAC,CAAC;YACxB,CAAC,CAAC,CAAC;YACH,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,GAAG,CAAC,WAAW,EAAE,CAAC;gBAClB,wDAAwD;gBACxD,MAAM,CAAC,MAAM,CAAC,CAAC;YACjB,CAAC,EAAE,EAAE,CAAC,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CAAA;AAED,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,IAAwB,EAAE,OAAqB;IAChF,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,IAAI,SAAS;QAC3C,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;IACpC,KAAK,CAAC,eAAe,CAAC,CAAC,KAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACrF,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,MAAM,CAAC,MAAW,EAAE,WAAgB,IAAI,EAAE,KAAc;IACtE,IAAI,KAAK;QACP,KAAK,GAAG,GAAG,KAAK,IAAI,CAAC;;QAClB,KAAK,GAAG,EAAE,CAAC;IAChB,IAAI,MAAM,KAAK,QAAQ;QACrB,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,aAAa,QAAQ,WAAW,MAAM,GAAG,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,QAAgB,EAAE,SAAS,GAAG,KAAK,EAAE,KAAc;IAC7F,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,iBAAiB,IAAI,QAAQ,KAAK,MAAM,CAAC,iBAAiB,CAAC;QAC9E,CAAC,MAAM,KAAK,MAAM,CAAC,iBAAiB,IAAI,QAAQ,KAAK,MAAM,CAAC,iBAAiB,CAAC;QAC9E,CAAC,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,QAAQ,KAAK,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC1F,OAAO;IACT,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,SAAS,CAAC;IACzD,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,iBAAiB,SAAS,GAAG,CAAC,CAAC;IACpE,IAAI,CAAC,QAAQ;QACX,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,SAAS,MAAM,iBAAiB,SAAS,GAAG,CAAC,CAAC;AACtF,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAoB,EAAE,QAAsB,EAAE,KAAc;IACtF,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC3C,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC;IACvC,MAAM,CAAC,cAAc,EAAE,gBAAgB,EAAE,GAAG,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,aAAa,CAAC,CAAC;IAEtE,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE;QACrC,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,YAAY,IAAI,IAAI;YACtB,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,CAAC,IAAI,YAAY,CAAC,CAAC;QACrD,IAAI,YAAY,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI;YAClC,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,CAAC,IAAI,kBAAkB,MAAM,CAAC,IAAI,QAAQ,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;QACjG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxC,IAAI,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK;gBAC9B,WAAW,CAAC,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;iBAC5C,IAAI,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,SAAS;gBACvC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;;gBAE/C,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;SACrC;KACF;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,MAA8B,EAAE,QAAgC;IAC3F,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QACnE,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,WAAW,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,sBAAsB,WAAW,aAAa,CAAC,CAAC;QAElE,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,WAAW,YAAY,KAAK,IAAI,aAAa,YAAY,KAAK;YAChE,WAAW,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACrC,IAAI,WAAW,YAAY,MAAM,IAAI,aAAa,YAAY,MAAM;YACvE,YAAY,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACtC,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;YACrE,WAAW,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACrC,IAAI,WAAW,IAAI,aAAa;YACnC,MAAM,IAAI,KAAK,CAAC,aAAa,aAAa,cAAc,WAAW,WAAW,WAAW,GAAG,CAAC,CAAC;KACjG;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAsB,EAAE,QAAwB;IAC1E,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC;IAEvC,IAAI,YAAY,IAAI,cAAc,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,0DAA0D,YAAY,GAAG;YACvF,gCAAgC,cAAc,EAAE,CAAC,CAAC;KACrD;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;QACrC,IAAI,MAAM,CAAC,CAAC,CAAC,YAAY,KAAK,IAAI,QAAQ,CAAC,CAAC,CAAC,YAAY,KAAK;YAC5D,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aACjC,IAAI,MAAM,CAAC,CAAC,CAAC,YAAY,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,YAAY,MAAM;YACnE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aAClC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KACjF;AACH,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,MAAkB,EAAE,OAAyB;;IACtF,eAAe,GAAG,QAAQ,CAAC;IAC3B,MAAM,EAAE,CAAC;IACT,IAAI,KAAK,CAAC,eAAe,CAAC,EAAE;QAC1B,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,mCAAI,IAAI,CAAC;QACtD,KAAK,CAAC,eAAe,CAAC,CAAC,OAAO,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,CAAC;KACnD;AACH,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,MAAM,CAAC,MAA2B;IAChD,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;AACzC,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,KAAK,CAAC,KAA0B;IAC9C,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;AACvC,CAAC;AAED,SAAS,YAAY,CAAC,CAAS,EAAE,CAAU;IACzC,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAgB,aAAa,CAAC,QAAoB,EAAE,MAAY;;;QACpE,MAAM,SAAS,GAAG,QAAQ,CAAC,EAAE,CAAC;QAC9B,IAAI,aAAa,CAAC,SAAS,CAAC;YAAE,OAAO;QACrC,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QAClD,IAAI,WAAW,CAAC,gBAAgB,CAAC,KAAK,SAAS;YAC3C,WAAW,CAAC,WAAW,CAAC,KAAK,SAAS;YACtC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE;YACrG,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;YAChC,OAAO;SACR;QACD,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,UAAU,CAAC,EAAE;YACrF,MAAM,aAAa,GAAc,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,CAAC,UAAU,CAAC,EAAC,CAAC,CAAC;YACpE,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE;gBAC7B,MAAM,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBACtC,MAAM,IAAI,GAAG,MAAA,GAAG,CAAC,GAAG,EAAE,mCAAI,CAAC,CAAC,IAAI,CAAC;gBACjC,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,GAAG,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;gBAC3E,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,SAAS;oBAChC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;gBAC9C,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,EAC5C,GAAS,EAAE,gDAAC,OAAA,MAAM,CAAC,CAAC,KAAK,EAAE,CAAA,GAAA,EAAE,EAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAC,CAAC,CAAC,CAAC;aACxF;SACF;QACD,MAAM,eAAe,GAAG,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,MAAM,eAAe,GAAG,EAAE,CAAC;QAC3B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAC7F,MAAM,GAAG,GAAG,IAAI,MAAM,CAAC,oEAAoE,CAAC,CAAC;QAC7F,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE;YAC7B,MAAM,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAChC,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACnC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;gBACnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACrC,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,CAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;oBAC/C,MAAM,GAAG,GAAmE,EAAE,CAAC;oBAC/E,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;wBAC9B,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;4BAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;6BAC/C,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;4BAAE,GAAG,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;6BAC9D,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;4BAAE,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;6BAClD,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC;4BAAE,GAAG,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC3E,CAAC,CAAC,CAAC;oBACH,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,GAAS,EAAE;wBACrG,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBACjE,IAAI,GAAG,CAAC,IAAI;4BAAE,MAAM,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpC,4CAA4C;wBAC5C,IAAI,OAAO,GAAG,KAAK,SAAS,IAAI,CAAC,GAAG;4BAAE,MAAM,WAAW,KAAK,CAAC,CAAC,CAAC,wBAAwB,GAAG,EAAE,CAAC;oBAC/F,CAAC,CAAA,EAAE,EAAC,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAC,CAAC,CAAC;oBACjD,IAAI,GAAG,CAAC,GAAG,EAAE;wBACX,MAAM,GAAG,GAAW,gBAAgB,GAAG,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC;wBACtD,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;wBACpB,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,SAAS;4BAChC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;wBAC9C,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBACnC;;wBACC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC9B;aACF;YACD,IAAI,IAAI,EAAE;gBACR,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;gBACjF,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,YAAY,EAAE,GAAS,EAAE;oBAC5D,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;oBAC1B,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC;oBAChB,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;oBAChC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS;wBACtB,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC1C,CAAC,CAAA,EAAE,EAAC,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAC,CAAC,CAAC;gBACxC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACvB;YACD,IAAI,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE;gBAC/B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,YAAY,EAAE,GAAS,EAAE;oBACjE,MAAM,GAAG,GAAG,EAAE,CAAC;oBACf,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE;wBAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;wBACjC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;qBAC9B;oBACD,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;gBACzC,CAAC,CAAA,EAAE,EAAC,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAC,CAAC,CAAC;gBACxC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC5B;SACF;QACD,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;QAChC,IAAI,eAAe,CAAC,MAAM;YACxB,WAAW,CAAC,gBAAgB,CAAC,GAAG,EAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;QACxE,IAAI,UAAU,CAAC,MAAM;YACnB,WAAW,CAAC,WAAW,CAAC,GAAG,EAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;QAC9D,IAAI,eAAe,CAAC,MAAM;YACxB,WAAW,CAAC,gBAAgB,CAAC,GAAG,EAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC;;CAC1E;AAED,SAAS,eAAe;IACtB,MAAM,IAAI,GAAU,EAAE,CAAC;IACvB,OAAO,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACxB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAClB,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IACpB,CAAC,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,YAAY;IACnB,OAAO,CAAC,GAAG,GAAG,MAAM,CAAC;IACrB,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;IACvB,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;IACvB,OAAO,CAAC,KAAK,GAAG,QAAQ,CAAC;AAC3B,CAAC;AAED,MAAM,UAAgB,QAAQ,CAAC,OACuE;;;;QACpG,MAAM,QAAQ,GAAG,MAAA,MAAA,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,0CAAE,IAAI,0CAAE,OAAO,CAAC;QAChE,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC9B,MAAM,OAAO,GACuD,EAAE,CAAC;QACvE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC7B,OAAO,aAAP,OAAO,cAAP,OAAO,IAAP,OAAO,GAAK,EAAE,EAAC;QACf,YAAA,OAAQ,EAAC,WAAW,uCAAX,WAAW,GAAK,IAAI,WAAW,EAAE,EAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;QAC1B,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,eAAe,EAAE,CAAC;QAC/B,IAAI;YACF,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAChD,IAAI,CAAC,CAAC,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAA,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;qBACzF,MAAA,OAAO,CAAC,OAAO,0CAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;oBAC/C,SAAS;gBACX,MAAM,CAAC,WAAW,GAAG,WAAW,CAAC,CAAC;gBAClC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACrB,MAAM,OAAO,GAAG,MAAA,KAAK,CAAC,KAAK,0CAAE,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,WAAC,OAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,CAAA,EAAA,CAAC,CAAC;gBACjE,IAAI;oBACF,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,OAAO;wBAC1B,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;iBACxB;gBAAC,OAAO,CAAM,EAAE;oBACf,KAAK,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;iBACnC;gBACD,MAAM,CAAC,GAAG,MAAA,KAAK,CAAC,KAAK,mCAAI,EAAE,CAAC;gBAC5B,MAAM,GAAG,GAAG,EAAE,CAAC;gBACf,IAAI,KAAK,CAAC,KAAK,EAAE;oBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;wBACjC,GAAG,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;wBACnG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;wBACtB,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;qBACvB;iBACF;qBAAM;oBACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE;wBAC/B,GAAG,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;iBACtG;gBACD,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;gBACtD,IAAI;oBACF,IAAI,KAAK,CAAC,KAAK,IAAI,CAAC,OAAO;wBACzB,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;iBACvB;gBAAC,OAAO,CAAM,EAAE;oBACf,KAAK,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;iBAClC;gBACD,uBAAuB;gBACvB,yBAAyB;gBACzB,yBAAyB;gBACzB,IAAI,KAAK,CAAC,WAAW;oBACnB,IAAI,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;gBAC9G,IAAI,KAAK,CAAC,YAAY;oBACpB,IAAI,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;gBAChH,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;aACvB;SACF;gBAAS;YACR,YAAY,EAAE,CAAC;SAChB;QACD,IAAI,OAAO,CAAC,WAAW,CAAC,cAAc,EAAE;YACtC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;YAClB,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;gBACnC,OAAO,CAAC,IAAI,CAAC;oBACX,QAAQ,EAAE,sBAAsB;oBAChC,IAAI,EAAE,YAAY;oBAClB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK;iBACpE,CAAC,CAAC;aACJ;SACF;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE;YACnC,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;YAC3D,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;YACxD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC;YAClC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE;gBAC5B,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,GAAG,CAAC,CAAC;gBACtD,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;gBACrD,MAAM,MAAM,GAAG,EAAC,OAAO,EAAE,OAAO,KAAK,CAAC;oBACpC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM;oBAC3C,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM;oBAC5C,MAAM,EAAE,OAAO;oBACf,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,EAAC,CAAC;gBAC/C,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,WAAW,KAAK,GAAG,EAAE,EACrC,MAAM,EAAE,oBAAoB,WAAW,KAAK,GAAG,EAAE,CAAC,CAAC;aACtD;YACD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;gBACrB,MAAM,MAAM,GAAG,EAAC,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM;oBAC9F,IAAI,EAAE,SAAS,EAAE,WAAW,EAAC,CAAC;gBAChC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,mBAAmB,WAAW,EAAE,CAAC,CAAC;aACvE;YACD,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE;gBAC9B,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBAC/B,MAAM,WAAW,GAAG,yFAAyF,CAAC;gBAC9G,MAAM,MAAM,GAAG;oBACb,UAAU,EAAE,UAAU;oBACtB,OAAO,EAAE,OAAO;oBAChB,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,OAAO,EAAE,QAAQ;iBAClB,CAAC;gBACF,KAAK,MAAM,CAAC,IAAI,MAAM;oBAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAC,CAAC,CAAC;gBACzF,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC;aACnD;SACF;QACD,OAAO,OAAO,CAAC;;CAChB;AAED,SAAS,SAAS,CAAC,CAAM;IACvB,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AACrF,CAAC;AAED,SAAe,QAAQ,CAAC,CAAO,EAAE,SAA6B,EAAE,IAAW,EACzE,eAAwB,EAAE,WAAoB,EAAE,OAAiB;;;QACjE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAiH,CAAC;QACtH,IAAI,IAAI,GAAW,SAAS,CAAC;QAC7B,MAAM,MAAM,GAAG,SAAS,IAAI,SAAS,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,KAAI,MAAM,CAAC;QAC7C,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,CAAC;QAC9D,IAAI,CAAC,IAAI;YACP,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,IAAI;YACF,IAAI,IAAI;gBACN,CAAC,GAAG,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAW,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC,CAAC;iBAC5D;gBACH,IAAI,QAAQ,GAAG,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,OAAO,MAAK,gBAAgB;oBACpD,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,MAAA,CAAC,CAAC,OAAO,0CAAE,OAAQ,CAAC;gBAC1D,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,QAAQ,KAAK,gBAAgB,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC;gBACjG,CAAC,GAAG,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAA,MAAM,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,mCAAI,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC;aAC7F;SACF;QAAC,OAAO,CAAM,EAAE;YACf,CAAC,GAAG,EAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC;SACnE;QACD,IAAI,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,YAAY,KAAI,CAAC,CAAC,MAAM,CAAC,WAAW,KAAK,EAAE,CAAC,SAAS,EAAE;YACpE,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,GAAG,MAAM,CAAC;YACd,IAAI,GAAG;gBACL,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,MAAM,CAAC;YAC3C,IAAI,CAAC,OAAO,EAAE;gBACZ,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC;gBACpB,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAC3B,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC7C,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC;aACf;YACD,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;SAC7B;QACD,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,IAAI;YACP,MAAM,CAAC,YAAY,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;QACxB,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;QAChB,IAAI,CAAC,MAAM,EAAE;YACX,IAAI,MAAM,GAAG,EAAC,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,OAAO;gBACtF,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,EAAC,CAAC;YACrF,IAAI,CAAC,CAAC,MAAM,CAAC,WAAW,IAAI,MAAM,EAAE;gBAClC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,iCAAK,GAAG,KAAE,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAE,EAAE,EAAE,CAAC,CAAC;gBACnG,MAAM,mCAAO,MAAM,GAAK,GAAG,CAAC,CAAC;aAC9B;YACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,IAAI,EAAE,EACvD,MAAM,EAAE,QAAQ,IAAI,IAAI,WAAW,KAAK,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;SACpE;QACD,OAAO,CAAC,CAAC;;CACV;AAED,6BAA6B;AAC7B,MAAM,UAAgB,KAAK,CAAC,EAAU;;QACpC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC9C,CAAC;CAAA;AAED,MAAM,UAAgB,UAAU,CAAC,YAA2B,EAC1D,QAAgB,kBAAkB,EAAE,OAAe,GAAG,EAAE,WAAmB,EAAE;;QAC7E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,UAAU,CAAC,GAAG,EAAE;gBACd,aAAa,CAAC,UAAU,CAAC,CAAC;gBAC1B,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAC3B,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,aAAa;YACb,MAAM,UAAU,GAAY,WAAW,CAAC,GAAG,EAAE;gBAC3C,IAAI,YAAY,EAAE,EAAE;oBAClB,aAAa,CAAC,UAAU,CAAC,CAAC;oBAC1B,OAAO,EAAE,CAAC;iBACX;YACH,CAAC,EAAE,QAAQ,CAAC,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC;CAAA;AAED,+DAA+D;AAC/D,SAAe,OAAO,CAAC,IAAwB,EAAE,WAAmB;;QAClE,IAAI,OAAO,GAAQ,IAAI,CAAC;QACxB,MAAM,cAAc,GAAG,IAAI,OAAO,CAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YACpD,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBACxB,wDAAwD;gBACxD,MAAM,CAAC,mBAAmB,CAAC,CAAC;YAC9B,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,IAAI;YACF,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC;SACrD;gBAAS;YACR,IAAI,OAAO;gBACT,YAAY,CAAC,OAAO,CAAC,CAAC;SACzB;IACH,CAAC;CAAA;AAED,MAAM,UAAU,eAAe,CAAC,WAAmB;IACjD,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACvC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,WAAW;YACjC,OAAO,IAAI,CAAC;KACf;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAgB,oBAAoB,CAAC,MAA2B,EACpE,KAAmC;;QACnC,IAAI,MAAM,GAAY,KAAK,CAAC;QAC5B,IAAI,OAAO,GAAY,KAAK,CAAC;QAC7B,IAAI;YACF,MAAM,MAAM,EAAE,CAAC;SAChB;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,GAAG,IAAI,CAAC;YACd,OAAO,GAAG,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;SAC9B;gBAAS;YACR,IAAI,CAAC,MAAM;gBACT,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC7D,IAAI,CAAC,OAAO;gBACV,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;SAC7F;IACH,CAAC;CAAA;AAED,MAAM,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjG;;;;;;;;;;GAUG;AACH,MAAM,UAAgB,UAAU,CAAC,CAAS,EAAE,EAAgB,EAAE,OAG7D;;;QACC,MAAM,YAAY,GAAG,CAAO,EAAgB,EAAE,CAAS,EAAE,WAAoB,EAAsB,EAAE;YACnG,IAAI,GAAc,CAAC;YACnB,IAAI,WAAW,EAAE;gBACf,GAAG,IAAG,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAc,CAAA,CAAC;gBACvD,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC1B;;gBACC,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACxB,OAAO,GAAG,CAAC;QACb,CAAC,CAAA,CAAC;QAEF,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,mBAAmB;YAAE,MAAM,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;QAC1E,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QACrC,MAAM,UAAU,GAAG,gBAAgB,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC;QAC/D,8EAA8E;QAC9E,0FAA0F;QAC1F,MAAM,QAAQ,GAAG,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,kBAAkB,CAAC;aACvG,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,UAAU,IAAI,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,EAAE,CAAC;QACf,IAAI;YACF,IAAI,MAAM,GAAG,MAAM,YAAY,CAAC,EAAE,EAAE,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,CAAC,CAAC;YAC7D,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC9D,oBAAoB,EAAE,IAAI,CAAC,CAAC;YAC9B,MAAM,GAAG,GAAG,MAAA,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,0CAAE,OAAO,CAAC;YACtD,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;YACxC,IAAI,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAA,EAAE;gBACtB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAK,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;gBAC/D,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAChE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;gBAC/D,MAAM,KAAK,CAAC,EAAE,CAAC,CAAC;gBAChB,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE;oBAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBAC5D,MAAM,KAAK,CAAC,EAAE,CAAC,CAAC;gBAChB,EAAE,CAAC,aAAa,GAAG,CAAC,CAAC;gBACrB,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC;gBACvB,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBACxG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;gBACjB,EAAE,CAAC,SAAS,GAAG,GAAG,CAAC;aACpB;YACD,IAAI,KAA2B,CAAC;YAChC,IAAI;gBACF,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;aACtC;YAAC,OAAO,GAAQ,EAAE;gBACjB,MAAM,IAAI,KAAK,CAAC,+BAA+B,EAAE,EAAC,KAAK,EAAE,GAAG,EAAC,CAAC,CAAC;aAChE;YACD,IAAI,KAAoB,CAAC;YACzB,IAAI;gBACF,KAAK,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;aAChC;YAAC,OAAO,GAAQ,EAAE;gBACjB,MAAM,IAAI,KAAK,CAAC,kCAAkC,EAAE,EAAC,KAAK,EAAE,GAAG,EAAC,CAAC,CAAC;aACnE;YACD,MAAM,QAAQ,GAAqC,EAAE,CAAC;YACtD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACxG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,CAAC;iBACjD,OAAO,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAE,CAAC,CAAC;YACpG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YAC5B,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,MAAM,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC;YAC1C,EAAE,CAAC,WAAW,EAAE,CAAC;YACjB,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;YACxC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YACtB,MAAM,SAAS,GAAG,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC;YACzC,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,IAAI,EAC/D,gCAAgC,EAAE,IAAI,CAAC,CAAC;YAC1C,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;YACxC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAE,CAAC;YACrE,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC3E,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe,MAAK,KAAK,EAAE;gBACtC,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;oBAAE,MAAM,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBAC5D,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;gBAEtB,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;gBACjB,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;gBACpC,IAAI;oBACF,MAAM,GAAG,MAAM,YAAY,CAAC,EAAE,EAAE,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,CAAC,CAAC;iBAC1D;gBAAC,OAAO,CAAC,EAAE;oBACV,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;oBACtB,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtB,OAAO;iBACR;gBACD,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC9D,yCAAyC,EAAE,IAAI,CAAC,CAAC;aACpD;YACD,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;gBAAE,MAAM,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;SAC7D;gBAAS;YACR,iDAAiD;YACjD,yBAAyB;YACzB,yBAAyB;SAC1B;;CACF","sourcesContent":["import * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\nimport {Observable} from 'rxjs';\nimport {testData} from './dataframe-utils';\nimport Timeout = NodeJS.Timeout;\n\nconst STANDART_TIMEOUT = 30000;\nconst BENCHMARK_TIMEOUT = 10800000;\n\nconst stdLog = console.log.bind(console);\nconst stdInfo = console.info.bind(console);\nconst stdWarn = console.warn.bind(console);\nconst stdError = console.error.bind(console);\n\nexport const tests: {\n  [key: string]: {\n    tests?: Test[], before?: () => Promise<void>, after?: () => Promise<void>,\n    beforeStatus?: string, afterStatus?: string, clear?: boolean, timeout?: number\n  }\n} = {};\n\nconst autoTestsCatName = 'Auto Tests';\nconst demoCatName = 'Demo';\nconst detectorsCatName = 'Detectors';\nconst coreCatName = 'Core';\nconst wasRegistered: {[key: string]: boolean} = {};\nexport let currentCategory: string;\n\nexport namespace assure {\n  export function notNull(value: any, name?: string) {\n    if (value == null)\n      throw new Error(`${name == null ? 'Value' : name} not defined`);\n  }\n}\n\nexport interface TestOptions {\n  timeout?: number;\n  unhandledExceptionTimeout?: number;\n  skipReason?: string;\n  isAggregated?: boolean;\n}\n\nexport interface CategoryOptions {\n  clear?: boolean;\n  timeout?: number;\n}\n\nexport class TestContext {\n  catchUnhandled = true;\n  report = false;\n\n  constructor(catchUnhandled?: boolean, report?: boolean) {\n    if (catchUnhandled !== undefined) this.catchUnhandled = catchUnhandled;\n    if (report !== undefined) this.report = report;\n  };\n}\n\nexport class Test {\n  test: () => Promise<any>;\n  name: string;\n  category: string;\n  options?: TestOptions;\n\n  constructor(category: string, name: string, test: () => Promise<any>, options?: TestOptions) {\n    this.category = category;\n    this.name = name;\n    options ??= {};\n    options.timeout ??= STANDART_TIMEOUT;\n    this.options = options;\n    this.test = async (): Promise<any> => {\n      return new Promise(async (resolve, reject) => {\n        let result = '';\n        try {\n          result = await test();\n        } catch (e: any) {\n          reject(e);\n        }\n        resolve(result);\n      });\n    };\n  }\n}\n\nexport async function testEvent<T>(event: Observable<T>,\n  handler: (args: T) => void, trigger: () => void, ms: number = 0, reason: string = `timeout`\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const sub = event.subscribe((args: T) => {\n      try {\n        handler(args);\n        resolve('OK');\n      } catch (e) {\n        reject(e);\n      }\n      // Do not clearTimeout or event sub if handler fails\n      sub.unsubscribe();\n      clearTimeout(timeout);\n    });\n    const timeout = setTimeout(() => {\n      sub.unsubscribe();\n      // eslint-disable-next-line prefer-promise-reject-errors\n      reject(reason);\n    }, ms);\n    trigger();\n  });\n}\n\nexport function test(name: string, test: () => Promise<any>, options?: TestOptions): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  if (tests[currentCategory].tests == undefined)\n    tests[currentCategory].tests = [];\n  tests[currentCategory].tests!.push(new Test(currentCategory, name, test, options));\n}\n\n/* Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual: any, expected: any = true, error?: string): void {\n  if (error)\n    error = `${error}, `;\n  else error = '';\n  if (actual !== expected)\n    throw new Error(`${error}Expected \"${expected}\", got \"${actual}\"`);\n}\n\nexport function expectFloat(actual: number, expected: number, tolerance = 0.001, error?: string): void {\n  if ((actual === Number.POSITIVE_INFINITY && expected === Number.POSITIVE_INFINITY) ||\n      (actual === Number.NEGATIVE_INFINITY && expected === Number.NEGATIVE_INFINITY) ||\n      (actual === Number.NaN && expected === Number.NaN) || (isNaN(actual) && isNaN(expected)))\n    return;\n  const areEqual = Math.abs(actual - expected) < tolerance;\n  expect(areEqual, true, `${error ?? ''} (tolerance = ${tolerance})`);\n  if (!areEqual)\n    throw new Error(`Expected ${expected}, got ${actual} (tolerance = ${tolerance})`);\n}\n\nexport function expectTable(actual: DG.DataFrame, expected: DG.DataFrame, error?: string): void {\n  const expectedRowCount = expected.rowCount;\n  const actualRowCount = actual.rowCount;\n  expect(actualRowCount, expectedRowCount, `${error ?? ''}, row count`);\n\n  for (const column of expected.columns) {\n    const actualColumn = actual.columns.byName(column.name);\n    if (actualColumn == null)\n      throw new Error(`Column ${column.name} not found`);\n    if (actualColumn.type != column.type)\n      throw new Error(`Column ${column.name} type expected ${column.type} got ${actualColumn.type}`);\n    for (let i = 0; i < expectedRowCount; i++) {\n      const value = column.get(i);\n      const actualValue = actualColumn.get(i);\n      if (column.type == DG.TYPE.FLOAT)\n        expectFloat(actualValue, value, 0.0001, error);\n      else if (column.type == DG.TYPE.DATE_TIME)\n        expect(actualValue.isSame(value), true, error);\n      else\n        expect(actualValue, value, error);\n    }\n  }\n}\n\nexport function expectObject(actual: { [key: string]: any }, expected: { [key: string]: any }) {\n  for (const [expectedKey, expectedValue] of Object.entries(expected)) {\n    if (!actual.hasOwnProperty(expectedKey))\n      throw new Error(`Expected property \"${expectedKey}\" not found`);\n\n    const actualValue = actual[expectedKey];\n    if (actualValue instanceof Array && expectedValue instanceof Array)\n      expectArray(actualValue, expectedValue);\n    else if (actualValue instanceof Object && expectedValue instanceof Object)\n      expectObject(actualValue, expectedValue);\n    else if (Number.isFinite(actualValue) && Number.isFinite(expectedValue))\n      expectFloat(actualValue, expectedValue);\n    else if (actualValue != expectedValue)\n      throw new Error(`Expected (${expectedValue}) for key '${expectedKey}', got (${actualValue})`);\n  }\n}\n\nexport function expectArray(actual: ArrayLike<any>, expected: ArrayLike<any>) {\n  const actualLength = actual.length;\n  const expectedLength = expected.length;\n\n  if (actualLength != expectedLength) {\n    throw new Error(`Arrays are of different length: actual array length is ${actualLength} ` +\n      `and expected array length is ${expectedLength}`);\n  }\n\n  for (let i = 0; i < actualLength; i++) {\n    if (actual[i] instanceof Array && expected[i] instanceof Array)\n      expectArray(actual[i], expected[i]);\n    else if (actual[i] instanceof Object && expected[i] instanceof Object)\n      expectObject(actual[i], expected[i]);\n    else if (actual[i] != expected[i])\n      throw new Error(`Expected ${expected[i]} at position ${i}, got ${actual[i]}`);\n  }\n}\n\n/* Defines a test suite. */\nexport function category(category: string, tests_: () => void, options?: CategoryOptions): void {\n  currentCategory = category;\n  tests_();\n  if (tests[currentCategory]) {\n    tests[currentCategory].clear = options?.clear ?? true;\n    tests[currentCategory].timeout = options?.timeout;\n  }\n}\n\n/* Defines a function to be executed before the tests in this category are executed. */\nexport function before(before: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].before = before;\n}\n\n/* Defines a function to be executed after the tests in this category are executed. */\nexport function after(after: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].after = after;\n}\n\nfunction addNamespace(s: string, f: DG.Func): string {\n  return s.replace(new RegExp(f.name, 'gi'), f.nqName);\n}\n\nexport async function initAutoTests(package_: DG.Package, module?: any) {\n  const packageId = package_.id;\n  if (wasRegistered[packageId]) return;\n  const moduleTests = module ? module.tests : tests;\n  if (moduleTests[autoTestsCatName] !== undefined ||\n      moduleTests[demoCatName] !== undefined ||\n      Object.keys(moduleTests).find((c) => c.startsWith(autoTestsCatName) || c.startsWith(coreCatName))) {\n    wasRegistered[packageId] = true;\n    return;\n  }\n  if (package_.name === 'DevTools' || (!!module && module._package.name === 'DevTools')) {\n    const testFunctions: DG.Func[] = DG.Func.find({tags: ['dartTest']});\n    for (const f of testFunctions) {\n      const arr = f.name.split(/\\s*\\|\\s*/g);\n      const name = arr.pop() ?? f.name;\n      const cat = arr.length ? coreCatName + ': ' + arr.join(': ') : coreCatName;\n      if (moduleTests[cat] === undefined)\n        moduleTests[cat] = {tests: [], clear: true};\n      moduleTests[cat].tests.push(new Test(cat, name,\n        async () => await f.apply(), {isAggregated: f.outputs.length > 0, timeout: 300000}));\n    }\n  }\n  const moduleAutoTests = [];\n  const moduleDemo = [];\n  const moduleDetectors = [];\n  const packFunctions = await grok.dapi.functions.filter(`package.id = \"${packageId}\"`).list();\n  const reg = new RegExp(/skip:\\s*([^,\\s]+)|wait:\\s*(\\d+)|cat:\\s*([^,\\s]+)|timeout:\\s*(\\d+)/g);\n  for (const f of packFunctions) {\n    const tests = f.options['test'];\n    const demo = f.options['demoPath'];\n    if ((tests && Array.isArray(tests) && tests.length)) {\n      for (let i = 0; i < tests.length; i++) {\n        const res = (tests[i] as string).matchAll(reg);\n        const map: {skip?: string, wait?: number, cat?: string, timeout?: number} = {};\n        Array.from(res).forEach((arr) => {\n          if (arr[0].startsWith('skip')) map['skip'] = arr[1];\n          else if (arr[0].startsWith('wait')) map['wait'] = parseInt(arr[2]);\n          else if (arr[0].startsWith('cat')) map['cat'] = arr[3];\n          else if (arr[0].startsWith('timeout')) map['timeout'] = parseInt(arr[4]);\n        });\n        const test = new Test(autoTestsCatName, tests.length === 1 ? f.name : `${f.name} ${i + 1}`, async () => {\n          const res = await grok.functions.eval(addNamespace(tests[i], f));\n          if (map.wait) await delay(map.wait);\n          // eslint-disable-next-line no-throw-literal\n          if (typeof res === 'boolean' && !res) throw `Failed: ${tests[i]}, expected true, got ${res}`;\n        }, {skipReason: map.skip, timeout: map.timeout});\n        if (map.cat) {\n          const cat: string = autoTestsCatName + ': ' + map.cat;\n          test.category = cat;\n          if (moduleTests[cat] === undefined)\n            moduleTests[cat] = {tests: [], clear: true};\n          moduleTests[cat].tests.push(test);\n        } else\n          moduleAutoTests.push(test);\n      }\n    }\n    if (demo) {\n      const wait = f.options['demoWait'] ? parseInt(f.options['demoWait']) : undefined;\n      const test = new Test(demoCatName, f.friendlyName, async () => {\n        grok.shell.lastError = '';\n        await f.apply();\n        await delay(wait ? wait : 2000);\n        if (grok.shell.lastError)\n          throw new Error(grok.shell.lastError);\n      }, {skipReason: f.options['demoSkip']});\n      moduleDemo.push(test);\n    }\n    if (f.hasTag('semTypeDetector')) {\n      const test = new Test(detectorsCatName, f.friendlyName, async () => {\n        const arr = [];\n        for (const col of testData.clone().columns) {\n          const res = await f.apply([col]);\n          arr.push(res || col.semType);\n        }\n        expect(arr.filter((i) => i).length, 1);\n      }, {skipReason: f.options['skipTest']});\n      moduleDetectors.push(test);\n    }\n  }\n  wasRegistered[packageId] = true;\n  if (moduleAutoTests.length)\n    moduleTests[autoTestsCatName] = {tests: moduleAutoTests, clear: true};\n  if (moduleDemo.length)\n    moduleTests[demoCatName] = {tests: moduleDemo, clear: true};\n  if (moduleDetectors.length)\n    moduleTests[detectorsCatName] = {tests: moduleDetectors, clear: false};\n}\n\nfunction redefineConsole(): any[] {\n  const logs: any[] = [];\n  console.log = (...args) => {\n    logs.push(...args);\n    stdLog(...args);\n  };\n  console.info = (...args) => {\n    logs.push(...args);\n    stdInfo(...args);\n  };\n  console.warn = (...args) => {\n    logs.push(...args);\n    stdWarn(...args);\n  };\n  console.error = (...args) => {\n    logs.push(...args);\n    stdError(...args);\n  };\n  return logs;\n}\n\nfunction resetConsole(): void {\n  console.log = stdLog;\n  console.info = stdInfo;\n  console.warn = stdWarn;\n  console.error = stdError;\n}\n\nexport async function runTests(options?:\n  {category?: string, test?: string, testContext?: TestContext, exclude?: string[], verbose?: boolean}) {\n  const package_ = grok.functions.getCurrentCall()?.func?.package;\n  await initAutoTests(package_);\n  const results: { category?: string, name?: string, success: boolean,\n                   result: string, ms: number, skipped: boolean }[] = [];\n  console.log(`Running tests`);\n  options ??= {};\n  options!.testContext ??= new TestContext();\n  grok.shell.lastError = '';\n  const categories = [];\n  const logs = redefineConsole();\n  try {\n    for (const [key, value] of Object.entries(tests)) {\n      if ((!!options?.category && !key.toLowerCase().startsWith(options?.category.toLowerCase())) ||\n        options.exclude?.some((c) => key.startsWith(c)))\n        continue;\n      stdLog(`Started ${key} category`);\n      categories.push(key);\n      const skipped = value.tests?.every((t) => t.options?.skipReason);\n      try {\n        if (value.before && !skipped)\n          await value.before();\n      } catch (x: any) {\n        value.beforeStatus = getResult(x);\n      }\n      const t = value.tests ?? [];\n      const res = [];\n      if (value.clear) {\n        for (let i = 0; i < t.length; i++) {\n          res.push(await execTest(t[i], options?.test, logs, value.timeout, package_.name, options.verbose));\n          grok.shell.closeAll();\n          DG.Balloon.closeAll();\n        }\n      } else {\n        for (let i = 0; i < t.length; i++)\n          res.push(await execTest(t[i], options?.test, logs, value.timeout, package_.name, options.verbose));\n      }\n      const data = res.filter((d) => d.result != 'skipped');\n      try {\n        if (value.after && !skipped)\n          await value.after();\n      } catch (x: any) {\n        value.afterStatus = getResult(x);\n      }\n      // Clear after category\n      // grok.shell.closeAll();\n      // DG.Balloon.closeAll();\n      if (value.afterStatus)\n        data.push({category: key, name: 'after', result: value.afterStatus, success: false, ms: 0, skipped: false});\n      if (value.beforeStatus)\n        data.push({category: key, name: 'before', result: value.beforeStatus, success: false, ms: 0, skipped: false});\n      results.push(...data);\n    }\n  } finally {\n    resetConsole();\n  }\n  if (options.testContext.catchUnhandled) {\n    await delay(1000);\n    if (grok.shell.lastError.length > 0) {\n      results.push({\n        category: 'Unhandled exceptions',\n        name: 'exceptions',\n        result: grok.shell.lastError, success: false, ms: 0, skipped: false\n      });\n    }\n  }\n  if (!options.test && results.length) {\n    const successful = results.filter((r) => r.success).length;\n    const skipped = results.filter((r) => r.skipped).length;\n    const failed = results.filter((r) => !r.success);\n    const packageName = package_.name;\n    for (const cat of categories) {\n      const res = results.filter((r) => r.category === cat);\n      const failed_ = res.filter((r) => !r.success).length;\n      const params = {success: failed_ === 0,\n        passed: res.filter((r) => r.success).length,\n        skipped: res.filter((r) => r.skipped).length,\n        failed: failed_,\n        type: 'package', packageName, category: cat};\n      grok.log.usage(`${packageName}: ${cat}`,\n        params, `category-package ${packageName}: ${cat}`);\n    }\n    if (!options.category) {\n      const params = {success: failed.length === 0, passed: successful, skipped, failed: failed.length,\n        type: 'package', packageName};\n      grok.log.usage(packageName, params, `package-package ${packageName}`);\n    }\n    if (options.testContext.report) {\n      const logger = new DG.Logger();\n      const description = 'Package @package tested: @successful successful, @skipped skipped, @failed failed tests';\n      const params = {\n        successful: successful,\n        skipped: skipped,\n        failed: failed.length,\n        package: package_\n      };\n      for (const r of failed) Object.assign(params, {[`${r.category} | ${r.name}`]: r.result});\n      logger.log(description, params, 'package-tested');\n    }\n  }\n  return results;\n}\n\nfunction getResult(x: any) {\n  return `${x.toString()}\\n${x.stack ? DG.Logger.translateStackTrace(x.stack) : ''}`;\n}\n\nasync function execTest(t: Test, predicate: string | undefined, logs: any[],\n  categoryTimeout?: number, packageName?: string, verbose?: boolean) {\n  logs.length = 0;\n  let r: {category?: string, name?: string, success: boolean, result: any, ms: number, skipped: boolean, logs?: string};\n  let type: string = 'package';\n  const filter = predicate != undefined && (t.name.toLowerCase() !== predicate.toLowerCase());\n  const skip = t.options?.skipReason || filter;\n  const skipReason = filter ? 'skipped' : t.options?.skipReason;\n  if (!skip)\n    stdLog(`Started ${t.category} ${t.name}`);\n  const start = Date.now();\n  try {\n    if (skip)\n      r = {success: true, result: skipReason!, ms: 0, skipped: true};\n    else {\n      let timeout_ = t.options?.timeout === STANDART_TIMEOUT &&\n        categoryTimeout ? categoryTimeout : t.options?.timeout!;\n      timeout_ = DG.Test.isInBenchmark && timeout_ === STANDART_TIMEOUT ? BENCHMARK_TIMEOUT : timeout_;\n      r = {success: true, result: await timeout(t.test, timeout_) ?? 'OK', ms: 0, skipped: false};\n    }\n  } catch (x: any) {\n    r = {success: false, result: getResult(x), ms: 0, skipped: false};\n  }\n  if (t.options?.isAggregated && r.result.constructor === DG.DataFrame) {\n    const col = r.result.col('success');\n    type = 'core';\n    if (col)\n      r.success = col.stats.sum === col.length;\n    if (!verbose) {\n      const df = r.result;\n      df.columns.remove('stack');\n      df.rows.removeWhere((r) => r.get('success'));\n      r.result = df;\n    }\n    r.result = r.result.toCsv();\n  }\n  r.logs = logs.join('\\n');\n  r.ms = Date.now() - start;\n  if (!skip)\n    stdLog(`Finished ${t.category} ${t.name} for ${r.ms} ms`);\n  r.category = t.category;\n  r.name = t.name;\n  if (!filter) {\n    let params = {'success': r.success, 'result': r.result, 'ms': r.ms, 'skipped': r.skipped,\n      'type': type, packageName, 'category': t.category, 'test': t.name, 'logs': r.logs};\n    if (r.result.constructor == Object) {\n      const res = Object.keys(r.result).reduce((acc, k) => ({...acc, ['result.' + k]: r.result[k]}), {});\n      params = {...params, ...res};\n    }\n    grok.log.usage(`${packageName}: ${t.category}: ${t.name}`,\n      params, `test-${type} ${packageName}: ${t.category}: ${t.name}`);\n  }\n  return r;\n}\n\n/* Waits [ms] milliseconds */\nexport async function delay(ms: number) {\n  await new Promise((r) => setTimeout(r, ms));\n}\n\nexport async function awaitCheck(checkHandler: () => boolean,\n  error: string = 'Timeout exceeded', wait: number = 500, interval: number = 50): Promise<void> {\n  return new Promise((resolve, reject) => {\n    setTimeout(() => {\n      clearInterval(intervalId);\n      reject(new Error(error));\n    }, wait);\n    // @ts-ignore\n    const intervalId: Timeout = setInterval(() => {\n      if (checkHandler()) {\n        clearInterval(intervalId);\n        resolve();\n      }\n    }, interval);\n  });\n}\n\n// Returns test execution result or an error in case of timeout\nasync function timeout(func: () => Promise<any>, testTimeout: number): Promise<any> {\n  let timeout: any = null;\n  const timeoutPromise = new Promise<any>((_, reject) => {\n    timeout = setTimeout(() => {\n      // eslint-disable-next-line prefer-promise-reject-errors\n      reject('EXECUTION TIMEOUT');\n    }, testTimeout);\n  });\n  try {\n    return await Promise.race([func(), timeoutPromise]);\n  } finally {\n    if (timeout)\n      clearTimeout(timeout);\n  }\n}\n\nexport function isDialogPresent(dialogTitle: string): boolean {\n  const dialogs = DG.Dialog.getOpenDialogs();\n  for (let i = 0; i < dialogs.length; i++) {\n    if (dialogs[i].title == dialogTitle)\n      return true;\n  }\n  return false;\n}\n\n/** Expects an asynchronous {@link action} to throw an exception. Use {@link check} to perform\n * deeper inspection of the exception if necessary.\n * @param  {function(): Promise<void>} action\n * @param  {function(any): boolean} check\n * @return {Promise<void>}\n */\nexport async function expectExceptionAsync(action: () => Promise<void>,\n  check?: (exception: any) => boolean): Promise<void> {\n  let caught: boolean = false;\n  let checked: boolean = false;\n  try {\n    await action();\n  } catch (e) {\n    caught = true;\n    checked = !check || check(e);\n  } finally {\n    if (!caught)\n      throw new Error('An exception is expected but not thrown');\n    if (!checked)\n      throw new Error('An expected exception is thrown, but it does not satisfy the condition');\n  }\n}\n\nconst catDF = DG.DataFrame.fromColumns([DG.Column.fromStrings('col', ['val1', 'val2', 'val3'])]);\n\n/**\n * Universal test for viewers. It search viewers in DOM by tags: canvas, svg, img, input, h1, a\n * @param  {string} v Viewer name\n * @param  {DG.DataFrame} df Dataframe to use. Should have at least 3 rows\n * @param  {boolean} options.detectSemanticTypes Specify whether to detect semantic types or not\n * @param  {boolean} options.readOnly If set to true, the dataframe will not be modified during the test\n * @param  {boolean} options.arbitraryDfTest If set to false, test on arbitrary dataframe\n * (one categorical column) will not be performed\n * @param  {object} options List of options (optional)\n * @return {Promise<void>} The test is considered successful if it completes without errors\n */\nexport async function testViewer(v: string, df: DG.DataFrame, options?: {\n  detectSemanticTypes?: boolean, readOnly?: boolean, arbitraryDfTest?: boolean,\n  packageName?: string, awaitViewer?: (viewer: DG.Viewer) => Promise<void>\n}): Promise<void> {\n  const createViewer = async (tv: DG.TableView, v: string, packageName?: string): Promise<DG.Viewer> => {\n    let res: DG.Viewer;\n    if (packageName) {\n      res = await tv.dataFrame.plot.fromType(v) as DG.Viewer;\n      tv.dockManager.dock(res);\n    } else\n      res = tv.addViewer(v);\n    return res;\n  };\n\n  if (options?.detectSemanticTypes) await grok.data.detectSemanticTypes(df);\n  let tv = grok.shell.addTableView(df);\n  const viewerName = `[name=viewer-${v.replace(/\\s+/g, '-')} i]`;\n  // const selector = `${viewerName} canvas,${viewerName} svg,${viewerName} img,\n  //   ${viewerName} input,${viewerName} h1,${viewerName} a,${viewerName} .d4-viewer-error`;\n  const selector = ['div.ui-box' /* root */, 'canvas', 'svg', 'img', 'input', 'h1', 'a', '.d4-viewer-error']\n    .map((selTag) => `${viewerName} ${selTag}`).join(', ');\n  const res = [];\n  try {\n    let viewer = await createViewer(tv, v, options?.packageName);\n    await awaitCheck(() => document.querySelector(selector) !== null,\n      'cannot load viewer', 3000);\n    const tag = document.querySelector(selector)?.tagName;\n    res.push(Array.from(tv.viewers).length);\n    if (!options?.readOnly) {\n      Array.from(df.row(0).cells).forEach((c:any) => c.value = null);\n      const num = df.rowCount < 20 ? Math.floor(df.rowCount / 2) : 10;\n      df.rows.select((row: DG.Row) => row.idx >= 0 && row.idx < num);\n      await delay(50);\n      for (let i = num; i < num * 2; i++) df.filter.set(i, false);\n      await delay(50);\n      df.currentRowIdx = 1;\n      const df1 = df.clone();\n      df.columns.names().slice(0, Math.ceil(df.columns.length / 2)).forEach((c: any) => df.columns.remove(c));\n      await delay(100);\n      tv.dataFrame = df1;\n    }\n    let optns: { [p: string]: any };\n    try {\n      optns = viewer.getOptions(true).look;\n    } catch (err: any) {\n      throw new Error(`Viewer's .getOptions() error.`, {cause: err});\n    }\n    let props: DG.Property[];\n    try {\n      props = viewer.getProperties();\n    } catch (err: any) {\n      throw new Error(`Viewer's .getProperties() error.`, {cause: err});\n    }\n    const newProps: Record<string, string | boolean> = {};\n    Object.keys(optns).filter((k) => typeof optns[k] === 'boolean').forEach((k) => newProps[k] = !optns[k]);\n    props.filter((p: DG.Property) => p.choices !== null)\n      .forEach((p: DG.Property) => newProps[p.name] = p.choices.find((c: any) => c !== optns[p.name])!);\n    viewer.setOptions(newProps);\n    await delay(300);\n    const layout = tv.saveLayout();\n    const oldProps = viewer.getOptions().look;\n    tv.resetLayout();\n    res.push(Array.from(tv.viewers).length);\n    tv.loadLayout(layout);\n    const selector1 = `${viewerName} ${tag}`;\n    await awaitCheck(() => document.querySelector(selector1) !== null,\n      'cannot load viewer from layout', 3000);\n    res.push(Array.from(tv.viewers).length);\n    viewer = Array.from(tv.viewers).find((v: any) => v.type !== 'Grid')!;\n    expectArray(res, [2, 1, 2]);\n    expect(JSON.stringify(viewer.getOptions().look), JSON.stringify(oldProps));\n    if (options?.arbitraryDfTest !== false) {\n      if (options?.awaitViewer) await options.awaitViewer(viewer);\n      grok.shell.closeAll();\n\n      await delay(100);\n      tv = grok.shell.addTableView(catDF);\n      try {\n        viewer = await createViewer(tv, v, options?.packageName);\n      } catch (e) {\n        grok.shell.closeAll();\n        DG.Balloon.closeAll();\n        return;\n      }\n      await awaitCheck(() => document.querySelector(selector) !== null,\n        'cannot load viewer on arbitrary dataset', 3000);\n    }\n    if (options?.awaitViewer) await options.awaitViewer(viewer);\n  } finally {\n    // closeAll() is handling by common test workflow\n    // grok.shell.closeAll();\n    // DG.Balloon.closeAll();\n  }\n}\n"]}","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.colored-text-input > textarea {\n  width: 100%;\n  -webkit-text-fill-color: transparent;\n  background-color: transparent;\n  position: relative;\n  z-index: 1;\n  resize: none;\n  height: 22px; /* Fine tuned value to avoid \"jumping\" of the textarea upon autoresize */\n}\n\n.colored-text-input > div {\n  /* The values here are fine tuned to those of the ui.input textarea in order\n   * to achieve precise overlap */\n  overflow: auto;\n  position: absolute;\n  pointer-events: none;\n  cursor: text;\n  z-index: 0;\n  max-width: 100%;\n  padding: 2px;\n  line-height: normal;\n  font-family: 'Roboto Mono', 'Roboto Mono Local', monospace;\n  font-size: 12px;\n  color: transparent;\n  white-space: pre-wrap;\n  word-wrap: break-word;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/apps/common/view/components/colored-input/style.css\"],\"names\":[],\"mappings\":\"AAAA;EACE,WAAW;EACX,oCAAoC;EACpC,6BAA6B;EAC7B,kBAAkB;EAClB,UAAU;EACV,YAAY;EACZ,YAAY,EAAE,wEAAwE;AACxF;;AAEA;EACE;iCAC+B;EAC/B,cAAc;EACd,kBAAkB;EAClB,oBAAoB;EACpB,YAAY;EACZ,UAAU;EACV,eAAe;EACf,YAAY;EACZ,mBAAmB;EACnB,0DAA0D;EAC1D,eAAe;EACf,kBAAkB;EAClB,qBAAqB;EACrB,qBAAqB;AACvB\",\"sourcesContent\":[\".colored-text-input > textarea {\\n  width: 100%;\\n  -webkit-text-fill-color: transparent;\\n  background-color: transparent;\\n  position: relative;\\n  z-index: 1;\\n  resize: none;\\n  height: 22px; /* Fine tuned value to avoid \\\"jumping\\\" of the textarea upon autoresize */\\n}\\n\\n.colored-text-input > div {\\n  /* The values here are fine tuned to those of the ui.input textarea in order\\n   * to achieve precise overlap */\\n  overflow: auto;\\n  position: absolute;\\n  pointer-events: none;\\n  cursor: text;\\n  z-index: 0;\\n  max-width: 100%;\\n  padding: 2px;\\n  line-height: normal;\\n  font-family: 'Roboto Mono', 'Roboto Mono Local', monospace;\\n  font-size: 12px;\\n  color: transparent;\\n  white-space: pre-wrap;\\n  word-wrap: break-word;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `/* Naming convention: class names should begin with st and app name to avoid naming collitions */\n\n.st-pattern-text-input > textarea {\n  resize: none;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/apps/pattern/view/style.css\"],\"names\":[],\"mappings\":\"AAAA,gGAAgG;;AAEhG;EACE,YAAY;AACd\",\"sourcesContent\":[\"/* Naming convention: class names should begin with st and app name to avoid naming collitions */\\n\\n.st-pattern-text-input > textarea {\\n  resize: none;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `/* Naming convention: class names should begin with st and app name to avoid naming collitions */\n\n.st-structure-body {\n  padding-right: 20px;\n}\n\n.st-structure-input-form {\n  text-align: right;\n  vertical-align: top;\n  min-width: 95px;\n}\n\n.st-structure-direction-choice label {\n  min-width: 100px;\n  float: right;\n}\n\n.st-structure-direction-choice div {\n  justify-content: right;\n}\n\n.st-structure-text-input-td { /* Style for td containing textarea */\n  width: 100%;\n}\n\n.st-structure-mol-img {\n  margin-right: 30px;\n  float: right;\n}\n\n.st-structure-bool-button-block {\n  justify-content: right;\n  margin-bottom: 10px;\n}\n\n.st-structure-bottom {\n  flex-direction: row-reverse;\n  padding-top: 20px;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/apps/structure/view/style.css\"],\"names\":[],\"mappings\":\"AAAA,gGAAgG;;AAEhG;EACE,mBAAmB;AACrB;;AAEA;EACE,iBAAiB;EACjB,mBAAmB;EACnB,eAAe;AACjB;;AAEA;EACE,gBAAgB;EAChB,YAAY;AACd;;AAEA;EACE,sBAAsB;AACxB;;AAEA,8BAA8B,qCAAqC;EACjE,WAAW;AACb;;AAEA;EACE,kBAAkB;EAClB,YAAY;AACd;;AAEA;EACE,sBAAsB;EACtB,mBAAmB;AACrB;;AAEA;EACE,2BAA2B;EAC3B,iBAAiB;AACnB\",\"sourcesContent\":[\"/* Naming convention: class names should begin with st and app name to avoid naming collitions */\\n\\n.st-structure-body {\\n  padding-right: 20px;\\n}\\n\\n.st-structure-input-form {\\n  text-align: right;\\n  vertical-align: top;\\n  min-width: 95px;\\n}\\n\\n.st-structure-direction-choice label {\\n  min-width: 100px;\\n  float: right;\\n}\\n\\n.st-structure-direction-choice div {\\n  justify-content: right;\\n}\\n\\n.st-structure-text-input-td { /* Style for td containing textarea */\\n  width: 100%;\\n}\\n\\n.st-structure-mol-img {\\n  margin-right: 30px;\\n  float: right;\\n}\\n\\n.st-structure-bool-button-block {\\n  justify-content: right;\\n  margin-bottom: 10px;\\n}\\n\\n.st-structure-bottom {\\n  flex-direction: row-reverse;\\n  padding-top: 20px;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `/* Naming convention: class names should begin with st and app name to avoid naming collitions */\n.st-translator-input-table {\n  /* width: 100%; */\n  margin-right: 20px;\n}\n\n.st-translator-input-table td:has(textarea) {\n  width: 100%;\n}\n\n.st-translator-input-table td:has(select) {\n  min-width: 120px;\n  vertical-align: top;\n}\n\n.st-translator-output-table {\n  margin-top: 20px;\n  margin-right: 20px;\n  margin-bottom: 10px;\n}\n\n.st-translator-output-table table {\n  width: 100%;\n  table-layout: fixed;\n}\n\n/* .st-translator-output-table table tbody tr td { */\n/*   max-width: 20%; */\n/* } */\n\n.st-translator-output-table td {\n  padding-top: 6px;\n  padding-bottom: 6px;\n}\n.st-translator-output-table tr:nth-child(even) {\n  background-color: var(--grey-1);\n}\n\n.st-translator-output-table td:nth-child(odd) {\n  width: 120px;\n  vertical-align: top;\n}\n\n.st-translator-output-table td a {\n  overflow-wrap: break-word;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/apps/translator/view/style.css\"],\"names\":[],\"mappings\":\"AAAA,gGAAgG;AAChG;EACE,iBAAiB;EACjB,kBAAkB;AACpB;;AAEA;EACE,WAAW;AACb;;AAEA;EACE,gBAAgB;EAChB,mBAAmB;AACrB;;AAEA;EACE,gBAAgB;EAChB,kBAAkB;EAClB,mBAAmB;AACrB;;AAEA;EACE,WAAW;EACX,mBAAmB;AACrB;;AAEA,oDAAoD;AACpD,sBAAsB;AACtB,MAAM;;AAEN;EACE,gBAAgB;EAChB,mBAAmB;AACrB;AACA;EACE,+BAA+B;AACjC;;AAEA;EACE,YAAY;EACZ,mBAAmB;AACrB;;AAEA;EACE,yBAAyB;AAC3B\",\"sourcesContent\":[\"/* Naming convention: class names should begin with st and app name to avoid naming collitions */\\n.st-translator-input-table {\\n  /* width: 100%; */\\n  margin-right: 20px;\\n}\\n\\n.st-translator-input-table td:has(textarea) {\\n  width: 100%;\\n}\\n\\n.st-translator-input-table td:has(select) {\\n  min-width: 120px;\\n  vertical-align: top;\\n}\\n\\n.st-translator-output-table {\\n  margin-top: 20px;\\n  margin-right: 20px;\\n  margin-bottom: 10px;\\n}\\n\\n.st-translator-output-table table {\\n  width: 100%;\\n  table-layout: fixed;\\n}\\n\\n/* .st-translator-output-table table tbody tr td { */\\n/*   max-width: 20%; */\\n/* } */\\n\\n.st-translator-output-table td {\\n  padding-top: 6px;\\n  padding-bottom: 6px;\\n}\\n.st-translator-output-table tr:nth-child(even) {\\n  background-color: var(--grey-1);\\n}\\n\\n.st-translator-output-table td:nth-child(odd) {\\n  width: 120px;\\n  vertical-align: top;\\n}\\n\\n.st-translator-output-table td a {\\n  overflow-wrap: break-word;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n  var list = [];\n\n  // return the list of modules as css string\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = \"\";\n      var needLayer = typeof item[5] !== \"undefined\";\n      if (item[4]) {\n        content += \"@supports (\".concat(item[4], \") {\");\n      }\n      if (item[2]) {\n        content += \"@media \".concat(item[2], \" {\");\n      }\n      if (needLayer) {\n        content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n      }\n      content += cssWithMappingToString(item);\n      if (needLayer) {\n        content += \"}\";\n      }\n      if (item[2]) {\n        content += \"}\";\n      }\n      if (item[4]) {\n        content += \"}\";\n      }\n      return content;\n    }).join(\"\");\n  };\n\n  // import a list of modules into the list\n  list.i = function i(modules, media, dedupe, supports, layer) {\n    if (typeof modules === \"string\") {\n      modules = [[null, modules, undefined]];\n    }\n    var alreadyImportedModules = {};\n    if (dedupe) {\n      for (var k = 0; k < this.length; k++) {\n        var id = this[k][0];\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n    for (var _k = 0; _k < modules.length; _k++) {\n      var item = [].concat(modules[_k]);\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue;\n      }\n      if (typeof layer !== \"undefined\") {\n        if (typeof item[5] === \"undefined\") {\n          item[5] = layer;\n        } else {\n          item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n          item[5] = layer;\n        }\n      }\n      if (media) {\n        if (!item[2]) {\n          item[2] = media;\n        } else {\n          item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n          item[2] = media;\n        }\n      }\n      if (supports) {\n        if (!item[4]) {\n          item[4] = \"\".concat(supports);\n        } else {\n          item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n          item[4] = supports;\n        }\n      }\n      list.push(item);\n    }\n  };\n  return list;\n};","\"use strict\";\n\nmodule.exports = function (item) {\n  var content = item[1];\n  var cssMapping = item[3];\n  if (!cssMapping) {\n    return content;\n  }\n  if (typeof btoa === \"function\") {\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    return [content].concat([sourceMapping]).join(\"\\n\");\n  }\n  return [content].join(\"\\n\");\n};","(function (root, factory) {\n    // Hack to make all exports of this module sha256 function object properties.\n    var exports = {};\n    factory(exports);\n    var sha256 = exports[\"default\"];\n    for (var k in exports) {\n        sha256[k] = exports[k];\n    }\n        \n    if (typeof module === 'object' && typeof module.exports === 'object') {\n        module.exports = sha256;\n    } else if (typeof define === 'function' && define.amd) {\n        define(function() { return sha256; }); \n    } else {\n        root.sha256 = sha256;\n    }\n})(this, function(exports) {\n\"use strict\";\nexports.__esModule = true;\n// SHA-256 (+ HMAC and PBKDF2) for JavaScript.\n//\n// Written in 2014-2016 by Dmitry Chestnykh.\n// Public domain, no warranty.\n//\n// Functions (accept and return Uint8Arrays):\n//\n//   sha256(message) -> hash\n//   sha256.hmac(key, message) -> mac\n//   sha256.pbkdf2(password, salt, rounds, dkLen) -> dk\n//\n//  Classes:\n//\n//   new sha256.Hash()\n//   new sha256.HMAC(key)\n//\nexports.digestLength = 32;\nexports.blockSize = 64;\n// SHA-256 constants\nvar K = new Uint32Array([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n    0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n    0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n    0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n    0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n    0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n    0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\nfunction hashBlocks(w, v, p, pos, len) {\n    var a, b, c, d, e, f, g, h, u, i, j, t1, t2;\n    while (len >= 64) {\n        a = v[0];\n        b = v[1];\n        c = v[2];\n        d = v[3];\n        e = v[4];\n        f = v[5];\n        g = v[6];\n        h = v[7];\n        for (i = 0; i < 16; i++) {\n            j = pos + i * 4;\n            w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16) |\n                ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));\n        }\n        for (i = 16; i < 64; i++) {\n            u = w[i - 2];\n            t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);\n            u = w[i - 15];\n            t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);\n            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);\n        }\n        for (i = 0; i < 64; i++) {\n            t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11)) ^\n                (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0) +\n                ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n            t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13)) ^\n                (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n            h = g;\n            g = f;\n            f = e;\n            e = (d + t1) | 0;\n            d = c;\n            c = b;\n            b = a;\n            a = (t1 + t2) | 0;\n        }\n        v[0] += a;\n        v[1] += b;\n        v[2] += c;\n        v[3] += d;\n        v[4] += e;\n        v[5] += f;\n        v[6] += g;\n        v[7] += h;\n        pos += 64;\n        len -= 64;\n    }\n    return pos;\n}\n// Hash implements SHA256 hash algorithm.\nvar Hash = /** @class */ (function () {\n    function Hash() {\n        this.digestLength = exports.digestLength;\n        this.blockSize = exports.blockSize;\n        // Note: Int32Array is used instead of Uint32Array for performance reasons.\n        this.state = new Int32Array(8); // hash state\n        this.temp = new Int32Array(64); // temporary state\n        this.buffer = new Uint8Array(128); // buffer for data to hash\n        this.bufferLength = 0; // number of bytes in buffer\n        this.bytesHashed = 0; // number of total bytes hashed\n        this.finished = false; // indicates whether the hash was finalized\n        this.reset();\n    }\n    // Resets hash state making it possible\n    // to re-use this instance to hash other data.\n    Hash.prototype.reset = function () {\n        this.state[0] = 0x6a09e667;\n        this.state[1] = 0xbb67ae85;\n        this.state[2] = 0x3c6ef372;\n        this.state[3] = 0xa54ff53a;\n        this.state[4] = 0x510e527f;\n        this.state[5] = 0x9b05688c;\n        this.state[6] = 0x1f83d9ab;\n        this.state[7] = 0x5be0cd19;\n        this.bufferLength = 0;\n        this.bytesHashed = 0;\n        this.finished = false;\n        return this;\n    };\n    // Cleans internal buffers and re-initializes hash state.\n    Hash.prototype.clean = function () {\n        for (var i = 0; i < this.buffer.length; i++) {\n            this.buffer[i] = 0;\n        }\n        for (var i = 0; i < this.temp.length; i++) {\n            this.temp[i] = 0;\n        }\n        this.reset();\n    };\n    // Updates hash state with the given data.\n    //\n    // Optionally, length of the data can be specified to hash\n    // fewer bytes than data.length.\n    //\n    // Throws error when trying to update already finalized hash:\n    // instance must be reset to use it again.\n    Hash.prototype.update = function (data, dataLength) {\n        if (dataLength === void 0) { dataLength = data.length; }\n        if (this.finished) {\n            throw new Error(\"SHA256: can't update because hash was finished.\");\n        }\n        var dataPos = 0;\n        this.bytesHashed += dataLength;\n        if (this.bufferLength > 0) {\n            while (this.bufferLength < 64 && dataLength > 0) {\n                this.buffer[this.bufferLength++] = data[dataPos++];\n                dataLength--;\n            }\n            if (this.bufferLength === 64) {\n                hashBlocks(this.temp, this.state, this.buffer, 0, 64);\n                this.bufferLength = 0;\n            }\n        }\n        if (dataLength >= 64) {\n            dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);\n            dataLength %= 64;\n        }\n        while (dataLength > 0) {\n            this.buffer[this.bufferLength++] = data[dataPos++];\n            dataLength--;\n        }\n        return this;\n    };\n    // Finalizes hash state and puts hash into out.\n    //\n    // If hash was already finalized, puts the same value.\n    Hash.prototype.finish = function (out) {\n        if (!this.finished) {\n            var bytesHashed = this.bytesHashed;\n            var left = this.bufferLength;\n            var bitLenHi = (bytesHashed / 0x20000000) | 0;\n            var bitLenLo = bytesHashed << 3;\n            var padLength = (bytesHashed % 64 < 56) ? 64 : 128;\n            this.buffer[left] = 0x80;\n            for (var i = left + 1; i < padLength - 8; i++) {\n                this.buffer[i] = 0;\n            }\n            this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;\n            this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;\n            this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;\n            this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;\n            this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;\n            this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;\n            this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;\n            this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;\n            hashBlocks(this.temp, this.state, this.buffer, 0, padLength);\n            this.finished = true;\n        }\n        for (var i = 0; i < 8; i++) {\n            out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;\n            out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;\n            out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;\n            out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;\n        }\n        return this;\n    };\n    // Returns the final hash digest.\n    Hash.prototype.digest = function () {\n        var out = new Uint8Array(this.digestLength);\n        this.finish(out);\n        return out;\n    };\n    // Internal function for use in HMAC for optimization.\n    Hash.prototype._saveState = function (out) {\n        for (var i = 0; i < this.state.length; i++) {\n            out[i] = this.state[i];\n        }\n    };\n    // Internal function for use in HMAC for optimization.\n    Hash.prototype._restoreState = function (from, bytesHashed) {\n        for (var i = 0; i < this.state.length; i++) {\n            this.state[i] = from[i];\n        }\n        this.bytesHashed = bytesHashed;\n        this.finished = false;\n        this.bufferLength = 0;\n    };\n    return Hash;\n}());\nexports.Hash = Hash;\n// HMAC implements HMAC-SHA256 message authentication algorithm.\nvar HMAC = /** @class */ (function () {\n    function HMAC(key) {\n        this.inner = new Hash();\n        this.outer = new Hash();\n        this.blockSize = this.inner.blockSize;\n        this.digestLength = this.inner.digestLength;\n        var pad = new Uint8Array(this.blockSize);\n        if (key.length > this.blockSize) {\n            (new Hash()).update(key).finish(pad).clean();\n        }\n        else {\n            for (var i = 0; i < key.length; i++) {\n                pad[i] = key[i];\n            }\n        }\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] ^= 0x36;\n        }\n        this.inner.update(pad);\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] ^= 0x36 ^ 0x5c;\n        }\n        this.outer.update(pad);\n        this.istate = new Uint32Array(8);\n        this.ostate = new Uint32Array(8);\n        this.inner._saveState(this.istate);\n        this.outer._saveState(this.ostate);\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] = 0;\n        }\n    }\n    // Returns HMAC state to the state initialized with key\n    // to make it possible to run HMAC over the other data with the same\n    // key without creating a new instance.\n    HMAC.prototype.reset = function () {\n        this.inner._restoreState(this.istate, this.inner.blockSize);\n        this.outer._restoreState(this.ostate, this.outer.blockSize);\n        return this;\n    };\n    // Cleans HMAC state.\n    HMAC.prototype.clean = function () {\n        for (var i = 0; i < this.istate.length; i++) {\n            this.ostate[i] = this.istate[i] = 0;\n        }\n        this.inner.clean();\n        this.outer.clean();\n    };\n    // Updates state with provided data.\n    HMAC.prototype.update = function (data) {\n        this.inner.update(data);\n        return this;\n    };\n    // Finalizes HMAC and puts the result in out.\n    HMAC.prototype.finish = function (out) {\n        if (this.outer.finished) {\n            this.outer.finish(out);\n        }\n        else {\n            this.inner.finish(out);\n            this.outer.update(out, this.digestLength).finish(out);\n        }\n        return this;\n    };\n    // Returns message authentication code.\n    HMAC.prototype.digest = function () {\n        var out = new Uint8Array(this.digestLength);\n        this.finish(out);\n        return out;\n    };\n    return HMAC;\n}());\nexports.HMAC = HMAC;\n// Returns SHA256 hash of data.\nfunction hash(data) {\n    var h = (new Hash()).update(data);\n    var digest = h.digest();\n    h.clean();\n    return digest;\n}\nexports.hash = hash;\n// Function hash is both available as module.hash and as default export.\nexports[\"default\"] = hash;\n// Returns HMAC-SHA256 of data under the key.\nfunction hmac(key, data) {\n    var h = (new HMAC(key)).update(data);\n    var digest = h.digest();\n    h.clean();\n    return digest;\n}\nexports.hmac = hmac;\n// Fills hkdf buffer like this:\n// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)\nfunction fillBuffer(buffer, hmac, info, counter) {\n    // Counter is a byte value: check if it overflowed.\n    var num = counter[0];\n    if (num === 0) {\n        throw new Error(\"hkdf: cannot expand more\");\n    }\n    // Prepare HMAC instance for new data with old key.\n    hmac.reset();\n    // Hash in previous output if it was generated\n    // (i.e. counter is greater than 1).\n    if (num > 1) {\n        hmac.update(buffer);\n    }\n    // Hash in info if it exists.\n    if (info) {\n        hmac.update(info);\n    }\n    // Hash in the counter.\n    hmac.update(counter);\n    // Output result to buffer and clean HMAC instance.\n    hmac.finish(buffer);\n    // Increment counter inside typed array, this works properly.\n    counter[0]++;\n}\nvar hkdfSalt = new Uint8Array(exports.digestLength); // Filled with zeroes.\nfunction hkdf(key, salt, info, length) {\n    if (salt === void 0) { salt = hkdfSalt; }\n    if (length === void 0) { length = 32; }\n    var counter = new Uint8Array([1]);\n    // HKDF-Extract uses salt as HMAC key, and key as data.\n    var okm = hmac(salt, key);\n    // Initialize HMAC for expanding with extracted key.\n    // Ensure no collisions with `hmac` function.\n    var hmac_ = new HMAC(okm);\n    // Allocate buffer.\n    var buffer = new Uint8Array(hmac_.digestLength);\n    var bufpos = buffer.length;\n    var out = new Uint8Array(length);\n    for (var i = 0; i < length; i++) {\n        if (bufpos === buffer.length) {\n            fillBuffer(buffer, hmac_, info, counter);\n            bufpos = 0;\n        }\n        out[i] = buffer[bufpos++];\n    }\n    hmac_.clean();\n    buffer.fill(0);\n    counter.fill(0);\n    return out;\n}\nexports.hkdf = hkdf;\n// Derives a key from password and salt using PBKDF2-HMAC-SHA256\n// with the given number of iterations.\n//\n// The number of bytes returned is equal to dkLen.\n//\n// (For better security, avoid dkLen greater than hash length - 32 bytes).\nfunction pbkdf2(password, salt, iterations, dkLen) {\n    var prf = new HMAC(password);\n    var len = prf.digestLength;\n    var ctr = new Uint8Array(4);\n    var t = new Uint8Array(len);\n    var u = new Uint8Array(len);\n    var dk = new Uint8Array(dkLen);\n    for (var i = 0; i * len < dkLen; i++) {\n        var c = i + 1;\n        ctr[0] = (c >>> 24) & 0xff;\n        ctr[1] = (c >>> 16) & 0xff;\n        ctr[2] = (c >>> 8) & 0xff;\n        ctr[3] = (c >>> 0) & 0xff;\n        prf.reset();\n        prf.update(salt);\n        prf.update(ctr);\n        prf.finish(u);\n        for (var j = 0; j < len; j++) {\n            t[j] = u[j];\n        }\n        for (var j = 2; j <= iterations; j++) {\n            prf.reset();\n            prf.update(u).finish(u);\n            for (var k = 0; k < len; k++) {\n                t[k] ^= u[k];\n            }\n        }\n        for (var j = 0; j < len && i * len + j < dkLen; j++) {\n            dk[i * len + j] = t[j];\n        }\n    }\n    for (var i = 0; i < len; i++) {\n        t[i] = u[i] = 0;\n    }\n    for (var i = 0; i < 4; i++) {\n        ctr[i] = 0;\n    }\n    prf.clean();\n    return dk;\n}\nexports.pbkdf2 = pbkdf2;\n});\n","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.21';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function',\n      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading whitespace. */\n  var reTrimStart = /^\\s+/;\n\n  /** Used to match a single whitespace character. */\n  var reWhitespace = /\\s/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /**\n   * Used to validate the `validate` option in `_.template` variable.\n   *\n   * Forbids characters which could potentially change the meaning of the function argument definition:\n   * - \"(),\" (modification of function parameters)\n   * - \"=\" (default value)\n   * - \"[]{}\" (destructuring of function parameters)\n   * - \"/\" (beginning of a comment)\n   * - whitespace\n   */\n  var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n      rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** 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/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      // Use `util.types` for Node.js 10+.\n      var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n      if (types) {\n        return types;\n      }\n\n      // Legacy `process.binding('util')` for Node.js < 10.\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * A faster alternative to `Function#apply`, this function invokes `func`\n   * with the `this` binding of `thisArg` and the arguments of `args`.\n   *\n   * @private\n   * @param {Function} func The function to invoke.\n   * @param {*} thisArg The `this` binding of `func`.\n   * @param {Array} args The arguments to invoke `func` with.\n   * @returns {*} Returns the result of `func`.\n   */\n  function apply(func, thisArg, args) {\n    switch (args.length) {\n      case 0: return func.call(thisArg);\n      case 1: return func.call(thisArg, args[0]);\n      case 2: return func.call(thisArg, args[0], args[1]);\n      case 3: return func.call(thisArg, args[0], args[1], args[2]);\n    }\n    return func.apply(thisArg, args);\n  }\n\n  /**\n   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined) {\n        result = result === undefined ? current : (result + current);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.times` without support for iteratee shorthands\n   * or max array length checks.\n   *\n   * @private\n   * @param {number} n The number of times to invoke `iteratee`.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the array of results.\n   */\n  function baseTimes(n, iteratee) {\n    var index = -1,\n        result = Array(n);\n\n    while (++index < n) {\n      result[index] = iteratee(index);\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.trim`.\n   *\n   * @private\n   * @param {string} string The string to trim.\n   * @returns {string} Returns the trimmed string.\n   */\n  function baseTrim(string) {\n    return string\n      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n      : string;\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\n    });\n    return result;\n  }\n\n  /**\n   * Creates a unary function that invokes `func` with its argument transformed.\n   *\n   * @private\n   * @param {Function} func The function to wrap.\n   * @param {Function} transform The argument transform.\n   * @returns {Function} Returns the new function.\n   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n   * character of `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the index of the last non-whitespace character.\n   */\n  function trimmedEndIndex(string) {\n    var index = string.length;\n\n    while (index-- && reWhitespace.test(string.charAt(index))) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\n\n    /**\n     * Used to resolve the\n     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n     * of values.\n     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n        symIterator = Symbol ? Symbol.iterator : undefined,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n        symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of the enumerable property names of the array-like `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @param {boolean} inherited Specify returning inherited property names.\n     * @returns {Array} Returns the array of property names.\n     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined && !eq(object[key], value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Assigns `value` to `key` of `object` if the existing value is not equivalent\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignValue(object, key, value) {\n      var objValue = object[key];\n      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      if (isSet(value)) {\n        value.forEach(function(subValue) {\n          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n        });\n      } else if (isMap(value)) {\n        value.forEach(function(subValue, key) {\n          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n        });\n      }\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\n    }\n\n    /**\n     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeys(object) {\n      if (!isPrototype(object)) {\n        return nativeKeys(object);\n      }\n      var result = [];\n      for (var key in Object(object)) {\n        if (hasOwnProperty.call(object, key) && key != 'constructor') {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        stack || (stack = new Stack);\n        if (isObject(srcValue)) {\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n            : undefined;\n\n          if (newValue === undefined) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = safeGet(object, key),\n          srcValue = safeGet(source, key),\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      var isCommon = newValue === undefined;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || isFunction(objValue)) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      if (iteratees.length) {\n        iteratees = arrayMap(iteratees, function(iteratee) {\n          if (isArray(iteratee)) {\n            return function(value) {\n              return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n            }\n          }\n          return iteratee;\n        });\n      } else {\n        iteratees = [identity];\n      }\n\n      var index = -1;\n      iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (n);\n\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n          return object;\n        }\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined;\n          if (newValue === undefined) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      var low = 0,\n          high = array == null ? 0 : array.length;\n      if (high === 0) {\n        return 0;\n      }\n\n      value = iteratee(value);\n      var valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\n    }\n\n    /**\n     * Copies properties of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy properties from.\n     * @param {Array} props The property identifiers to copy.\n     * @param {Object} [object={}] The object to copy properties to.\n     * @param {Function} [customizer] The function to customize copied values.\n     * @returns {Object} Returns `object`.\n     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\n      object || (object = {});\n\n      var index = -1,\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index];\n\n        var newValue = customizer\n          ? customizer(object[key], source[key], key, object, source)\n          : undefined;\n\n        if (newValue === undefined) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\n    }\n\n    /**\n     * Creates a function like `_.assign`.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @returns {Function} Returns the new assigner function.\n     */\n    function createAssigner(assigner) {\n      return baseRest(function(object, sources) {\n        var index = -1,\n            length = sources.length,\n            customizer = length > 1 ? sources[length - 1] : undefined,\n            guard = length > 2 ? sources[2] : undefined;\n\n        customizer = (assigner.length > 3 && typeof customizer == 'function')\n          ? (length--, customizer)\n          : undefined;\n\n        if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n          customizer = length < 3 ? undefined : customizer;\n          length = 1;\n        }\n        object = Object(object);\n        while (++index < length) {\n          var source = sources[index];\n          if (source) {\n            assigner(object, source, index, customizer);\n          }\n        }\n        return object;\n      });\n    }\n\n    /**\n     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined,\n            args, holders, undefined, undefined, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined && other === undefined) {\n          return defaultValue;\n        }\n        if (value !== undefined) {\n          result = value;\n        }\n        if (other !== undefined) {\n          if (result === undefined) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined,\n          newHoldersRight = isCurry ? undefined : holders,\n          newPartials = isCurry ? partials : undefined,\n          newPartialsRight = isCurry ? undefined : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision && nativeIsFinite(number)) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Check that cyclic values are equal.\n      var arrStacked = stack.get(array);\n      var othStacked = stack.get(other);\n      if (arrStacked && othStacked) {\n        return arrStacked == other && othStacked == array;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Check that cyclic values are equal.\n      var objStacked = stack.get(object);\n      var othStacked = stack.get(other);\n      if (objStacked && othStacked) {\n        return objStacked == other && othStacked == object;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = new array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return new Ctor;\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return new Ctor;\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like index.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n     */\n    function isIndex(value, length) {\n      var type = typeof value;\n      length = length == null ? MAX_SAFE_INTEGER : length;\n\n      return !!length &&\n        (type == 'number' ||\n          (type != 'symbol' && reIsUint.test(value))) &&\n            (value > -1 && value % 1 == 0 && value < length);\n    }\n\n    /**\n     * Checks if the given arguments are from an iteratee call.\n     *\n     * @private\n     * @param {*} value The potential iteratee value argument.\n     * @param {*} index The potential iteratee index or key argument.\n     * @param {*} object The potential iteratee object argument.\n     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n     *  else `false`.\n     */\n    function isIterateeCall(value, index, object) {\n      if (!isObject(object)) {\n        return false;\n      }\n      var type = typeof index;\n      if (type == 'number'\n            ? (isArrayLike(object) && isIndex(index, object.length))\n            : (type == 'string' && index in object)\n          ) {\n        return eq(object[index], value);\n      }\n      return false;\n    }\n\n    /**\n     * Checks if `value` is a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\n\n    /**\n     * Checks if `value` is likely a prototype object.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n     */\n    function isPrototype(value) {\n      var Ctor = value && value.constructor,\n          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n      return value === proto;\n    }\n\n    /**\n     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\n      start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n      return function() {\n        var args = arguments,\n            index = -1,\n            length = nativeMax(args.length - start, 0),\n            array = Array(length);\n\n        while (++index < length) {\n          array[index] = args[start + index];\n        }\n        index = -1;\n        var otherArgs = Array(start + 1);\n        while (++index < start) {\n          otherArgs[index] = args[index];\n        }\n        otherArgs[start] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the property to get.\n     * @returns {*} Returns the property value.\n     */\n    function safeGet(object, key) {\n      if (key === 'constructor' && typeof object[key] === 'function') {\n        return;\n      }\n\n      if (key == '__proto__') {\n        return;\n      }\n\n      return object[key];\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (string.charCodeAt(0) === 46 /* . */) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, subString) {\n        result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     *\n     * // Combining several predicates using `_.overEvery` or `_.overSome`.\n     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n     * // => objects for ['fred', 'barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 30 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            timeWaiting = wait - timeSinceLastCall;\n\n        return maxing\n          ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n          : timeWaiting;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n      }\n\n      function flush() {\n        return timerId === undefined ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            clearTimeout(timerId);\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\n    }\n\n    /**\n     * Performs a\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * comparison between two values to determine if they are equivalent.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.eq(object, object);\n     * // => true\n     *\n     * _.eq(object, other);\n     * // => false\n     *\n     * _.eq('a', 'a');\n     * // => true\n     *\n     * _.eq('a', Object('a'));\n     * // => false\n     *\n     * _.eq(NaN, NaN);\n     * // => true\n     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= other;\n    });\n\n    /**\n     * Checks if `value` is likely an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\n    };\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(document.body.children);\n     * // => false\n     *\n     * _.isArray('abc');\n     * // => false\n     *\n     * _.isArray(_.noop);\n     * // => false\n     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n    /**\n     * Checks if `value` is array-like. A value is considered array-like if it's\n     * not a function and has a `value.length` that's an integer greater than or\n     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     * @example\n     *\n     * _.isArrayLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLike(document.body.children);\n     * // => true\n     *\n     * _.isArrayLike('abc');\n     * // => true\n     *\n     * _.isArrayLike(_.noop);\n     * // => false\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(value.length) && !isFunction(value);\n    }\n\n    /**\n     * This method is like `_.isArrayLike` except that it also checks if `value`\n     * is an object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array-like object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArrayLikeObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLikeObject(document.body.children);\n     * // => true\n     *\n     * _.isArrayLikeObject('abc');\n     * // => false\n     *\n     * _.isArrayLikeObject(_.noop);\n     * // => false\n     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     * @example\n     *\n     * _.isLength(3);\n     * // => true\n     *\n     * _.isLength(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isLength(Infinity);\n     * // => false\n     *\n     * _.isLength('3');\n     * // => false\n     */\n    function isLength(value) {\n      return typeof value == 'number' &&\n        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is the\n     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(_.noop);\n     * // => true\n     *\n     * _.isObject(null);\n     * // => false\n     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Checks if `value` is object-like. A value is object-like if it's not `null`\n     * and has a `typeof` result of \"object\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n     * @example\n     *\n     * _.isObjectLike({});\n     * // => true\n     *\n     * _.isObjectLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isObjectLike(_.noop);\n     * // => false\n     *\n     * _.isObjectLike(null);\n     * // => false\n     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = baseTrim(value);\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Assigns own enumerable string keyed properties of source objects to the\n     * destination object. Source objects are applied from left to right.\n     * Subsequent sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object` and is loosely based on\n     * [`Object.assign`](https://mdn.io/Object/assign).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assignIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assign({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var assign = createAssigner(function(object, source) {\n      if (isPrototype(source) || isArrayLike(source)) {\n        copyObject(source, keys(source), object);\n        return;\n      }\n      for (var key in source) {\n        if (hasOwnProperty.call(source, key)) {\n          assignValue(object, key, source[key]);\n        }\n      }\n    });\n\n    /**\n     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(object, sources) {\n      object = Object(object);\n\n      var index = -1;\n      var length = sources.length;\n      var guard = length > 2 ? sources[2] : undefined;\n\n      if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n        length = 1;\n      }\n\n      while (++index < length) {\n        var source = sources[index];\n        var props = keysIn(source);\n        var propsIndex = -1;\n        var propsLength = props.length;\n\n        while (++propsIndex < propsLength) {\n          var key = props[propsIndex];\n          var value = object[key];\n\n          if (value === undefined ||\n              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n            object[key] = source[key];\n          }\n        }\n      }\n\n      return object;\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined, customDefaultsMerge);\n      return apply(mergeWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, path);\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\n\n    /**\n     * Creates an array of the own enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects. See the\n     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * for more details.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keys(new Foo);\n     * // => ['a', 'b'] (iteration order is not guaranteed)\n     *\n     * _.keys('hi');\n     * // => ['0', '1']\n     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined : object[toKey(path[index])];\n        if (value === undefined) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined) {\n        upper = lower;\n        lower = undefined;\n      }\n      if (upper !== undefined) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined;\n      }\n      if (floating === undefined) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined;\n        }\n      }\n      if (lower === undefined && upper === undefined) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      // The sourceURL gets injected into the source that's eval-ed, so be careful\n      // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n      // and escape the comment, thus injecting code that gets evaled.\n      var sourceURL = '//# sourceURL=' +\n        (hasOwnProperty.call(options, 'sourceURL')\n          ? (options.sourceURL + '').replace(/\\s/g, ' ')\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Throw an error if a forbidden character was found in `variable`, to prevent\n      // potential command injection attacks.\n      else if (reForbiddenIdentifierChars.test(variable)) {\n        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);\n      }\n\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return baseTrim(string);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.slice(0, trimmedEndIndex(string) + 1);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     *\n     * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = lodashFunc.name + '';\n        if (!hasOwnProperty.call(realNames, key)) {\n          realNames[key] = [];\n        }\n        realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n","!function(e){var t;\"object\"==typeof exports?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(\"undefined\"!=typeof window?t=window:\"undefined\"!=typeof global?t=global:\"undefined\"!=typeof self&&(t=self),t.objectHash=e())}(function(){return function r(o,i,u){function s(n,e){if(!i[n]){if(!o[n]){var t=\"function\"==typeof require&&require;if(!e&&t)return t(n,!0);if(a)return a(n,!0);throw new Error(\"Cannot find module '\"+n+\"'\")}e=i[n]={exports:{}};o[n][0].call(e.exports,function(e){var t=o[n][1][e];return s(t||e)},e,e.exports,r,o,i,u)}return i[n].exports}for(var a=\"function\"==typeof require&&require,e=0;e<u.length;e++)s(u[e]);return s}({1:[function(w,b,m){!function(e,n,s,c,d,h,p,g,y){\"use strict\";var r=w(\"crypto\");function t(e,t){t=u(e,t);var n;return void 0===(n=\"passthrough\"!==t.algorithm?r.createHash(t.algorithm):new l).write&&(n.write=n.update,n.end=n.update),f(t,n).dispatch(e),n.update||n.end(\"\"),n.digest?n.digest(\"buffer\"===t.encoding?void 0:t.encoding):(e=n.read(),\"buffer\"!==t.encoding?e.toString(t.encoding):e)}(m=b.exports=t).sha1=function(e){return t(e)},m.keys=function(e){return t(e,{excludeValues:!0,algorithm:\"sha1\",encoding:\"hex\"})},m.MD5=function(e){return t(e,{algorithm:\"md5\",encoding:\"hex\"})},m.keysMD5=function(e){return t(e,{algorithm:\"md5\",encoding:\"hex\",excludeValues:!0})};var o=r.getHashes?r.getHashes().slice():[\"sha1\",\"md5\"],i=(o.push(\"passthrough\"),[\"buffer\",\"hex\",\"binary\",\"base64\"]);function u(e,t){var n={};if(n.algorithm=(t=t||{}).algorithm||\"sha1\",n.encoding=t.encoding||\"hex\",n.excludeValues=!!t.excludeValues,n.algorithm=n.algorithm.toLowerCase(),n.encoding=n.encoding.toLowerCase(),n.ignoreUnknown=!0===t.ignoreUnknown,n.respectType=!1!==t.respectType,n.respectFunctionNames=!1!==t.respectFunctionNames,n.respectFunctionProperties=!1!==t.respectFunctionProperties,n.unorderedArrays=!0===t.unorderedArrays,n.unorderedSets=!1!==t.unorderedSets,n.unorderedObjects=!1!==t.unorderedObjects,n.replacer=t.replacer||void 0,n.excludeKeys=t.excludeKeys||void 0,void 0===e)throw new Error(\"Object argument required.\");for(var r=0;r<o.length;++r)o[r].toLowerCase()===n.algorithm.toLowerCase()&&(n.algorithm=o[r]);if(-1===o.indexOf(n.algorithm))throw new Error('Algorithm \"'+n.algorithm+'\"  not supported. supported values: '+o.join(\", \"));if(-1===i.indexOf(n.encoding)&&\"passthrough\"!==n.algorithm)throw new Error('Encoding \"'+n.encoding+'\"  not supported. supported values: '+i.join(\", \"));return n}function a(e){if(\"function\"==typeof e)return null!=/^function\\s+\\w*\\s*\\(\\s*\\)\\s*{\\s+\\[native code\\]\\s+}$/i.exec(Function.prototype.toString.call(e))}function f(o,t,i){i=i||[];function u(e){return t.update?t.update(e,\"utf8\"):t.write(e,\"utf8\")}return{dispatch:function(e){return this[\"_\"+(null===(e=o.replacer?o.replacer(e):e)?\"null\":typeof e)](e)},_object:function(t){var n,e=Object.prototype.toString.call(t),r=/\\[object (.*)\\]/i.exec(e);r=(r=r?r[1]:\"unknown:[\"+e+\"]\").toLowerCase();if(0<=(e=i.indexOf(t)))return this.dispatch(\"[CIRCULAR:\"+e+\"]\");if(i.push(t),void 0!==s&&s.isBuffer&&s.isBuffer(t))return u(\"buffer:\"),u(t);if(\"object\"===r||\"function\"===r||\"asyncfunction\"===r)return e=Object.keys(t),o.unorderedObjects&&(e=e.sort()),!1===o.respectType||a(t)||e.splice(0,0,\"prototype\",\"__proto__\",\"constructor\"),o.excludeKeys&&(e=e.filter(function(e){return!o.excludeKeys(e)})),u(\"object:\"+e.length+\":\"),n=this,e.forEach(function(e){n.dispatch(e),u(\":\"),o.excludeValues||n.dispatch(t[e]),u(\",\")});if(!this[\"_\"+r]){if(o.ignoreUnknown)return u(\"[\"+r+\"]\");throw new Error('Unknown object type \"'+r+'\"')}this[\"_\"+r](t)},_array:function(e,t){t=void 0!==t?t:!1!==o.unorderedArrays;var n=this;if(u(\"array:\"+e.length+\":\"),!t||e.length<=1)return e.forEach(function(e){return n.dispatch(e)});var r=[],t=e.map(function(e){var t=new l,n=i.slice();return f(o,t,n).dispatch(e),r=r.concat(n.slice(i.length)),t.read().toString()});return i=i.concat(r),t.sort(),this._array(t,!1)},_date:function(e){return u(\"date:\"+e.toJSON())},_symbol:function(e){return u(\"symbol:\"+e.toString())},_error:function(e){return u(\"error:\"+e.toString())},_boolean:function(e){return u(\"bool:\"+e.toString())},_string:function(e){u(\"string:\"+e.length+\":\"),u(e.toString())},_function:function(e){u(\"fn:\"),a(e)?this.dispatch(\"[native]\"):this.dispatch(e.toString()),!1!==o.respectFunctionNames&&this.dispatch(\"function-name:\"+String(e.name)),o.respectFunctionProperties&&this._object(e)},_number:function(e){return u(\"number:\"+e.toString())},_xml:function(e){return u(\"xml:\"+e.toString())},_null:function(){return u(\"Null\")},_undefined:function(){return u(\"Undefined\")},_regexp:function(e){return u(\"regex:\"+e.toString())},_uint8array:function(e){return u(\"uint8array:\"),this.dispatch(Array.prototype.slice.call(e))},_uint8clampedarray:function(e){return u(\"uint8clampedarray:\"),this.dispatch(Array.prototype.slice.call(e))},_int8array:function(e){return u(\"int8array:\"),this.dispatch(Array.prototype.slice.call(e))},_uint16array:function(e){return u(\"uint16array:\"),this.dispatch(Array.prototype.slice.call(e))},_int16array:function(e){return u(\"int16array:\"),this.dispatch(Array.prototype.slice.call(e))},_uint32array:function(e){return u(\"uint32array:\"),this.dispatch(Array.prototype.slice.call(e))},_int32array:function(e){return u(\"int32array:\"),this.dispatch(Array.prototype.slice.call(e))},_float32array:function(e){return u(\"float32array:\"),this.dispatch(Array.prototype.slice.call(e))},_float64array:function(e){return u(\"float64array:\"),this.dispatch(Array.prototype.slice.call(e))},_arraybuffer:function(e){return u(\"arraybuffer:\"),this.dispatch(new Uint8Array(e))},_url:function(e){return u(\"url:\"+e.toString())},_map:function(e){u(\"map:\");e=Array.from(e);return this._array(e,!1!==o.unorderedSets)},_set:function(e){u(\"set:\");e=Array.from(e);return this._array(e,!1!==o.unorderedSets)},_file:function(e){return u(\"file:\"),this.dispatch([e.name,e.size,e.type,e.lastModfied])},_blob:function(){if(o.ignoreUnknown)return u(\"[blob]\");throw Error('Hashing Blob objects is currently not supported\\n(see https://github.com/puleos/object-hash/issues/26)\\nUse \"options.replacer\" or \"options.ignoreUnknown\"\\n')},_domwindow:function(){return u(\"domwindow\")},_bigint:function(e){return u(\"bigint:\"+e.toString())},_process:function(){return u(\"process\")},_timer:function(){return u(\"timer\")},_pipe:function(){return u(\"pipe\")},_tcp:function(){return u(\"tcp\")},_udp:function(){return u(\"udp\")},_tty:function(){return u(\"tty\")},_statwatcher:function(){return u(\"statwatcher\")},_securecontext:function(){return u(\"securecontext\")},_connection:function(){return u(\"connection\")},_zlib:function(){return u(\"zlib\")},_context:function(){return u(\"context\")},_nodescript:function(){return u(\"nodescript\")},_httpparser:function(){return u(\"httpparser\")},_dataview:function(){return u(\"dataview\")},_signal:function(){return u(\"signal\")},_fsevent:function(){return u(\"fsevent\")},_tlswrap:function(){return u(\"tlswrap\")}}}function l(){return{buf:\"\",write:function(e){this.buf+=e},end:function(e){this.buf+=e},read:function(){return this.buf}}}m.writeToStream=function(e,t,n){return void 0===n&&(n=t,t={}),f(t=u(e,t),n).dispatch(e)}}.call(this,w(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},w(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/fake_9a5aa49d.js\",\"/\")},{buffer:3,crypto:5,lYpoI2:11}],2:[function(e,t,f){!function(e,t,n,r,o,i,u,s,a){!function(e){\"use strict\";var a=\"undefined\"!=typeof Uint8Array?Uint8Array:Array,t=\"+\".charCodeAt(0),n=\"/\".charCodeAt(0),r=\"0\".charCodeAt(0),o=\"a\".charCodeAt(0),i=\"A\".charCodeAt(0),u=\"-\".charCodeAt(0),s=\"_\".charCodeAt(0);function f(e){e=e.charCodeAt(0);return e===t||e===u?62:e===n||e===s?63:e<r?-1:e<r+10?e-r+26+26:e<i+26?e-i:e<o+26?e-o+26:void 0}e.toByteArray=function(e){var t,n;if(0<e.length%4)throw new Error(\"Invalid string. Length must be a multiple of 4\");var r=e.length,r=\"=\"===e.charAt(r-2)?2:\"=\"===e.charAt(r-1)?1:0,o=new a(3*e.length/4-r),i=0<r?e.length-4:e.length,u=0;function s(e){o[u++]=e}for(t=0;t<i;t+=4,0)s((16711680&(n=f(e.charAt(t))<<18|f(e.charAt(t+1))<<12|f(e.charAt(t+2))<<6|f(e.charAt(t+3))))>>16),s((65280&n)>>8),s(255&n);return 2==r?s(255&(n=f(e.charAt(t))<<2|f(e.charAt(t+1))>>4)):1==r&&(s((n=f(e.charAt(t))<<10|f(e.charAt(t+1))<<4|f(e.charAt(t+2))>>2)>>8&255),s(255&n)),o},e.fromByteArray=function(e){var t,n,r,o,i=e.length%3,u=\"\";function s(e){return\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\".charAt(e)}for(t=0,r=e.length-i;t<r;t+=3)n=(e[t]<<16)+(e[t+1]<<8)+e[t+2],u+=s((o=n)>>18&63)+s(o>>12&63)+s(o>>6&63)+s(63&o);switch(i){case 1:u=(u+=s((n=e[e.length-1])>>2))+s(n<<4&63)+\"==\";break;case 2:u=(u=(u+=s((n=(e[e.length-2]<<8)+e[e.length-1])>>10))+s(n>>4&63))+s(n<<2&63)+\"=\"}return u}}(void 0===f?this.base64js={}:f)}.call(this,e(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},e(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/base64-js/lib/b64.js\",\"/node_modules/gulp-browserify/node_modules/base64-js/lib\")},{buffer:3,lYpoI2:11}],3:[function(O,e,H){!function(e,n,f,r,h,p,g,y,w){var a=O(\"base64-js\"),i=O(\"ieee754\");function f(e,t,n){if(!(this instanceof f))return new f(e,t,n);var r,o,i,u,s=typeof e;if(\"base64\"===t&&\"string\"==s)for(e=(u=e).trim?u.trim():u.replace(/^\\s+|\\s+$/g,\"\");e.length%4!=0;)e+=\"=\";if(\"number\"==s)r=j(e);else if(\"string\"==s)r=f.byteLength(e,t);else{if(\"object\"!=s)throw new Error(\"First argument needs to be a number, array or string.\");r=j(e.length)}if(f._useTypedArrays?o=f._augment(new Uint8Array(r)):((o=this).length=r,o._isBuffer=!0),f._useTypedArrays&&\"number\"==typeof e.byteLength)o._set(e);else if(C(u=e)||f.isBuffer(u)||u&&\"object\"==typeof u&&\"number\"==typeof u.length)for(i=0;i<r;i++)f.isBuffer(e)?o[i]=e.readUInt8(i):o[i]=e[i];else if(\"string\"==s)o.write(e,0,t);else if(\"number\"==s&&!f._useTypedArrays&&!n)for(i=0;i<r;i++)o[i]=0;return o}function b(e,t,n,r){return f._charsWritten=c(function(e){for(var t=[],n=0;n<e.length;n++)t.push(255&e.charCodeAt(n));return t}(t),e,n,r)}function m(e,t,n,r){return f._charsWritten=c(function(e){for(var t,n,r=[],o=0;o<e.length;o++)n=e.charCodeAt(o),t=n>>8,n=n%256,r.push(n),r.push(t);return r}(t),e,n,r)}function v(e,t,n){var r=\"\";n=Math.min(e.length,n);for(var o=t;o<n;o++)r+=String.fromCharCode(e[o]);return r}function o(e,t,n,r){r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(null!=t,\"missing offset\"),d(t+1<e.length,\"Trying to read beyond buffer length\"));var o,r=e.length;if(!(r<=t))return n?(o=e[t],t+1<r&&(o|=e[t+1]<<8)):(o=e[t]<<8,t+1<r&&(o|=e[t+1])),o}function u(e,t,n,r){r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(null!=t,\"missing offset\"),d(t+3<e.length,\"Trying to read beyond buffer length\"));var o,r=e.length;if(!(r<=t))return n?(t+2<r&&(o=e[t+2]<<16),t+1<r&&(o|=e[t+1]<<8),o|=e[t],t+3<r&&(o+=e[t+3]<<24>>>0)):(t+1<r&&(o=e[t+1]<<16),t+2<r&&(o|=e[t+2]<<8),t+3<r&&(o|=e[t+3]),o+=e[t]<<24>>>0),o}function _(e,t,n,r){if(r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(null!=t,\"missing offset\"),d(t+1<e.length,\"Trying to read beyond buffer length\")),!(e.length<=t))return r=o(e,t,n,!0),32768&r?-1*(65535-r+1):r}function E(e,t,n,r){if(r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(null!=t,\"missing offset\"),d(t+3<e.length,\"Trying to read beyond buffer length\")),!(e.length<=t))return r=u(e,t,n,!0),2147483648&r?-1*(4294967295-r+1):r}function I(e,t,n,r){return r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(t+3<e.length,\"Trying to read beyond buffer length\")),i.read(e,t,n,23,4)}function A(e,t,n,r){return r||(d(\"boolean\"==typeof n,\"missing or invalid endian\"),d(t+7<e.length,\"Trying to read beyond buffer length\")),i.read(e,t,n,52,8)}function s(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+1<e.length,\"trying to write beyond buffer length\"),Y(t,65535));o=e.length;if(!(o<=n))for(var i=0,u=Math.min(o-n,2);i<u;i++)e[n+i]=(t&255<<8*(r?i:1-i))>>>8*(r?i:1-i)}function l(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+3<e.length,\"trying to write beyond buffer length\"),Y(t,4294967295));o=e.length;if(!(o<=n))for(var i=0,u=Math.min(o-n,4);i<u;i++)e[n+i]=t>>>8*(r?i:3-i)&255}function B(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+1<e.length,\"Trying to write beyond buffer length\"),F(t,32767,-32768)),e.length<=n||s(e,0<=t?t:65535+t+1,n,r,o)}function L(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+3<e.length,\"Trying to write beyond buffer length\"),F(t,2147483647,-2147483648)),e.length<=n||l(e,0<=t?t:4294967295+t+1,n,r,o)}function U(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+3<e.length,\"Trying to write beyond buffer length\"),D(t,34028234663852886e22,-34028234663852886e22)),e.length<=n||i.write(e,t,n,r,23,4)}function x(e,t,n,r,o){o||(d(null!=t,\"missing value\"),d(\"boolean\"==typeof r,\"missing or invalid endian\"),d(null!=n,\"missing offset\"),d(n+7<e.length,\"Trying to write beyond buffer length\"),D(t,17976931348623157e292,-17976931348623157e292)),e.length<=n||i.write(e,t,n,r,52,8)}H.Buffer=f,H.SlowBuffer=f,H.INSPECT_MAX_BYTES=50,f.poolSize=8192,f._useTypedArrays=function(){try{var e=new ArrayBuffer(0),t=new Uint8Array(e);return t.foo=function(){return 42},42===t.foo()&&\"function\"==typeof t.subarray}catch(e){return!1}}(),f.isEncoding=function(e){switch(String(e).toLowerCase()){case\"hex\":case\"utf8\":case\"utf-8\":case\"ascii\":case\"binary\":case\"base64\":case\"raw\":case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return!0;default:return!1}},f.isBuffer=function(e){return!(null==e||!e._isBuffer)},f.byteLength=function(e,t){var n;switch(e+=\"\",t||\"utf8\"){case\"hex\":n=e.length/2;break;case\"utf8\":case\"utf-8\":n=T(e).length;break;case\"ascii\":case\"binary\":case\"raw\":n=e.length;break;case\"base64\":n=M(e).length;break;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":n=2*e.length;break;default:throw new Error(\"Unknown encoding\")}return n},f.concat=function(e,t){if(d(C(e),\"Usage: Buffer.concat(list, [totalLength])\\nlist should be an Array.\"),0===e.length)return new f(0);if(1===e.length)return e[0];if(\"number\"!=typeof t)for(o=t=0;o<e.length;o++)t+=e[o].length;for(var n=new f(t),r=0,o=0;o<e.length;o++){var i=e[o];i.copy(n,r),r+=i.length}return n},f.prototype.write=function(e,t,n,r){isFinite(t)?isFinite(n)||(r=n,n=void 0):(a=r,r=t,t=n,n=a),t=Number(t)||0;var o,i,u,s,a=this.length-t;switch((!n||a<(n=Number(n)))&&(n=a),r=String(r||\"utf8\").toLowerCase()){case\"hex\":o=function(e,t,n,r){n=Number(n)||0;var o=e.length-n;(!r||o<(r=Number(r)))&&(r=o),d((o=t.length)%2==0,\"Invalid hex string\"),o/2<r&&(r=o/2);for(var i=0;i<r;i++){var u=parseInt(t.substr(2*i,2),16);d(!isNaN(u),\"Invalid hex string\"),e[n+i]=u}return f._charsWritten=2*i,i}(this,e,t,n);break;case\"utf8\":case\"utf-8\":i=this,u=t,s=n,o=f._charsWritten=c(T(e),i,u,s);break;case\"ascii\":case\"binary\":o=b(this,e,t,n);break;case\"base64\":i=this,u=t,s=n,o=f._charsWritten=c(M(e),i,u,s);break;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":o=m(this,e,t,n);break;default:throw new Error(\"Unknown encoding\")}return o},f.prototype.toString=function(e,t,n){var r,o,i,u,s=this;if(e=String(e||\"utf8\").toLowerCase(),t=Number(t)||0,(n=void 0!==n?Number(n):s.length)===t)return\"\";switch(e){case\"hex\":r=function(e,t,n){var r=e.length;(!t||t<0)&&(t=0);(!n||n<0||r<n)&&(n=r);for(var o=\"\",i=t;i<n;i++)o+=k(e[i]);return o}(s,t,n);break;case\"utf8\":case\"utf-8\":r=function(e,t,n){var r=\"\",o=\"\";n=Math.min(e.length,n);for(var i=t;i<n;i++)e[i]<=127?(r+=N(o)+String.fromCharCode(e[i]),o=\"\"):o+=\"%\"+e[i].toString(16);return r+N(o)}(s,t,n);break;case\"ascii\":case\"binary\":r=v(s,t,n);break;case\"base64\":o=s,u=n,r=0===(i=t)&&u===o.length?a.fromByteArray(o):a.fromByteArray(o.slice(i,u));break;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":r=function(e,t,n){for(var r=e.slice(t,n),o=\"\",i=0;i<r.length;i+=2)o+=String.fromCharCode(r[i]+256*r[i+1]);return o}(s,t,n);break;default:throw new Error(\"Unknown encoding\")}return r},f.prototype.toJSON=function(){return{type:\"Buffer\",data:Array.prototype.slice.call(this._arr||this,0)}},f.prototype.copy=function(e,t,n,r){if(t=t||0,(r=r||0===r?r:this.length)!==(n=n||0)&&0!==e.length&&0!==this.length){d(n<=r,\"sourceEnd < sourceStart\"),d(0<=t&&t<e.length,\"targetStart out of bounds\"),d(0<=n&&n<this.length,\"sourceStart out of bounds\"),d(0<=r&&r<=this.length,\"sourceEnd out of bounds\"),r>this.length&&(r=this.length);var o=(r=e.length-t<r-n?e.length-t+n:r)-n;if(o<100||!f._useTypedArrays)for(var i=0;i<o;i++)e[i+t]=this[i+n];else e._set(this.subarray(n,n+o),t)}},f.prototype.slice=function(e,t){var n=this.length;if(e=S(e,n,0),t=S(t,n,n),f._useTypedArrays)return f._augment(this.subarray(e,t));for(var r=t-e,o=new f(r,void 0,!0),i=0;i<r;i++)o[i]=this[i+e];return o},f.prototype.get=function(e){return console.log(\".get() is deprecated. Access using array indexes instead.\"),this.readUInt8(e)},f.prototype.set=function(e,t){return console.log(\".set() is deprecated. Access using array indexes instead.\"),this.writeUInt8(e,t)},f.prototype.readUInt8=function(e,t){if(t||(d(null!=e,\"missing offset\"),d(e<this.length,\"Trying to read beyond buffer length\")),!(e>=this.length))return this[e]},f.prototype.readUInt16LE=function(e,t){return o(this,e,!0,t)},f.prototype.readUInt16BE=function(e,t){return o(this,e,!1,t)},f.prototype.readUInt32LE=function(e,t){return u(this,e,!0,t)},f.prototype.readUInt32BE=function(e,t){return u(this,e,!1,t)},f.prototype.readInt8=function(e,t){if(t||(d(null!=e,\"missing offset\"),d(e<this.length,\"Trying to read beyond buffer length\")),!(e>=this.length))return 128&this[e]?-1*(255-this[e]+1):this[e]},f.prototype.readInt16LE=function(e,t){return _(this,e,!0,t)},f.prototype.readInt16BE=function(e,t){return _(this,e,!1,t)},f.prototype.readInt32LE=function(e,t){return E(this,e,!0,t)},f.prototype.readInt32BE=function(e,t){return E(this,e,!1,t)},f.prototype.readFloatLE=function(e,t){return I(this,e,!0,t)},f.prototype.readFloatBE=function(e,t){return I(this,e,!1,t)},f.prototype.readDoubleLE=function(e,t){return A(this,e,!0,t)},f.prototype.readDoubleBE=function(e,t){return A(this,e,!1,t)},f.prototype.writeUInt8=function(e,t,n){n||(d(null!=e,\"missing value\"),d(null!=t,\"missing offset\"),d(t<this.length,\"trying to write beyond buffer length\"),Y(e,255)),t>=this.length||(this[t]=e)},f.prototype.writeUInt16LE=function(e,t,n){s(this,e,t,!0,n)},f.prototype.writeUInt16BE=function(e,t,n){s(this,e,t,!1,n)},f.prototype.writeUInt32LE=function(e,t,n){l(this,e,t,!0,n)},f.prototype.writeUInt32BE=function(e,t,n){l(this,e,t,!1,n)},f.prototype.writeInt8=function(e,t,n){n||(d(null!=e,\"missing value\"),d(null!=t,\"missing offset\"),d(t<this.length,\"Trying to write beyond buffer length\"),F(e,127,-128)),t>=this.length||(0<=e?this.writeUInt8(e,t,n):this.writeUInt8(255+e+1,t,n))},f.prototype.writeInt16LE=function(e,t,n){B(this,e,t,!0,n)},f.prototype.writeInt16BE=function(e,t,n){B(this,e,t,!1,n)},f.prototype.writeInt32LE=function(e,t,n){L(this,e,t,!0,n)},f.prototype.writeInt32BE=function(e,t,n){L(this,e,t,!1,n)},f.prototype.writeFloatLE=function(e,t,n){U(this,e,t,!0,n)},f.prototype.writeFloatBE=function(e,t,n){U(this,e,t,!1,n)},f.prototype.writeDoubleLE=function(e,t,n){x(this,e,t,!0,n)},f.prototype.writeDoubleBE=function(e,t,n){x(this,e,t,!1,n)},f.prototype.fill=function(e,t,n){if(t=t||0,n=n||this.length,d(\"number\"==typeof(e=\"string\"==typeof(e=e||0)?e.charCodeAt(0):e)&&!isNaN(e),\"value is not a number\"),d(t<=n,\"end < start\"),n!==t&&0!==this.length){d(0<=t&&t<this.length,\"start out of bounds\"),d(0<=n&&n<=this.length,\"end out of bounds\");for(var r=t;r<n;r++)this[r]=e}},f.prototype.inspect=function(){for(var e=[],t=this.length,n=0;n<t;n++)if(e[n]=k(this[n]),n===H.INSPECT_MAX_BYTES){e[n+1]=\"...\";break}return\"<Buffer \"+e.join(\" \")+\">\"},f.prototype.toArrayBuffer=function(){if(\"undefined\"==typeof Uint8Array)throw new Error(\"Buffer.toArrayBuffer not supported in this browser\");if(f._useTypedArrays)return new f(this).buffer;for(var e=new Uint8Array(this.length),t=0,n=e.length;t<n;t+=1)e[t]=this[t];return e.buffer};var t=f.prototype;function S(e,t,n){return\"number\"!=typeof e?n:t<=(e=~~e)?t:0<=e||0<=(e+=t)?e:0}function j(e){return(e=~~Math.ceil(+e))<0?0:e}function C(e){return(Array.isArray||function(e){return\"[object Array]\"===Object.prototype.toString.call(e)})(e)}function k(e){return e<16?\"0\"+e.toString(16):e.toString(16)}function T(e){for(var t=[],n=0;n<e.length;n++){var r=e.charCodeAt(n);if(r<=127)t.push(e.charCodeAt(n));else for(var o=n,i=(55296<=r&&r<=57343&&n++,encodeURIComponent(e.slice(o,n+1)).substr(1).split(\"%\")),u=0;u<i.length;u++)t.push(parseInt(i[u],16))}return t}function M(e){return a.toByteArray(e)}function c(e,t,n,r){for(var o=0;o<r&&!(o+n>=t.length||o>=e.length);o++)t[o+n]=e[o];return o}function N(e){try{return decodeURIComponent(e)}catch(e){return String.fromCharCode(65533)}}function Y(e,t){d(\"number\"==typeof e,\"cannot write a non-number as a number\"),d(0<=e,\"specified a negative value for writing an unsigned value\"),d(e<=t,\"value is larger than maximum value for type\"),d(Math.floor(e)===e,\"value has a fractional component\")}function F(e,t,n){d(\"number\"==typeof e,\"cannot write a non-number as a number\"),d(e<=t,\"value larger than maximum allowed value\"),d(n<=e,\"value smaller than minimum allowed value\"),d(Math.floor(e)===e,\"value has a fractional component\")}function D(e,t,n){d(\"number\"==typeof e,\"cannot write a non-number as a number\"),d(e<=t,\"value larger than maximum allowed value\"),d(n<=e,\"value smaller than minimum allowed value\")}function d(e,t){if(!e)throw new Error(t||\"Failed assertion\")}f._augment=function(e){return e._isBuffer=!0,e._get=e.get,e._set=e.set,e.get=t.get,e.set=t.set,e.write=t.write,e.toString=t.toString,e.toLocaleString=t.toString,e.toJSON=t.toJSON,e.copy=t.copy,e.slice=t.slice,e.readUInt8=t.readUInt8,e.readUInt16LE=t.readUInt16LE,e.readUInt16BE=t.readUInt16BE,e.readUInt32LE=t.readUInt32LE,e.readUInt32BE=t.readUInt32BE,e.readInt8=t.readInt8,e.readInt16LE=t.readInt16LE,e.readInt16BE=t.readInt16BE,e.readInt32LE=t.readInt32LE,e.readInt32BE=t.readInt32BE,e.readFloatLE=t.readFloatLE,e.readFloatBE=t.readFloatBE,e.readDoubleLE=t.readDoubleLE,e.readDoubleBE=t.readDoubleBE,e.writeUInt8=t.writeUInt8,e.writeUInt16LE=t.writeUInt16LE,e.writeUInt16BE=t.writeUInt16BE,e.writeUInt32LE=t.writeUInt32LE,e.writeUInt32BE=t.writeUInt32BE,e.writeInt8=t.writeInt8,e.writeInt16LE=t.writeInt16LE,e.writeInt16BE=t.writeInt16BE,e.writeInt32LE=t.writeInt32LE,e.writeInt32BE=t.writeInt32BE,e.writeFloatLE=t.writeFloatLE,e.writeFloatBE=t.writeFloatBE,e.writeDoubleLE=t.writeDoubleLE,e.writeDoubleBE=t.writeDoubleBE,e.fill=t.fill,e.inspect=t.inspect,e.toArrayBuffer=t.toArrayBuffer,e}}.call(this,O(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},O(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/buffer/index.js\",\"/node_modules/gulp-browserify/node_modules/buffer\")},{\"base64-js\":2,buffer:3,ieee754:10,lYpoI2:11}],4:[function(c,d,e){!function(e,t,a,n,r,o,i,u,s){var a=c(\"buffer\").Buffer,f=4,l=new a(f);l.fill(0);d.exports={hash:function(e,t,n,r){for(var o=t(function(e,t){e.length%f!=0&&(n=e.length+(f-e.length%f),e=a.concat([e,l],n));for(var n,r=[],o=t?e.readInt32BE:e.readInt32LE,i=0;i<e.length;i+=f)r.push(o.call(e,i));return r}(e=a.isBuffer(e)?e:new a(e),r),8*e.length),t=r,i=new a(n),u=t?i.writeInt32BE:i.writeInt32LE,s=0;s<o.length;s++)u.call(i,o[s],4*s,!0);return i}}}.call(this,c(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},c(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/helpers.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{buffer:3,lYpoI2:11}],5:[function(v,e,_){!function(l,c,u,d,h,p,g,y,w){var u=v(\"buffer\").Buffer,e=v(\"./sha\"),t=v(\"./sha256\"),n=v(\"./rng\"),b={sha1:e,sha256:t,md5:v(\"./md5\")},s=64,a=new u(s);function r(e,n){var r=b[e=e||\"sha1\"],o=[];return r||i(\"algorithm:\",e,\"is not yet supported\"),{update:function(e){return u.isBuffer(e)||(e=new u(e)),o.push(e),e.length,this},digest:function(e){var t=u.concat(o),t=n?function(e,t,n){u.isBuffer(t)||(t=new u(t)),u.isBuffer(n)||(n=new u(n)),t.length>s?t=e(t):t.length<s&&(t=u.concat([t,a],s));for(var r=new u(s),o=new u(s),i=0;i<s;i++)r[i]=54^t[i],o[i]=92^t[i];return n=e(u.concat([r,n])),e(u.concat([o,n]))}(r,n,t):r(t);return o=null,e?t.toString(e):t}}}function i(){var e=[].slice.call(arguments).join(\" \");throw new Error([e,\"we accept pull requests\",\"http://github.com/dominictarr/crypto-browserify\"].join(\"\\n\"))}a.fill(0),_.createHash=function(e){return r(e)},_.createHmac=r,_.randomBytes=function(e,t){if(!t||!t.call)return new u(n(e));try{t.call(this,void 0,new u(n(e)))}catch(e){t(e)}};var o,f=[\"createCredentials\",\"createCipher\",\"createCipheriv\",\"createDecipher\",\"createDecipheriv\",\"createSign\",\"createVerify\",\"createDiffieHellman\",\"pbkdf2\"],m=function(e){_[e]=function(){i(\"sorry,\",e,\"is not implemented yet\")}};for(o in f)m(f[o],o)}.call(this,v(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},v(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/index.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{\"./md5\":6,\"./rng\":7,\"./sha\":8,\"./sha256\":9,buffer:3,lYpoI2:11}],6:[function(w,b,e){!function(e,r,o,i,u,a,f,l,y){var t=w(\"./helpers\");function n(e,t){e[t>>5]|=128<<t%32,e[14+(t+64>>>9<<4)]=t;for(var n=1732584193,r=-271733879,o=-1732584194,i=271733878,u=0;u<e.length;u+=16){var s=n,a=r,f=o,l=i,n=c(n,r,o,i,e[u+0],7,-680876936),i=c(i,n,r,o,e[u+1],12,-389564586),o=c(o,i,n,r,e[u+2],17,606105819),r=c(r,o,i,n,e[u+3],22,-1044525330);n=c(n,r,o,i,e[u+4],7,-176418897),i=c(i,n,r,o,e[u+5],12,1200080426),o=c(o,i,n,r,e[u+6],17,-1473231341),r=c(r,o,i,n,e[u+7],22,-45705983),n=c(n,r,o,i,e[u+8],7,1770035416),i=c(i,n,r,o,e[u+9],12,-1958414417),o=c(o,i,n,r,e[u+10],17,-42063),r=c(r,o,i,n,e[u+11],22,-1990404162),n=c(n,r,o,i,e[u+12],7,1804603682),i=c(i,n,r,o,e[u+13],12,-40341101),o=c(o,i,n,r,e[u+14],17,-1502002290),n=d(n,r=c(r,o,i,n,e[u+15],22,1236535329),o,i,e[u+1],5,-165796510),i=d(i,n,r,o,e[u+6],9,-1069501632),o=d(o,i,n,r,e[u+11],14,643717713),r=d(r,o,i,n,e[u+0],20,-373897302),n=d(n,r,o,i,e[u+5],5,-701558691),i=d(i,n,r,o,e[u+10],9,38016083),o=d(o,i,n,r,e[u+15],14,-660478335),r=d(r,o,i,n,e[u+4],20,-405537848),n=d(n,r,o,i,e[u+9],5,568446438),i=d(i,n,r,o,e[u+14],9,-1019803690),o=d(o,i,n,r,e[u+3],14,-187363961),r=d(r,o,i,n,e[u+8],20,1163531501),n=d(n,r,o,i,e[u+13],5,-1444681467),i=d(i,n,r,o,e[u+2],9,-51403784),o=d(o,i,n,r,e[u+7],14,1735328473),n=h(n,r=d(r,o,i,n,e[u+12],20,-1926607734),o,i,e[u+5],4,-378558),i=h(i,n,r,o,e[u+8],11,-2022574463),o=h(o,i,n,r,e[u+11],16,1839030562),r=h(r,o,i,n,e[u+14],23,-35309556),n=h(n,r,o,i,e[u+1],4,-1530992060),i=h(i,n,r,o,e[u+4],11,1272893353),o=h(o,i,n,r,e[u+7],16,-155497632),r=h(r,o,i,n,e[u+10],23,-1094730640),n=h(n,r,o,i,e[u+13],4,681279174),i=h(i,n,r,o,e[u+0],11,-358537222),o=h(o,i,n,r,e[u+3],16,-722521979),r=h(r,o,i,n,e[u+6],23,76029189),n=h(n,r,o,i,e[u+9],4,-640364487),i=h(i,n,r,o,e[u+12],11,-421815835),o=h(o,i,n,r,e[u+15],16,530742520),n=p(n,r=h(r,o,i,n,e[u+2],23,-995338651),o,i,e[u+0],6,-198630844),i=p(i,n,r,o,e[u+7],10,1126891415),o=p(o,i,n,r,e[u+14],15,-1416354905),r=p(r,o,i,n,e[u+5],21,-57434055),n=p(n,r,o,i,e[u+12],6,1700485571),i=p(i,n,r,o,e[u+3],10,-1894986606),o=p(o,i,n,r,e[u+10],15,-1051523),r=p(r,o,i,n,e[u+1],21,-2054922799),n=p(n,r,o,i,e[u+8],6,1873313359),i=p(i,n,r,o,e[u+15],10,-30611744),o=p(o,i,n,r,e[u+6],15,-1560198380),r=p(r,o,i,n,e[u+13],21,1309151649),n=p(n,r,o,i,e[u+4],6,-145523070),i=p(i,n,r,o,e[u+11],10,-1120210379),o=p(o,i,n,r,e[u+2],15,718787259),r=p(r,o,i,n,e[u+9],21,-343485551),n=g(n,s),r=g(r,a),o=g(o,f),i=g(i,l)}return Array(n,r,o,i)}function s(e,t,n,r,o,i){return g((t=g(g(t,e),g(r,i)))<<o|t>>>32-o,n)}function c(e,t,n,r,o,i,u){return s(t&n|~t&r,e,t,o,i,u)}function d(e,t,n,r,o,i,u){return s(t&r|n&~r,e,t,o,i,u)}function h(e,t,n,r,o,i,u){return s(t^n^r,e,t,o,i,u)}function p(e,t,n,r,o,i,u){return s(n^(t|~r),e,t,o,i,u)}function g(e,t){var n=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(n>>16)<<16|65535&n}b.exports=function(e){return t.hash(e,n,16)}}.call(this,w(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},w(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/md5.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{\"./helpers\":4,buffer:3,lYpoI2:11}],7:[function(e,l,t){!function(e,t,n,r,o,i,u,s,f){var a;l.exports=a||function(e){for(var t,n=new Array(e),r=0;r<e;r++)0==(3&r)&&(t=4294967296*Math.random()),n[r]=t>>>((3&r)<<3)&255;return n}}.call(this,e(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},e(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/rng.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{buffer:3,lYpoI2:11}],8:[function(c,d,e){!function(e,t,n,r,o,s,a,f,l){var i=c(\"./helpers\");function u(l,c){l[c>>5]|=128<<24-c%32,l[15+(c+64>>9<<4)]=c;for(var e,t,n,r=Array(80),o=1732584193,i=-271733879,u=-1732584194,s=271733878,d=-1009589776,h=0;h<l.length;h+=16){for(var p=o,g=i,y=u,w=s,b=d,a=0;a<80;a++){r[a]=a<16?l[h+a]:v(r[a-3]^r[a-8]^r[a-14]^r[a-16],1);var f=m(m(v(o,5),(f=i,t=u,n=s,(e=a)<20?f&t|~f&n:!(e<40)&&e<60?f&t|f&n|t&n:f^t^n)),m(m(d,r[a]),(e=a)<20?1518500249:e<40?1859775393:e<60?-1894007588:-899497514)),d=s,s=u,u=v(i,30),i=o,o=f}o=m(o,p),i=m(i,g),u=m(u,y),s=m(s,w),d=m(d,b)}return Array(o,i,u,s,d)}function m(e,t){var n=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(n>>16)<<16|65535&n}function v(e,t){return e<<t|e>>>32-t}d.exports=function(e){return i.hash(e,u,20,!0)}}.call(this,c(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},c(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/sha.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{\"./helpers\":4,buffer:3,lYpoI2:11}],9:[function(c,d,e){!function(e,t,n,r,u,s,a,f,l){function b(e,t){var n=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(n>>16)<<16|65535&n}function o(e,l){var c,d=new Array(1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298),t=new Array(1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225),n=new Array(64);e[l>>5]|=128<<24-l%32,e[15+(l+64>>9<<4)]=l;for(var r,o,h=0;h<e.length;h+=16){for(var i=t[0],u=t[1],s=t[2],p=t[3],a=t[4],g=t[5],y=t[6],w=t[7],f=0;f<64;f++)n[f]=f<16?e[f+h]:b(b(b((o=n[f-2],m(o,17)^m(o,19)^v(o,10)),n[f-7]),(o=n[f-15],m(o,7)^m(o,18)^v(o,3))),n[f-16]),c=b(b(b(b(w,m(o=a,6)^m(o,11)^m(o,25)),a&g^~a&y),d[f]),n[f]),r=b(m(r=i,2)^m(r,13)^m(r,22),i&u^i&s^u&s),w=y,y=g,g=a,a=b(p,c),p=s,s=u,u=i,i=b(c,r);t[0]=b(i,t[0]),t[1]=b(u,t[1]),t[2]=b(s,t[2]),t[3]=b(p,t[3]),t[4]=b(a,t[4]),t[5]=b(g,t[5]),t[6]=b(y,t[6]),t[7]=b(w,t[7])}return t}var i=c(\"./helpers\"),m=function(e,t){return e>>>t|e<<32-t},v=function(e,t){return e>>>t};d.exports=function(e){return i.hash(e,o,32,!0)}}.call(this,c(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},c(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/crypto-browserify/sha256.js\",\"/node_modules/gulp-browserify/node_modules/crypto-browserify\")},{\"./helpers\":4,buffer:3,lYpoI2:11}],10:[function(e,t,f){!function(e,t,n,r,o,i,u,s,a){f.read=function(e,t,n,r,o){var i,u,l=8*o-r-1,c=(1<<l)-1,d=c>>1,s=-7,a=n?o-1:0,f=n?-1:1,o=e[t+a];for(a+=f,i=o&(1<<-s)-1,o>>=-s,s+=l;0<s;i=256*i+e[t+a],a+=f,s-=8);for(u=i&(1<<-s)-1,i>>=-s,s+=r;0<s;u=256*u+e[t+a],a+=f,s-=8);if(0===i)i=1-d;else{if(i===c)return u?NaN:1/0*(o?-1:1);u+=Math.pow(2,r),i-=d}return(o?-1:1)*u*Math.pow(2,i-r)},f.write=function(e,t,l,n,r,c){var o,i,u=8*c-r-1,s=(1<<u)-1,a=s>>1,d=23===r?Math.pow(2,-24)-Math.pow(2,-77):0,f=n?0:c-1,h=n?1:-1,c=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(i=isNaN(t)?1:0,o=s):(o=Math.floor(Math.log(t)/Math.LN2),t*(n=Math.pow(2,-o))<1&&(o--,n*=2),2<=(t+=1<=o+a?d/n:d*Math.pow(2,1-a))*n&&(o++,n/=2),s<=o+a?(i=0,o=s):1<=o+a?(i=(t*n-1)*Math.pow(2,r),o+=a):(i=t*Math.pow(2,a-1)*Math.pow(2,r),o=0));8<=r;e[l+f]=255&i,f+=h,i/=256,r-=8);for(o=o<<r|i,u+=r;0<u;e[l+f]=255&o,f+=h,o/=256,u-=8);e[l+f-h]|=128*c}}.call(this,e(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},e(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/ieee754/index.js\",\"/node_modules/gulp-browserify/node_modules/ieee754\")},{buffer:3,lYpoI2:11}],11:[function(e,h,t){!function(e,t,n,r,o,f,l,c,d){var i,u,s;function a(){}(e=h.exports={}).nextTick=(u=\"undefined\"!=typeof window&&window.setImmediate,s=\"undefined\"!=typeof window&&window.postMessage&&window.addEventListener,u?function(e){return window.setImmediate(e)}:s?(i=[],window.addEventListener(\"message\",function(e){var t=e.source;t!==window&&null!==t||\"process-tick\"!==e.data||(e.stopPropagation(),0<i.length&&i.shift()())},!0),function(e){i.push(e),window.postMessage(\"process-tick\",\"*\")}):function(e){setTimeout(e,0)}),e.title=\"browser\",e.browser=!0,e.env={},e.argv=[],e.on=a,e.addListener=a,e.once=a,e.off=a,e.removeListener=a,e.removeAllListeners=a,e.emit=a,e.binding=function(e){throw new Error(\"process.binding is not supported\")},e.cwd=function(){return\"/\"},e.chdir=function(e){throw new Error(\"process.chdir is not supported\")}}.call(this,e(\"lYpoI2\"),\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:{},e(\"buffer\").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],\"/node_modules/gulp-browserify/node_modules/process/browser.js\",\"/node_modules/gulp-browserify/node_modules/process\")},{buffer:3,lYpoI2:11}]},{},[1])(1)});","'use strict';\n\n(function () {\n  var out$ = typeof exports != 'undefined' && exports || typeof define != 'undefined' && {} || this || window;\n  if (typeof define !== 'undefined') define('save-svg-as-png', [], function () {\n    return out$;\n  });\n  out$.default = out$;\n\n  var xmlNs = 'http://www.w3.org/2000/xmlns/';\n  var xhtmlNs = 'http://www.w3.org/1999/xhtml';\n  var svgNs = 'http://www.w3.org/2000/svg';\n  var doctype = '<?xml version=\"1.0\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\" [<!ENTITY nbsp \"&#160;\">]>';\n  var urlRegex = /url\\([\"']?(.+?)[\"']?\\)/;\n  var fontFormats = {\n    woff2: 'font/woff2',\n    woff: 'font/woff',\n    otf: 'application/x-font-opentype',\n    ttf: 'application/x-font-ttf',\n    eot: 'application/vnd.ms-fontobject',\n    sfnt: 'application/font-sfnt',\n    svg: 'image/svg+xml'\n  };\n\n  var isElement = function isElement(obj) {\n    return obj instanceof HTMLElement || obj instanceof SVGElement;\n  };\n  var requireDomNode = function requireDomNode(el) {\n    if (!isElement(el)) throw new Error('an HTMLElement or SVGElement is required; got ' + el);\n  };\n  var requireDomNodePromise = function requireDomNodePromise(el) {\n    return new Promise(function (resolve, reject) {\n      if (isElement(el)) resolve(el);else reject(new Error('an HTMLElement or SVGElement is required; got ' + el));\n    });\n  };\n  var isExternal = function isExternal(url) {\n    return url && url.lastIndexOf('http', 0) === 0 && url.lastIndexOf(window.location.host) === -1;\n  };\n\n  var getFontMimeTypeFromUrl = function getFontMimeTypeFromUrl(fontUrl) {\n    var formats = Object.keys(fontFormats).filter(function (extension) {\n      return fontUrl.indexOf('.' + extension) > 0;\n    }).map(function (extension) {\n      return fontFormats[extension];\n    });\n    if (formats) return formats[0];\n    console.error('Unknown font format for ' + fontUrl + '. Fonts may not be working correctly.');\n    return 'application/octet-stream';\n  };\n\n  var arrayBufferToBase64 = function arrayBufferToBase64(buffer) {\n    var binary = '';\n    var bytes = new Uint8Array(buffer);\n    for (var i = 0; i < bytes.byteLength; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }return window.btoa(binary);\n  };\n\n  var getDimension = function getDimension(el, clone, dim) {\n    var v = el.viewBox && el.viewBox.baseVal && el.viewBox.baseVal[dim] || clone.getAttribute(dim) !== null && !clone.getAttribute(dim).match(/%$/) && parseInt(clone.getAttribute(dim)) || el.getBoundingClientRect()[dim] || parseInt(clone.style[dim]) || parseInt(window.getComputedStyle(el).getPropertyValue(dim));\n    return typeof v === 'undefined' || v === null || isNaN(parseFloat(v)) ? 0 : v;\n  };\n\n  var getDimensions = function getDimensions(el, clone, width, height) {\n    if (el.tagName === 'svg') return {\n      width: width || getDimension(el, clone, 'width'),\n      height: height || getDimension(el, clone, 'height')\n    };else if (el.getBBox) {\n      var _el$getBBox = el.getBBox(),\n          x = _el$getBBox.x,\n          y = _el$getBBox.y,\n          _width = _el$getBBox.width,\n          _height = _el$getBBox.height;\n\n      return {\n        width: x + _width,\n        height: y + _height\n      };\n    }\n  };\n\n  var reEncode = function reEncode(data) {\n    return decodeURIComponent(encodeURIComponent(data).replace(/%([0-9A-F]{2})/g, function (match, p1) {\n      var c = String.fromCharCode('0x' + p1);\n      return c === '%' ? '%25' : c;\n    }));\n  };\n\n  var uriToBlob = function uriToBlob(uri) {\n    var byteString = window.atob(uri.split(',')[1]);\n    var mimeString = uri.split(',')[0].split(':')[1].split(';')[0];\n    var buffer = new ArrayBuffer(byteString.length);\n    var intArray = new Uint8Array(buffer);\n    for (var i = 0; i < byteString.length; i++) {\n      intArray[i] = byteString.charCodeAt(i);\n    }\n    return new Blob([buffer], { type: mimeString });\n  };\n\n  var query = function query(el, selector) {\n    if (!selector) return;\n    try {\n      return el.querySelector(selector) || el.parentNode && el.parentNode.querySelector(selector);\n    } catch (err) {\n      console.warn('Invalid CSS selector \"' + selector + '\"', err);\n    }\n  };\n\n  var detectCssFont = function detectCssFont(rule, href) {\n    // Match CSS font-face rules to external links.\n    // @font-face {\n    //   src: local('Abel'), url(https://fonts.gstatic.com/s/abel/v6/UzN-iejR1VoXU2Oc-7LsbvesZW2xOQ-xsNqO47m55DA.woff2);\n    // }\n    var match = rule.cssText.match(urlRegex);\n    var url = match && match[1] || '';\n    if (!url || url.match(/^data:/) || url === 'about:blank') return;\n    var fullUrl = url.startsWith('../') ? href + '/../' + url : url.startsWith('./') ? href + '/.' + url : url;\n    return {\n      text: rule.cssText,\n      format: getFontMimeTypeFromUrl(fullUrl),\n      url: fullUrl\n    };\n  };\n\n  var inlineImages = function inlineImages(el) {\n    return Promise.all(Array.from(el.querySelectorAll('image')).map(function (image) {\n      var href = image.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || image.getAttribute('href');\n      if (!href) return Promise.resolve(null);\n      if (isExternal(href)) {\n        href += (href.indexOf('?') === -1 ? '?' : '&') + 't=' + new Date().valueOf();\n      }\n      return new Promise(function (resolve, reject) {\n        var canvas = document.createElement('canvas');\n        var img = new Image();\n        img.crossOrigin = 'anonymous';\n        img.src = href;\n        img.onerror = function () {\n          return reject(new Error('Could not load ' + href));\n        };\n        img.onload = function () {\n          canvas.width = img.width;\n          canvas.height = img.height;\n          canvas.getContext('2d').drawImage(img, 0, 0);\n          image.setAttributeNS('http://www.w3.org/1999/xlink', 'href', canvas.toDataURL('image/png'));\n          resolve(true);\n        };\n      });\n    }));\n  };\n\n  var cachedFonts = {};\n  var inlineFonts = function inlineFonts(fonts) {\n    return Promise.all(fonts.map(function (font) {\n      return new Promise(function (resolve, reject) {\n        if (cachedFonts[font.url]) return resolve(cachedFonts[font.url]);\n\n        var req = new XMLHttpRequest();\n        req.addEventListener('load', function () {\n          // TODO: it may also be worth it to wait until fonts are fully loaded before\n          // attempting to rasterize them. (e.g. use https://developer.mozilla.org/en-US/docs/Web/API/FontFaceSet)\n          var fontInBase64 = arrayBufferToBase64(req.response);\n          var fontUri = font.text.replace(urlRegex, 'url(\"data:' + font.format + ';base64,' + fontInBase64 + '\")') + '\\n';\n          cachedFonts[font.url] = fontUri;\n          resolve(fontUri);\n        });\n        req.addEventListener('error', function (e) {\n          console.warn('Failed to load font from: ' + font.url, e);\n          cachedFonts[font.url] = null;\n          resolve(null);\n        });\n        req.addEventListener('abort', function (e) {\n          console.warn('Aborted loading font from: ' + font.url, e);\n          resolve(null);\n        });\n        req.open('GET', font.url);\n        req.responseType = 'arraybuffer';\n        req.send();\n      });\n    })).then(function (fontCss) {\n      return fontCss.filter(function (x) {\n        return x;\n      }).join('');\n    });\n  };\n\n  var cachedRules = null;\n  var styleSheetRules = function styleSheetRules() {\n    if (cachedRules) return cachedRules;\n    return cachedRules = Array.from(document.styleSheets).map(function (sheet) {\n      try {\n        return { rules: sheet.cssRules, href: sheet.href };\n      } catch (e) {\n        console.warn('Stylesheet could not be loaded: ' + sheet.href, e);\n        return {};\n      }\n    });\n  };\n\n  var inlineCss = function inlineCss(el, options) {\n    var _ref = options || {},\n        selectorRemap = _ref.selectorRemap,\n        modifyStyle = _ref.modifyStyle,\n        modifyCss = _ref.modifyCss,\n        fonts = _ref.fonts,\n        excludeUnusedCss = _ref.excludeUnusedCss;\n\n    var generateCss = modifyCss || function (selector, properties) {\n      var sel = selectorRemap ? selectorRemap(selector) : selector;\n      var props = modifyStyle ? modifyStyle(properties) : properties;\n      return sel + '{' + props + '}\\n';\n    };\n    var css = [];\n    var detectFonts = typeof fonts === 'undefined';\n    var fontList = fonts || [];\n    styleSheetRules().forEach(function (_ref2) {\n      var rules = _ref2.rules,\n          href = _ref2.href;\n\n      if (!rules) return;\n      Array.from(rules).forEach(function (rule) {\n        if (typeof rule.style != 'undefined') {\n          if (query(el, rule.selectorText)) css.push(generateCss(rule.selectorText, rule.style.cssText));else if (detectFonts && rule.cssText.match(/^@font-face/)) {\n            var font = detectCssFont(rule, href);\n            if (font) fontList.push(font);\n          } else if (!excludeUnusedCss) {\n            css.push(rule.cssText);\n          }\n        }\n      });\n    });\n\n    return inlineFonts(fontList).then(function (fontCss) {\n      return css.join('\\n') + fontCss;\n    });\n  };\n\n  var downloadOptions = function downloadOptions() {\n    if (!navigator.msSaveOrOpenBlob && !('download' in document.createElement('a'))) {\n      return { popup: window.open() };\n    }\n  };\n\n  out$.prepareSvg = function (el, options, done) {\n    requireDomNode(el);\n\n    var _ref3 = options || {},\n        _ref3$left = _ref3.left,\n        left = _ref3$left === undefined ? 0 : _ref3$left,\n        _ref3$top = _ref3.top,\n        top = _ref3$top === undefined ? 0 : _ref3$top,\n        w = _ref3.width,\n        h = _ref3.height,\n        _ref3$scale = _ref3.scale,\n        scale = _ref3$scale === undefined ? 1 : _ref3$scale,\n        _ref3$responsive = _ref3.responsive,\n        responsive = _ref3$responsive === undefined ? false : _ref3$responsive,\n        _ref3$excludeCss = _ref3.excludeCss,\n        excludeCss = _ref3$excludeCss === undefined ? false : _ref3$excludeCss;\n\n    return inlineImages(el).then(function () {\n      var clone = el.cloneNode(true);\n      clone.style.backgroundColor = (options || {}).backgroundColor || el.style.backgroundColor;\n\n      var _getDimensions = getDimensions(el, clone, w, h),\n          width = _getDimensions.width,\n          height = _getDimensions.height;\n\n      if (el.tagName !== 'svg') {\n        if (el.getBBox) {\n          if (clone.getAttribute('transform') != null) {\n            clone.setAttribute('transform', clone.getAttribute('transform').replace(/translate\\(.*?\\)/, ''));\n          }\n          var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n          svg.appendChild(clone);\n          clone = svg;\n        } else {\n          console.error('Attempted to render non-SVG element', el);\n          return;\n        }\n      }\n\n      clone.setAttribute('version', '1.1');\n      clone.setAttribute('viewBox', [left, top, width, height].join(' '));\n      if (!clone.getAttribute('xmlns')) clone.setAttributeNS(xmlNs, 'xmlns', svgNs);\n      if (!clone.getAttribute('xmlns:xlink')) clone.setAttributeNS(xmlNs, 'xmlns:xlink', 'http://www.w3.org/1999/xlink');\n\n      if (responsive) {\n        clone.removeAttribute('width');\n        clone.removeAttribute('height');\n        clone.setAttribute('preserveAspectRatio', 'xMinYMin meet');\n      } else {\n        clone.setAttribute('width', width * scale);\n        clone.setAttribute('height', height * scale);\n      }\n\n      Array.from(clone.querySelectorAll('foreignObject > *')).forEach(function (foreignObject) {\n        foreignObject.setAttributeNS(xmlNs, 'xmlns', foreignObject.tagName === 'svg' ? svgNs : xhtmlNs);\n      });\n\n      if (excludeCss) {\n        var outer = document.createElement('div');\n        outer.appendChild(clone);\n        var src = outer.innerHTML;\n        if (typeof done === 'function') done(src, width, height);else return { src: src, width: width, height: height };\n      } else {\n        return inlineCss(el, options).then(function (css) {\n          var style = document.createElement('style');\n          style.setAttribute('type', 'text/css');\n          style.innerHTML = '<![CDATA[\\n' + css + '\\n]]>';\n\n          var defs = document.createElement('defs');\n          defs.appendChild(style);\n          clone.insertBefore(defs, clone.firstChild);\n\n          var outer = document.createElement('div');\n          outer.appendChild(clone);\n          var src = outer.innerHTML.replace(/NS\\d+:href/gi, 'xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href');\n\n          if (typeof done === 'function') done(src, width, height);else return { src: src, width: width, height: height };\n        });\n      }\n    });\n  };\n\n  out$.svgAsDataUri = function (el, options, done) {\n    requireDomNode(el);\n    return out$.prepareSvg(el, options).then(function (_ref4) {\n      var src = _ref4.src,\n          width = _ref4.width,\n          height = _ref4.height;\n\n      var svgXml = 'data:image/svg+xml;base64,' + window.btoa(reEncode(doctype + src));\n      if (typeof done === 'function') {\n        done(svgXml, width, height);\n      }\n      return svgXml;\n    });\n  };\n\n  out$.svgAsPngUri = function (el, options, done) {\n    requireDomNode(el);\n\n    var _ref5 = options || {},\n        _ref5$encoderType = _ref5.encoderType,\n        encoderType = _ref5$encoderType === undefined ? 'image/png' : _ref5$encoderType,\n        _ref5$encoderOptions = _ref5.encoderOptions,\n        encoderOptions = _ref5$encoderOptions === undefined ? 0.8 : _ref5$encoderOptions,\n        canvg = _ref5.canvg;\n\n    var convertToPng = function convertToPng(_ref6) {\n      var src = _ref6.src,\n          width = _ref6.width,\n          height = _ref6.height;\n\n      var canvas = document.createElement('canvas');\n      var context = canvas.getContext('2d');\n      var pixelRatio = window.devicePixelRatio || 1;\n\n      canvas.width = width * pixelRatio;\n      canvas.height = height * pixelRatio;\n      canvas.style.width = canvas.width + 'px';\n      canvas.style.height = canvas.height + 'px';\n      context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n\n      if (canvg) canvg(canvas, src);else context.drawImage(src, 0, 0);\n\n      var png = void 0;\n      try {\n        png = canvas.toDataURL(encoderType, encoderOptions);\n      } catch (e) {\n        if (typeof SecurityError !== 'undefined' && e instanceof SecurityError || e.name === 'SecurityError') {\n          console.error('Rendered SVG images cannot be downloaded in this browser.');\n          return;\n        } else throw e;\n      }\n      if (typeof done === 'function') done(png, canvas.width, canvas.height);\n      return Promise.resolve(png);\n    };\n\n    if (canvg) return out$.prepareSvg(el, options).then(convertToPng);else return out$.svgAsDataUri(el, options).then(function (uri) {\n      return new Promise(function (resolve, reject) {\n        var image = new Image();\n        image.onload = function () {\n          return resolve(convertToPng({\n            src: image,\n            width: image.width,\n            height: image.height\n          }));\n        };\n        image.onerror = function () {\n          reject('There was an error loading the data URI as an image on the following SVG\\n' + window.atob(uri.slice(26)) + 'Open the following link to see browser\\'s diagnosis\\n' + uri);\n        };\n        image.src = uri;\n      });\n    });\n  };\n\n  out$.download = function (name, uri, options) {\n    if (navigator.msSaveOrOpenBlob) navigator.msSaveOrOpenBlob(uriToBlob(uri), name);else {\n      var saveLink = document.createElement('a');\n      if ('download' in saveLink) {\n        saveLink.download = name;\n        saveLink.style.display = 'none';\n        document.body.appendChild(saveLink);\n        try {\n          var blob = uriToBlob(uri);\n          var url = URL.createObjectURL(blob);\n          saveLink.href = url;\n          saveLink.onclick = function () {\n            return requestAnimationFrame(function () {\n              return URL.revokeObjectURL(url);\n            });\n          };\n        } catch (e) {\n          console.error(e);\n          console.warn('Error while getting object URL. Falling back to string URL.');\n          saveLink.href = uri;\n        }\n        saveLink.click();\n        document.body.removeChild(saveLink);\n      } else if (options && options.popup) {\n        options.popup.document.title = name;\n        options.popup.location.replace(uri);\n      }\n    }\n  };\n\n  out$.saveSvg = function (el, name, options) {\n    var downloadOpts = downloadOptions(); // don't inline, can't be async\n    return requireDomNodePromise(el).then(function (el) {\n      return out$.svgAsDataUri(el, options || {});\n    }).then(function (uri) {\n      return out$.download(name, uri, downloadOpts);\n    });\n  };\n\n  out$.saveSvgAsPng = function (el, name, options) {\n    var downloadOpts = downloadOptions(); // don't inline, can't be async\n    return requireDomNodePromise(el).then(function (el) {\n      return out$.svgAsPngUri(el, options || {});\n    }).then(function (uri) {\n      return out$.download(name, uri, downloadOpts);\n    });\n  };\n})();","\"use strict\";\n\nvar stylesInDOM = [];\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n  return result;\n}\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n    identifiers.push(identifier);\n  }\n  return identifiers;\n}\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n  return updater;\n}\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n    var newLastIdentifiers = modulesToDom(newList, options);\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n      var _index = getIndexByIdentifier(_identifier);\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n\n/* istanbul ignore next  */\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target);\n\n    // Special case to return head of iframe instead of iframe itself\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n    memo[target] = styleTarget;\n  }\n  return memo[target];\n}\n\n/* istanbul ignore next  */\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n  target.appendChild(style);\n}\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n  var needLayer = typeof obj.layer !== \"undefined\";\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n  css += obj.css;\n  if (needLayer) {\n    css += \"}\";\n  }\n  if (obj.media) {\n    css += \"}\";\n  }\n  if (obj.supports) {\n    css += \"}\";\n  }\n  var sourceMap = obj.sourceMap;\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  }\n\n  // For old IE\n  /* istanbul ignore if  */\n  options.styleTagTransform(css, styleElement, options.options);\n}\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n  styleElement.parentNode.removeChild(styleElement);\n}\n\n/* istanbul ignore next  */\nfunction domAPI(options) {\n  if (typeof document === \"undefined\") {\n    return {\n      update: function update() {},\n      remove: function remove() {}\n    };\n  }\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\nmodule.exports = styleTagTransform;","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nexport const NUCLEOTIDES = ['A', 'G', 'C', 'U'];\n\nexport const TECHNOLOGIES = {\n  DNA: 'DNA',\n  RNA: 'RNA',\n  ASO_GAPMERS: 'ASOGapmers',\n  SI_RNA: 'siRNA',\n};\n\nexport enum DEFAULT_FORMATS {\n  HELM = 'HELM',\n  AXOLABS = 'Axolabs',\n}\n","export const LIB_PATH = 'System:AppData/SequenceTranslator';\nexport const DEFAULT_LIB_FILENAME = 'monomer-lib.json';\n\nexport const APP_PATH = 'System:AppData/SequenceTranslator';\nexport const PATTERN_APP_DATA_FILENAME = 'pattern-app-data.json';\nexport const CODES_TO_HELM_DICT_FILENAME = 'formats-to-helm.json';\nexport const CODES_TO_SYMBOLS_FILENAME = 'codes-to-symbols.json';\nexport const MONOMERS_WITH_PHOSPHATE_FILENAME = 'linkers.json';\n\nexport const enum MODIFICATION_DATA_FIELDS {\n  COLOR = 'color',\n  SUBSTITUTION = 'substitution',\n}\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as DG from 'datagrok-api/dg';\n\nimport {\n  APP_PATH, PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME,\n  CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_FILENAME\n} from './const';\nimport {PatternAppData, CodeToSymbol, FormatToHELMDict} from './types';\n\nconst fileSource = new DG.FileSource(APP_PATH);\n\nexport let PATTERN_APP_DATA: PatternAppData;\nexport let CODES_TO_HELM_DICT: FormatToHELMDict;\nexport let CODES_TO_SYMBOLS_DICT: CodeToSymbol;\nexport let MONOMERS_WITH_PHOSPHATE: {[key: string]: string[]};\n\nexport async function loadJsonData(): Promise<void> {\n  if (isAllJsonDataLoaded())\n    return;\n\n  const jsonFileNames = [\n    PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME, CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_FILENAME\n  ];\n\n  [\n    PATTERN_APP_DATA,\n    CODES_TO_HELM_DICT,\n    CODES_TO_SYMBOLS_DICT,\n    MONOMERS_WITH_PHOSPHATE\n  ] = await Promise.all(\n    jsonFileNames.map((fileName) => loadAndParseJson(fileName))\n  );\n}\n\nasync function loadAndParseJson(filePath: string): Promise<any> {\n  try {\n    const content = await fileSource.readAsText(filePath);\n    return JSON.parse(content);\n  } catch (err) {\n    console.error(`Error loading json from ${filePath}:`, err);\n  }\n}\n\nfunction isAllJsonDataLoaded(): boolean {\n  const data = [PATTERN_APP_DATA, CODES_TO_HELM_DICT, CODES_TO_SYMBOLS_DICT, MONOMERS_WITH_PHOSPHATE];\n\n  return data.every((item) => item !== undefined);\n}\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nexport function sortByReverseLength(array: string[]): string[] {\n  return array.sort((a, b) => b.length - a.length);\n}\n\nexport function download(name: string, href: string): void {\n  const element = document.createElement('a');\n  element.setAttribute('href', 'data:text/plain;charset=utf-8,' + href);\n  element.setAttribute('download', name);\n  element.click();\n}\n\nexport async function tryCatch<T>(func: () => Promise<T>, finallyFunc?: () => any, callbackName: string = 'Oligo app'): Promise<T> {\n  try {\n    return await func();\n  } catch (err: any) {\n    const errMsg: string = err.hasOwnProperty('message') ? err.message : err.toString();\n    grok.shell.error(`${callbackName} error: ` + errMsg);\n    throw err;\n  } finally {\n    if (finallyFunc)\n      finallyFunc();\n  }\n};\n\n","import * as DG from 'datagrok-api/dg';\n\nimport {_package} from '../../../../package';\nimport {DEFAULT_FORMATS} from '../const';\n\nimport {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';\nimport {HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT} from '@datagrok-libraries/bio/src/utils/const';\n\nimport {META_FIELDS as MET} from './const';\nimport {CODES_TO_SYMBOLS_DICT} from '../data-loader/json-loader';\n\nexport class MonomerLibWrapper {\n  private constructor() {\n    const lib = _package.monomerLib;\n    if (lib === null)\n      throw new Error('SequenceTranslator: monomer library is null');\n    this.lib = lib!;\n    this.allMonomers = this.getAllMonomers();\n  }\n\n  private lib: IMonomerLib;\n  private static instance?: MonomerLibWrapper;\n  private allMonomers: Monomer[];\n\n  private formatMonomerForViewer(sourceObj: Monomer): {[key: string]: string} {\n    const formattedObject: {[key: string]: string} = {};\n    formattedObject[REQ.NAME] = sourceObj[REQ.SYMBOL];\n    formattedObject[REQ.SYMBOL] = sourceObj[REQ.SYMBOL];\n    formattedObject[REQ.MOLFILE] = sourceObj[REQ.MOLFILE];\n    const formats = this.getAllFormats();\n    formats.forEach((format) => {\n      if (format === DEFAULT_FORMATS.HELM)\n        return;\n      const map = CODES_TO_SYMBOLS_DICT[format];\n      const codes = Object.keys(map).filter((code) => map[code] === sourceObj.symbol);\n      formattedObject[format] = codes.join(', ');\n    });\n\n    return formattedObject;\n  }\n\n  private getAllMonomers(): Monomer[] {\n    const polymerTypes = this.lib.getPolymerTypes();\n    let result: Monomer[] = [];\n    for (const polymerType of polymerTypes) {\n      const monomerSymbols = this.lib.getMonomerSymbolsByType(polymerType);\n      const monomersByType: Monomer[] = monomerSymbols\n        .map((monomerSymbol) => this.lib.getMonomer(polymerType, monomerSymbol))\n        .filter((monomer): monomer is Monomer => monomer !== null);\n      result = result.concat(monomersByType);\n    }\n    return result;\n  }\n\n  private getMonomer(monomerSymbol: string): Monomer {\n    const monomer = this.lib.getMonomer('RNA', monomerSymbol);\n    if (monomer === undefined)\n      throw new Error(`SequenceTranslator: no monomer with symbol ${monomerSymbol}`);\n    return monomer!;\n  }\n\n  static getInstance(): MonomerLibWrapper {\n    if (MonomerLibWrapper.instance === undefined)\n      MonomerLibWrapper.instance = new MonomerLibWrapper();\n    return MonomerLibWrapper.instance!;\n  }\n\n  getMolfileBySymbol(monomerSymbol: string): string {\n    const monomer = this.getMonomer(monomerSymbol);\n    return monomer.molfile;\n  }\n\n  getNaturalAnalogBySymbol(monomerSymbol: string): string {\n    const monomer = this.getMonomer(monomerSymbol);\n    const naturalAnalog = monomer.naturalAnalog;\n    if (!naturalAnalog)\n      throw new Error(`ST: no natural analog for ${monomerSymbol}`);\n    return naturalAnalog!;\n  }\n\n  // todo: a better criterion\n  isModification(monomerSymbol: string): boolean {\n    const molfile = this.getMolfileBySymbol(monomerSymbol);\n    return (molfile.includes('MODIFICATION')) ? true : false;\n  }\n\n  getCodeToSymbolMap(format: string): Map<string, string> {\n    return new Map<string, string>(Object.entries(CODES_TO_SYMBOLS_DICT[format]));\n  }\n\n  getCodesByFormat(format: string): string[] {\n    return Object.keys(CODES_TO_SYMBOLS_DICT[format]);\n  }\n\n  getAllFormats(): string[] {\n    return Object.keys(CODES_TO_SYMBOLS_DICT);\n  }\n\n  getTableForViewer(): DG.DataFrame {\n    const formattedObjects = this.allMonomers.map((monomer) => this.formatMonomerForViewer(monomer));\n    const df = DG.DataFrame.fromObjects(formattedObjects)!;\n    return df;\n  }\n\n  getCodesToWeightsMap(): Map<string, number> {\n    const codesToWeightsMap = new Map<string, number>();\n    Object.entries(CODES_TO_SYMBOLS_DICT).forEach(([_, dict]) => {\n      Object.entries(dict).forEach(([code, monomerSymbol]) => {\n        const monomer = this.getMonomer(monomerSymbol);\n        const weight = monomer[OPT.META]?.[MET.MOLWEIGHT];\n        codesToWeightsMap.set(code, weight);\n      });\n    });\n    return codesToWeightsMap;\n  }\n}\n","import {NUCLEOTIDES} from '../const';\nimport {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';\nimport {sortByReverseLength} from '../helpers';\nimport {DEFAULT_FORMATS} from '../const';\n\nexport class SequenceValidator {\n  constructor(private sequence: string) {\n    this.libWrapper = MonomerLibWrapper.getInstance();\n  };\n  private libWrapper: MonomerLibWrapper;\n\n  getInvalidCodeIndex(format: string): number {\n    if (format === DEFAULT_FORMATS.HELM)\n      return this.sequence.length;\n    const firstUniqueCharacters = ['r', 'd']; // what for?\n    const codes = sortByReverseLength(\n      this.libWrapper.getCodesByFormat(format)\n    );\n    let indexOfFirstInvalidChar = 0;\n    while (indexOfFirstInvalidChar < this.sequence.length) {\n      const matchedCode = codes.find((code) => {\n        const subSequence = this.sequence.substring(indexOfFirstInvalidChar, indexOfFirstInvalidChar + code.length);\n        return code === subSequence;\n      });\n\n      if (!matchedCode) break;\n\n      // todo: refactor the vague condition\n      if ( // for mistake pattern 'rAA'\n        indexOfFirstInvalidChar > 1 &&\n        NUCLEOTIDES.includes(this.sequence[indexOfFirstInvalidChar]) &&\n        firstUniqueCharacters.includes(this.sequence[indexOfFirstInvalidChar - 2])\n      ) break;\n\n      if ( // for mistake pattern 'ArA'\n        firstUniqueCharacters.includes(this.sequence[indexOfFirstInvalidChar + 1]) &&\n        NUCLEOTIDES.includes(this.sequence[indexOfFirstInvalidChar])\n      ) {\n        indexOfFirstInvalidChar++;\n        break;\n      }\n      indexOfFirstInvalidChar += matchedCode.length;\n    }\n    if (indexOfFirstInvalidChar === this.sequence.length)\n      indexOfFirstInvalidChar = -1;\n    return indexOfFirstInvalidChar;\n  }\n\n  isValidSequence(format: string): boolean {\n    return this.getInvalidCodeIndex(format) === -1;\n  }\n}\n","export function getNucleotidesMol(codes: string[]) {\n  const molBlocks: string[] = [];\n\n  for (let i = 0; i < codes.length - 1; i++) {\n    if (codes[i].includes('MODIFICATION')) {\n      if (i === 0)\n        molBlocks.push(reflect(codes[i]));\n      else\n        molBlocks.push(codes[i]);\n    } else {\n      molBlocks.push(rotateNucleotidesV3000(codes[i]));\n    }\n  }\n\n  return linkV3000(molBlocks);\n}\n\nexport function linkStrandsV3000(\n  strands: { senseStrands: string[], antiStrands: string[] }, useChirality: boolean = true\n): string {\n  let macroMolBlock = '\\n  Datagrok macromolecule handler\\n\\n';\n  macroMolBlock += '  0  0  0  0  0  0            999 V3000\\n';\n  macroMolBlock += 'M  V30 BEGIN CTAB\\n';\n  let atomBlock = '';\n  let bondBlock = '';\n  let collectionBlock = '';\n  const collection: number [] = [];\n  let natom = 0;\n  let nbond = 0;\n  let xShift = 0;\n\n  if (strands.antiStrands.length > 0) {\n    for (let i = 0; i < strands.antiStrands.length; i++)\n      strands.antiStrands[i] = invertNucleotidesV3000(strands.antiStrands[i]);\n  }\n\n  let inverted = false;\n  const molBlocks = strands.senseStrands.concat(strands.antiStrands);\n  /** Minimal value of ANTISENSE_STRAND and AS2 shift  */\n  let ssYShift = 0;\n\n  for (let i = 0; i < molBlocks.length; i++) {\n    molBlocks[i] = molBlocks[i].replaceAll('(-\\nM  V30 ', '(')\n      .replaceAll('-\\nM  V30 ', '').replaceAll(' )', ')');\n    const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);\n    const coordinates = extractAtomDataV3000(molBlocks[i]);\n\n    if (i >= strands.senseStrands.length) {\n      if (inverted === false) {\n        // ANTISENSE_STRAND strand\n        inverted = true;\n        xShift = 0;\n      }\n    } else {\n      // SENSE_STRAND strands\n      ssYShift = Math.min(ssYShift, Math.min(\n        ...coordinates.y.filter((item) => item < 0)\n      ));\n    }\n\n    if (inverted) {\n      const xShiftRight = Math.min(...coordinates.x) - xShift;\n      const yShift = Math.max(...coordinates.y) + 5;\n      for (let j = 0; j < coordinates.x.length; j++)\n        coordinates.x[j] -= xShiftRight;\n      for (let j = 0; j < coordinates.y.length; j++)\n        coordinates.y[j] -= yShift - ssYShift;\n    }\n\n    let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n    indexAtoms = molBlocks[i].indexOf('\\n', indexAtoms);\n    let index = indexAtoms;\n    let indexEnd = indexAtoms;\n\n    for (let j = 0; j < numbers.natom; j++) {\n      // if (coordinates.atomIndex[j] !== 1 || i === 0 || twoChains) {\n      //rewrite atom number\n      index = molBlocks[i].indexOf('V30', index) + 4;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      const atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n\n      //rewrite coordinates\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n\n      const totalShift = true ? 0 : xShift - coordinates.x[0];\n      let coordinate = true ?\n        Math.round(10000 * coordinates.x[j]) / 10000 :\n        Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift)) / 10000;\n      molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);\n\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      coordinate = true ?\n        Math.round(10000 * coordinates.y[j]) / 10000 :\n        Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)))) / 10000;\n      molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);\n\n      index = molBlocks[i].indexOf('\\n', index) + 1;\n    }\n\n    const indexAtomsEnd = molBlocks[i].indexOf('M  V30 END ATOM');\n    atomBlock += molBlocks[i].substring(indexAtoms + 1, indexAtomsEnd);\n\n    let indexBonds = molBlocks[i].indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds\n    indexBonds = molBlocks[i].indexOf('\\n', indexBonds);\n    index = indexBonds;\n    indexEnd = indexBonds;\n\n    for (let j = 0; j < numbers.nbond; j++) {\n      //rewrite bond number\n      index = molBlocks[i].indexOf('V30', index) + 4;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      const bondNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + nbond;\n      molBlocks[i] = molBlocks[i].slice(0, index) + bondNumber + molBlocks[i].slice(indexEnd);\n\n      //rewrite atom pair in bond\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      let atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = Math.min(molBlocks[i].indexOf('\\n', index), molBlocks[i].indexOf(' ', index));\n      atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n\n      index = molBlocks[i].indexOf('\\n', index) + 1;\n    }\n\n    const indexBondEnd = molBlocks[i].indexOf('M  V30 END BOND');\n    bondBlock += molBlocks[i].substring(indexBonds + 1, indexBondEnd);\n\n    let indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=('); // V3000 index for collections\n\n    while (indexCollection !== -1) {\n      indexCollection += 28;\n      const collectionEnd = molBlocks[i].indexOf(')', indexCollection);\n      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);\n      collectionEntries.forEach((e) => {\n        collection.push(parseInt(e) + natom);\n      });\n      indexCollection = collectionEnd;\n      indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);\n    }\n\n    natom += true ? numbers.natom : numbers.natom - 1;\n    nbond += numbers.nbond;\n    xShift += Math.max(...coordinates.x) + 5;//twoChains ? 0 : coordinates.x[numbers.natom - 1] - coordinates.x[0];\n  }\n\n  const entries = 4;\n  const collNumber = Math.ceil(collection.length / entries);\n\n  collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\\n';\n  for (let i = 0; i < collNumber; i++) {\n    collectionBlock += 'M  V30 ';\n    const entriesCurrent = i + 1 === collNumber ? collection.length - (collNumber - 1) * entries : entries;\n    for (let j = 0; j < entriesCurrent; j++) {\n      collectionBlock += (j + 1 === entriesCurrent) ?\n        (i === collNumber - 1 ? collection[entries * i + j] + ')\\n' : collection[entries * i + j] + ' -\\n') :\n        collection[entries * i + j] + ' ';\n    }\n  }\n\n  //generate file\n  true ? natom : natom++;\n  macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\\n';\n  macroMolBlock += 'M  V30 BEGIN ATOM\\n';\n  macroMolBlock += atomBlock;\n  macroMolBlock += 'M  V30 END ATOM\\n';\n  macroMolBlock += 'M  V30 BEGIN BOND\\n';\n  macroMolBlock += bondBlock;\n  macroMolBlock += 'M  V30 END BOND\\n';\n  if (useChirality && collection.length > 0) {\n    macroMolBlock += 'M  V30 BEGIN COLLECTION\\n';\n    macroMolBlock += collectionBlock;\n    macroMolBlock += 'M  V30 END COLLECTION\\n';\n  } else {\n    macroMolBlock = macroMolBlock.replace(/ CFG=\\d/g, ' ');\n  }\n\n  macroMolBlock += 'M  V30 END CTAB\\n';\n  macroMolBlock += 'M  END';\n\n  return macroMolBlock;\n}\n\nexport function linkV3000(molBlocks: string[], useChirality: boolean = true): string {\n  let macroMolBlock = '\\n  Datagrok macromolecule handler\\n\\n';\n  macroMolBlock += '  0  0  0  0  0  0            999 V3000\\n';\n  macroMolBlock += 'M  V30 BEGIN CTAB\\n';\n  let atomBlock = '';\n  let bondBlock = '';\n  let collectionBlock = '';\n  const collection: number [] = [];\n  let natom = 0;\n  let nbond = 0;\n  let xShift = 0;\n\n  for (let i = 0; i < molBlocks.length; i++) {\n    const isBoundary = molBlocks[i].includes('MODIFICATION') && i === 0;\n    let specLength = 0;\n    if (isBoundary) {\n      const coordinates = extractAtomDataV3000(molBlocks[i]);\n      specLength = coordinates.atomIndex.length;\n    }\n\n\n    molBlocks[i] = molBlocks[i].replaceAll('(-\\nM  V30 ', '(')\n      .replaceAll('-\\nM  V30 ', '').replaceAll(' )', ')');\n    const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);\n    const coordinates = extractAtomDataV3000(molBlocks[i]);\n\n    let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n    indexAtoms = molBlocks[i].indexOf('\\n', indexAtoms);\n    let index = indexAtoms;\n    let indexEnd = indexAtoms;\n\n    for (let j = 0; j < numbers.natom; j++) {\n      if (coordinates.atomIndex[j] !== 1 || i === 0) {\n        //rewrite atom number\n        index = molBlocks[i].indexOf('V30', index) + 4;\n        indexEnd = molBlocks[i].indexOf(' ', index);\n        let atomNumber = 0;\n        if (isBoundary) {\n          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));\n          if (atomNumber === 1)\n            atomNumber = specLength;\n          else if (atomNumber === specLength)\n            atomNumber = 1;\n          atomNumber += natom;\n        } else {\n          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n        }\n        molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n\n        //rewrite coordinates\n        index = molBlocks[i].indexOf(' ', index) + 1;\n        index = molBlocks[i].indexOf(' ', index) + 1;\n        indexEnd = molBlocks[i].indexOf(' ', index);\n\n        const totalShift = xShift - coordinates.x[0];\n        let coordinate =\n          Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift)) / 10000;\n        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);\n\n        index = molBlocks[i].indexOf(' ', index) + 1;\n        indexEnd = molBlocks[i].indexOf(' ', index);\n        coordinate =\n          Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)))) / 10000;\n        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);\n\n        index = molBlocks[i].indexOf('\\n', index) + 1;\n      } else {\n        index = molBlocks[i].indexOf('M  V30', index) - 1;\n        indexEnd = molBlocks[i].indexOf('\\n', index + 1);\n        molBlocks[i] = molBlocks[i].slice(0, index) + molBlocks[i].slice(indexEnd);\n      }\n    }\n\n    const indexAtomsEnd = molBlocks[i].indexOf('M  V30 END ATOM');\n    atomBlock += molBlocks[i].substring(indexAtoms + 1, indexAtomsEnd);\n\n    let indexBonds = molBlocks[i].indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds\n    indexBonds = molBlocks[i].indexOf('\\n', indexBonds);\n    index = indexBonds;\n    indexEnd = indexBonds;\n\n    for (let j = 0; j < numbers.nbond; j++) {\n      //rewrite bond number\n      index = molBlocks[i].indexOf('V30', index) + 4;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      const bondNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + nbond;\n      molBlocks[i] = molBlocks[i].slice(0, index) + bondNumber + molBlocks[i].slice(indexEnd);\n\n      //rewrite atom pair in bond\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = molBlocks[i].indexOf(' ', index);\n      let atomNumber = 0;\n      if (isBoundary) {\n        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));\n        if (atomNumber === 1)\n          atomNumber = specLength;\n        else if (atomNumber === specLength)\n          atomNumber = 1;\n        atomNumber += natom;\n      } else {\n        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n      }\n\n      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n      index = molBlocks[i].indexOf(' ', index) + 1;\n      indexEnd = Math.min(molBlocks[i].indexOf('\\n', index), molBlocks[i].indexOf(' ', index));\n      atomNumber = 0;\n      if (isBoundary) {\n        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));\n        if (atomNumber === 1)\n          atomNumber = specLength;\n        else if (atomNumber === specLength)\n          atomNumber = 1;\n        atomNumber += natom;\n      } else {\n        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;\n      }\n      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);\n\n      index = molBlocks[i].indexOf('\\n', index) + 1;\n    }\n\n    const indexBondEnd = molBlocks[i].indexOf('M  V30 END BOND');\n    bondBlock += molBlocks[i].substring(indexBonds + 1, indexBondEnd);\n\n    let indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=('); // V3000 index for collections\n\n    while (indexCollection !== -1) {\n      indexCollection += 28;\n      const collectionEnd = molBlocks[i].indexOf(')', indexCollection);\n      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);\n      collectionEntries.forEach((e) => {\n        collection.push(parseInt(e) + natom);\n      });\n      indexCollection = collectionEnd;\n      indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);\n    }\n\n    natom += numbers.natom - 1;\n    nbond += numbers.nbond;\n    if (isBoundary)\n      xShift += Math.max(...coordinates.x);\n    else\n      xShift += coordinates.x[numbers.natom - 1] - coordinates.x[0];\n  }\n\n  const entries = 4;\n  const collNumber = Math.ceil(collection.length / entries);\n\n  collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\\n';\n  for (let i = 0; i < collNumber; i++) {\n    collectionBlock += 'M  V30 ';\n    const entriesCurrent = i + 1 === collNumber ? collection.length - (collNumber - 1) * entries : entries;\n    for (let j = 0; j < entriesCurrent; j++) {\n      collectionBlock += (j + 1 === entriesCurrent) ?\n        (i === collNumber - 1 ? collection[entries * i + j] + ')\\n' : collection[entries * i + j] + ' -\\n') :\n        collection[entries * i + j] + ' ';\n    }\n  }\n  //}\n\n  //generate file\n  natom++;\n  macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\\n';\n  macroMolBlock += 'M  V30 BEGIN ATOM\\n';\n  macroMolBlock += atomBlock;\n  macroMolBlock += 'M  V30 END ATOM\\n';\n  macroMolBlock += 'M  V30 BEGIN BOND\\n';\n  macroMolBlock += bondBlock;\n  macroMolBlock += 'M  V30 END BOND\\n';\n  if (useChirality && collection.length > 0) {\n    macroMolBlock += 'M  V30 BEGIN COLLECTION\\n';\n    macroMolBlock += collectionBlock;\n    macroMolBlock += 'M  V30 END COLLECTION\\n';\n  } else { macroMolBlock = macroMolBlock.replace(/ CFG=\\d/g, ' '); }\n\n  macroMolBlock += 'M  V30 END CTAB\\n';\n  macroMolBlock += 'M  END';\n\n  return macroMolBlock;\n}\n\nfunction rotateNucleotidesV3000(molBlock: string): string {\n  const coordinates = extractAtomDataV3000(molBlock);\n  const natom = coordinates.atomIndex.length;\n\n  const indexFivePrime = coordinates.atomIndex.indexOf(1);\n  const indexThreePrime = coordinates.atomIndex.indexOf(natom);\n\n  //fix 5 prime if inadequate\n  if (natom > 8)\n    fix5Prime(coordinates, indexFivePrime, indexThreePrime);\n\n  const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime]) / 2;\n  const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime]) / 2;\n\n  //place to center\n  for (let i = 0; i < natom; i++) {\n    coordinates.x[i] -= xCenter;\n    coordinates.y[i] -= yCenter;\n  }\n\n  let angle = 0;\n  if (coordinates.x[indexFivePrime] === 0) {\n    angle = coordinates.y[indexFivePrime] > coordinates.y[indexThreePrime] ? Math.PI / 2 : 3 * Math.PI / 2;\n  } else if (coordinates.y[indexFivePrime] === 0) {\n    angle = coordinates.x[indexFivePrime] > coordinates.x[indexThreePrime] ? Math.PI : 0;\n  } else {\n    const derivative = coordinates.y[indexFivePrime] / coordinates.x[indexFivePrime];\n    angle = derivative > 0 ?\n      (coordinates.x[indexFivePrime] > 0 ? Math.PI - Math.atan(derivative) : Math.PI * 2 - Math.atan(derivative)) :\n      (coordinates.x[indexFivePrime] > 0 ? -Math.PI - Math.atan(derivative) : Math.atan(derivative));\n  }\n\n  const cos = Math.cos(angle);\n  const sin = Math.sin(angle);\n\n  for (let i = 0; i < natom; i++) {\n    const xAdd = coordinates.x[i];\n    coordinates.x[i] = xAdd * cos - coordinates.y[i] * sin;\n    coordinates.y[i] = xAdd * sin + coordinates.y[i] * cos;\n  }\n\n  //place to right\n  const xShift = coordinates.x[indexFivePrime];\n  for (let i = 0; i < natom; i++)\n    coordinates.x[i] -= xShift;\n\n  //rewrite molBlock\n  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n  index = molBlock.indexOf('\\n', index);\n  let indexEnd = index;\n  for (let i = 0; i < natom; i++) {\n    index = molBlock.indexOf('V30', index) + 4;\n    index = molBlock.indexOf(' ', index) + 1;\n    index = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', indexEnd);\n\n    molBlock = molBlock.slice(0, index) +\n      coordinates.x[i] + ' ' + coordinates.y[i] +\n      molBlock.slice(indexEnd);\n\n    index = molBlock.indexOf('\\n', index) + 1;\n  }\n\n  return molBlock;\n}\n\nfunction reflect(molBlock: string): string {\n  const coordinates = extractAtomDataV3000(molBlock);\n  const natom = coordinates.atomIndex.length;\n\n  const indexFivePrime = coordinates.atomIndex.indexOf(1);\n  const indexThreePrime = coordinates.atomIndex.indexOf(natom);\n\n  const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime]) / 2;\n  const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime]) / 2;\n\n  //place to center\n  for (let i = 0; i < natom; i++) {\n    coordinates.x[i] -= xCenter;\n    coordinates.y[i] -= yCenter;\n  }\n\n  //place to center\n  for (let i = 0; i < natom; i++)\n    coordinates.x[i] = -coordinates.x[i];\n\n  //place to right\n  const xShift = coordinates.x[indexFivePrime];\n  for (let i = 0; i < natom; i++)\n    coordinates.x[i] -= xShift;\n\n  //rewrite molBlock\n  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n  index = molBlock.indexOf('\\n', index);\n  let indexEnd = index;\n  for (let i = 0; i < natom; i++) {\n    index = molBlock.indexOf('V30', index) + 4;\n    index = molBlock.indexOf(' ', index) + 1;\n    index = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', indexEnd);\n\n    molBlock = molBlock.slice(0, index) +\n      coordinates.x[i] + ' ' + coordinates.y[i] +\n      molBlock.slice(indexEnd);\n\n    index = molBlock.indexOf('\\n', index) + 1;\n  }\n\n  return molBlock;\n}\n\n\nfunction invertNucleotidesV3000(molBlock: string) {\n  const coordinates = extractAtomDataV3000(molBlock);\n  const natom = coordinates.atomIndex.length;\n\n  const xCenter = (Math.max(...coordinates.x) + Math.min(...coordinates.x)) / 2;\n  const yCenter = (Math.max(...coordinates.y) + Math.min(...coordinates.y)) / 2;\n\n  //place to center\n  for (let i = 0; i < natom; i++) {\n    coordinates.x[i] -= xCenter;\n    coordinates.y[i] -= yCenter;\n  }\n\n  const angle = Math.PI;\n\n  const cos = Math.cos(angle);\n  const sin = Math.sin(angle);\n\n  for (let i = 0; i < natom; i++) {\n    const xAdd = coordinates.x[i];\n    coordinates.x[i] = xAdd * cos - coordinates.y[i] * sin;\n    coordinates.y[i] = xAdd * sin + coordinates.y[i] * cos;\n  }\n\n  //place back\n  const yShift = Math.max(...coordinates.y);\n  for (let i = 0; i < natom; i++) {\n    coordinates.x[i] += xCenter;\n    coordinates.y[i] -= yShift;\n  }\n\n  //rewrite molBlock\n  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n  index = molBlock.indexOf('\\n', index);\n  let indexEnd = index;\n  for (let i = 0; i < natom; i++) {\n    index = molBlock.indexOf('V30', index) + 4;\n    index = molBlock.indexOf(' ', index) + 1;\n    index = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', index) + 1;\n    indexEnd = molBlock.indexOf(' ', indexEnd);\n\n    molBlock = molBlock.slice(0, index) +\n      coordinates.x[i] + ' ' + coordinates.y[i] +\n      molBlock.slice(indexEnd);\n\n    index = molBlock.indexOf('\\n', index) + 1;\n  }\n\n  return molBlock;\n}\n\nfunction fix5Prime(coordinates: { atomIndex: number[], atomType: string[], x: number[], y: number[] },\n  indexFivePrime: number, indexThreePrime: number) {\n  const indexFivePrimeNeighbour = indexFivePrime + 1;\n  const xShift = coordinates.x[indexFivePrimeNeighbour];\n  const yShift = coordinates.y[indexFivePrimeNeighbour];\n  const base3PrimeX = coordinates.x[indexThreePrime] - xShift;\n  const base3PrimeY = coordinates.y[indexThreePrime] - yShift;\n  const base5PrimeX = coordinates.x[indexFivePrime] - xShift;\n  const base5PrimeY = coordinates.y[indexFivePrime] - yShift;\n\n  const rotated5PrimeX = base5PrimeX * Math.cos(Math.PI * 2 / 3) - base5PrimeY * Math.sin(Math.PI * 2 / 3);\n  const rotated5PrimeY = base5PrimeX * Math.sin(Math.PI * 2 / 3) + base5PrimeY * Math.cos(Math.PI * 2 / 3);\n\n  const dx = base5PrimeX - base3PrimeX;\n  const dy = base5PrimeY - base3PrimeY;\n  const dxRotated = rotated5PrimeX - base3PrimeX;\n  const dyRotated = rotated5PrimeY - base3PrimeY;\n\n  if (Math.sqrt(dyRotated * dyRotated + dxRotated * dxRotated) >= Math.sqrt(dy * dy + dx * dx)) {\n    coordinates.x[indexFivePrime] = rotated5PrimeX + xShift;\n    coordinates.y[indexFivePrime] = rotated5PrimeY + yShift;\n  }\n}\n\nfunction extractAtomsBondsNumbersV3000(molBlock: string): { natom: number, nbond: number } {\n  molBlock = molBlock.replaceAll('\\r', ''); //equalize old and new sdf standards\n  let index = molBlock.indexOf('COUNTS') + 7; // V3000 index for atoms and bonds number\n  let indexEnd = molBlock.indexOf(' ', index);\n\n  const atomsNumber = parseInt(molBlock.substring(index, indexEnd));\n  index = indexEnd + 1;\n  indexEnd = molBlock.indexOf(' ', index);\n  const bondsNumber = parseInt(molBlock.substring(index, indexEnd));\n\n  return {natom: atomsNumber, nbond: bondsNumber};\n}\n\nexport function extractAtomDataV3000(molBlock: string) {\n  const numbers = extractAtomsBondsNumbersV3000(molBlock);\n  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates\n  index = molBlock.indexOf('\\n', index);\n  let indexEnd = index;\n\n  const indexes: number[] = Array(numbers.natom);\n  const types: string[] = Array(numbers.natom);\n  const x: number[] = Array(numbers.natom);\n  const y: number[] = Array(numbers.natom);\n\n  for (let i = 0; i < numbers.natom; i++) {\n    index = molBlock.indexOf('V30', index) + 4;\n    indexEnd = molBlock.indexOf(' ', index);\n    indexes[i] = parseInt(molBlock.substring(index, indexEnd));\n\n    index = indexEnd + 1;\n    indexEnd = molBlock.indexOf(' ', index);\n    types[i] = molBlock.substring(index, indexEnd);\n\n    index = indexEnd + 1;\n    indexEnd = molBlock.indexOf(' ', index);\n    x[i] = parseFloat(molBlock.substring(index, indexEnd));\n\n    index = indexEnd + 1;\n    indexEnd = molBlock.indexOf(' ', index);\n    y[i] = parseFloat(molBlock.substring(index, indexEnd));\n\n    index = molBlock.indexOf('\\n', index) + 1;\n  }\n\n  return {atomIndex: indexes, atomType: types, x: x, y: y};\n}\n","export const GROUP_TYPE = {\n  NUCLEOSIDE: 'nucleoside',\n  LINKAGE: 'phosphateBackbone',\n} as const;\n\nexport const PHOSPHATE_SYMBOL = 'p';\n\nexport const UNKNOWN_SYMBOL = '<?>';\n","import {DEFAULT_FORMATS, NUCLEOTIDES} from '../../common/model/const';\nimport {NUCLEOTIDES_FORMAT} from '../view/const';\nimport {UNKNOWN_SYMBOL} from './const';\nimport {FormatConverter} from './format-converter';\nimport {CODES_TO_HELM_DICT} from '../../common/model/data-loader/json-loader';\nimport {MonomerLibWrapper} from '../../common/model/monomer-lib/lib-wrapper';\n\nexport function getTranslatedSequences(sequence: string, indexOfFirstInvalidChar: number, sourceFormat: string): {[key: string]: string} {\n  const supportedFormats = Object.keys(CODES_TO_HELM_DICT).concat([DEFAULT_FORMATS.HELM]) as string[];\n\n  if (!sequence || (indexOfFirstInvalidChar !== -1 && sourceFormat !== DEFAULT_FORMATS.HELM))\n    return {};\n\n  if (!supportedFormats.includes(sourceFormat))\n    throw new Error(`${sourceFormat} format is not supported by SequenceTranslator`);\n\n  const outputFormats = supportedFormats.filter((el) => el != sourceFormat)\n    .sort((a, b) => a.localeCompare(b));\n  const converter = new FormatConverter(sequence, sourceFormat);\n  const result = Object.fromEntries(\n    outputFormats.map((format) => {\n      let translation;\n      try {\n        translation = converter.convertTo(format);\n      } catch {\n        translation = null;\n      }\n      return [format, translation];\n    }).filter(([_, translation]) => translation)\n  );\n  const helm = (sourceFormat === DEFAULT_FORMATS.HELM) ? sequence : result[DEFAULT_FORMATS.HELM];\n  const nucleotides = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());\n  if (nucleotides)\n    result['Nucleotides'] = nucleotides;\n  return result;\n}\n\nexport function getNucleotidesSequence(helmString: string, monomerLib: MonomerLibWrapper): string | null {\n  const re = new RegExp('\\\\([^()]*\\\\)', 'g');\n  const branches = helmString.match(re);\n  if (!branches)\n    return null;\n  const nucleotides = branches!.map((branch) => {\n    const stripped = branch.replace(/[\\[\\]()]/g, '');\n    if (NUCLEOTIDES.includes(stripped))\n      return stripped;\n    return monomerLib.getNaturalAnalogBySymbol(stripped);\n  }).map((el) => el ? el : UNKNOWN_SYMBOL).join('');\n  return nucleotides;\n}\n\n// todo: remove after refactoring as a workaround\nexport function convert(sequence: string, sourceFormat: string, targetFormat: string): string | null {\n  const converter = new FormatConverter(sequence, sourceFormat);\n  if (targetFormat === NUCLEOTIDES_FORMAT) {\n    const helm = converter.convertTo(DEFAULT_FORMATS.HELM);\n    const nucleotides = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());\n    return nucleotides;\n  }\n\n  return converter.convertTo(targetFormat);\n}\n\nexport function getSupportedTargetFormats(): string[] {\n  const supportedTargetFormats = Object.keys(CODES_TO_HELM_DICT).concat([DEFAULT_FORMATS.HELM, NUCLEOTIDES_FORMAT]).sort() as string[];\n  return supportedTargetFormats;\n}\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {CODES_TO_HELM_DICT} from '../data-loader/json-loader';\nimport {CodesInfo} from '../data-loader/types';\nimport {DEFAULT_FORMATS} from '../const';\nimport {GROUP_TYPE, PHOSPHATE_SYMBOL} from '../../../translator/model/const';\n\nconst inverseLengthComparator = (a: string, b: string) => b.length - a.length;\n\nexport class FormatHandler {\n  constructor() {\n    this.formats = this.getFormats();\n  }\n\n  /** Includes all formats except HELM (the \"default\" one)  */\n  private formats: string[];\n\n  /** All format names except HELM (the \"default\" one)  */\n  getFormatNames(): string[] {\n    return this.formats.sort();\n  };\n\n  getCodesByFormat(format: string): string[] {\n    this.validateFormat(format);\n\n    if (this.isHelm(format))\n      throw new Error(`Codes cannot be obtained for HELM`);\n    return this.getFormatCodes(format);\n  }\n\n  getHelmToFormatDict(format: string): {[key: string]: string} {\n    this.validateFormat(format);\n\n    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;\n    const dict = getHelmToCodeDict(codesInfoObject);\n    return dict;\n  }\n\n  getFormatToHelmDict(format: string): {[key: string]: string} {\n    this.validateFormat(format);\n\n    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;\n    const dict = Object.assign({}, ...Object.values(codesInfoObject)) as {[code: string]: string};\n    return dict;\n  }\n\n  /** Get helm codes for the specified format  */\n  getTargetFormatHelmCodes(format: string): string[] {\n    this.validateFormat(format);\n\n    const dict = this.getHelmToFormatDict(format);\n    const helmCodes = Object.keys(dict).sort(inverseLengthComparator);\n    return helmCodes;\n  }\n\n  getTargetFormatHelmCodesRegExp(format: string): RegExp {\n    this.validateFormat(format);\n\n    const helmCodes = this.getTargetFormatHelmCodes(format);\n    const helmRegExp = new RegExp(getRegExpPattern(helmCodes) + '|.', 'g');\n    return helmRegExp;\n  }\n\n  getFormatRegExp(format: string): RegExp {\n    this.validateFormat(format);\n\n    if (this.isHelm(format))\n      throw new Error(`Helm RegExp can be built for non-HELM target formats`);\n    return this.getNonHelmFormatRegExp(format);\n  }\n\n  getPhosphateHelmCodesRegExp(format: string): RegExp {\n    this.validateFormat(format);\n\n    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;\n    const phosphateHELMCodes = Array.from(\n      new Set(Object.values(codesInfoObject[GROUP_TYPE.LINKAGE]))\n    ).sort(inverseLengthComparator);\n    const phosphateHELMPattern = getRegExpPattern(phosphateHELMCodes);\n    const phosphateRegExp = new RegExp(`${PHOSPHATE_SYMBOL}\\.(${phosphateHELMPattern})`, 'g');\n    return phosphateRegExp;\n  }\n\n  isValidFormat(format: string): boolean {\n    return this.formats.includes(format);\n  }\n\n  private getFormats(): string[] {\n    return Object.keys(CODES_TO_HELM_DICT);\n  }\n\n  private validateFormat(format: string) {\n    if (!this.isValidFormat(format))\n      throw new Error(`Invalid format: ${format}`);\n  }\n\n  private isHelm(format: string): boolean {\n    return format === DEFAULT_FORMATS.HELM;\n  }\n\n  private getFormatCodes(format: string): string[] {\n    const dict = this.getFormatToHelmDict(format);\n    const formatCodes = Object.keys(dict).sort(inverseLengthComparator);\n    return formatCodes;\n  }\n\n  private getNonHelmFormatRegExp(format: string): RegExp {\n    const formatCodes = this.getCodesByFormat(format);\n    const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\\\([^()]*\\\\)|.', 'g'); // the added group before '|.' is to avoid mismatch inside parenths\n    return formatRegExp;\n  }\n}\n\nexport function getRegExpPattern(arr: string[]): string {\n  const negativeLookBehind = '(?<!\\\\([^()]*)'; // not '(' followed by non-parenths\n  const negativeLookAhead = '(?![^()]*\\\\))'; // not ')' preceded by non-parenths\n  const escaped = arr.map((key) => key.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'))\n    .map((key) => {\n      if (!key.includes('(') && !key.includes(')'))\n        return `${negativeLookBehind}${key}${negativeLookAhead}`;\n      return key;\n    });\n  const result = escaped.join('|');\n  return result;\n}\n\nfunction getHelmToCodeDict(infoObj: CodesInfo) {\n  const result: {[key: string]: string | string[]} = {};\n  Object.values(infoObj).forEach((obj: {[code: string]: string}) => {\n    Object.entries(obj).forEach(([code, helm]) => {\n      const key = helm.replace(/\\)p/g, ')').replace(/\\]p/g, ']');\n      if (result[key] === undefined)\n        result[key] = [code];\n      else\n        (result[key] as string[]).push(code);\n    });\n  });\n  Object.entries(result).forEach(([key, value]) => {\n    const sorted = (value as string[]).sort(inverseLengthComparator);\n    result[key] = sorted[0] as string;\n  });\n  return result as {[key: string]: string};\n}\n","import * as DG from 'datagrok-api/dg';\nimport {DEFAULT_FORMATS} from '../../common/model/const';\nimport {PHOSPHATE_SYMBOL, UNKNOWN_SYMBOL} from './const';\nimport {FormatHandler, getRegExpPattern} from '../../common/model/parsing-validation/format-handler';\n\nconst HELM_WRAPPER = {\n  LEFT: 'RNA1{',\n  RIGHT: '}$$$$',\n};\n\nexport class FormatConverter {\n  constructor(private readonly sequence: string, private readonly sourceFormat: string) { };\n\n  private formats = new FormatHandler();\n\n  convertTo(targetFormat: string): string {\n    const formats = this.formats.getFormatNames();\n\n    if (this.sourceFormat === DEFAULT_FORMATS.HELM && formats.includes(targetFormat)) { return this.helmToFormat(this.sequence, targetFormat); } else if (formats.includes(this.sourceFormat) && targetFormat === DEFAULT_FORMATS.HELM) { return this.formatToHelm(this.sequence, this.sourceFormat); } else if ([this.sourceFormat, targetFormat].every((el) => formats.includes(el))) {\n      const helm = this.formatToHelm(this.sequence, this.sourceFormat);\n      return this.helmToFormat(helm, targetFormat);\n    } else {\n      throw new Error(`ST: unsupported translation direction ${this.sourceFormat} -> ${targetFormat}`);\n    }\n  }\n\n  private helmToFormat(helmSequence: string, targetFormat: string): string {\n    const wrapperRegExp = new RegExp(getRegExpPattern(Object.values(HELM_WRAPPER)), 'g');\n    let result = helmSequence.replace(wrapperRegExp, '');\n\n    const dict = this.formats.getHelmToFormatDict(targetFormat);\n    const helmCodes = this.formats.getTargetFormatHelmCodes(targetFormat);\n    const helmRegExp = this.formats.getTargetFormatHelmCodesRegExp(targetFormat);\n\n    result = result.replace(helmRegExp, (match) => {\n      return helmCodes.includes(match) ? dict[match] :\n        (match === 'p' || match === '.') ? match : '?';\n    }).replace(/\\?+/g, UNKNOWN_SYMBOL).replace(/p\\.|\\./g, '');\n    result = result.replace(/<empty>/g, '');\n    // remove double slash in LCMS codes\n    result = result.replace(/\\/\\//g, '/');\n    return result;\n  }\n\n  private formatToHelm(sequence: string, sourceFormat: string): string {\n    const dict = this.formats.getFormatToHelmDict(sourceFormat);\n    const formatCodes = this.formats.getCodesByFormat(sourceFormat);\n    const formatRegExp = this.formats.getFormatRegExp(sourceFormat);\n    const phosphateRegExp = this.formats.getPhosphateHelmCodesRegExp(sourceFormat);\n\n    let helm = sequence.replace(formatRegExp, (match) => {\n      const result = formatCodes.includes(match) ? dict[match] + '.' : '?';\n      return result;\n    });\n    helm = helm.replace(/\\?+/g, `${UNKNOWN_SYMBOL}.`);\n    helm = helm.slice(0, -1); // strip last dot\n    if (helm[helm.length - 1] === PHOSPHATE_SYMBOL)\n      helm = helm.slice(0, -1);\n    helm = helm.replace(phosphateRegExp, (match, group) => group);\n    helm = helm.replace(/<empty>/g, '');\n    return `${HELM_WRAPPER.LEFT + helm + HELM_WRAPPER.RIGHT}`;\n  }\n}\n","export const DEFAULT_INPUT = 'fAmCmGmAmCpsmU';\nexport const SEQUENCE_COPIED_MSG = 'Copied';\nexport const SEQ_TOOLTIP_MSG = 'Copy sequence';\n\nexport const NUCLEOTIDES_FORMAT = 'Nucleotides';\n","export var StringMetricsNames;\n(function (StringMetricsNames) {\n    StringMetricsNames[\"Levenshtein\"] = \"Levenshtein\";\n    StringMetricsNames[\"JaroWinkler\"] = \"Jaro-Winkler\";\n    StringMetricsNames[\"Manhattan\"] = \"Manhattan\";\n    StringMetricsNames[\"Onehot\"] = \"One-Hot\";\n})(StringMetricsNames || (StringMetricsNames = {}));\nexport var VectorMetricsNames;\n(function (VectorMetricsNames) {\n    VectorMetricsNames[\"Euclidean\"] = \"Euclidean\";\n})(VectorMetricsNames || (VectorMetricsNames = {}));\nexport var BitArrayMetricsNames;\n(function (BitArrayMetricsNames) {\n    BitArrayMetricsNames[\"Tanimoto\"] = \"Tanimoto\";\n    BitArrayMetricsNames[\"Dice\"] = \"Dice\";\n    BitArrayMetricsNames[\"Asymmetric\"] = \"Asymmetric\";\n    BitArrayMetricsNames[\"BraunBlanquet\"] = \"Braun-Blanquet\";\n    BitArrayMetricsNames[\"Cosine\"] = \"Cosine\";\n    BitArrayMetricsNames[\"Kulczynski\"] = \"Kulczynski\";\n    BitArrayMetricsNames[\"McConnaughey\"] = \"Mc-Connaughey\";\n    BitArrayMetricsNames[\"RogotGoldberg\"] = \"Rogot-Goldberg\";\n    BitArrayMetricsNames[\"Russel\"] = \"Russel\";\n    BitArrayMetricsNames[\"Sokal\"] = \"Sokal\";\n    BitArrayMetricsNames[\"Hamming\"] = \"Hamming\";\n    BitArrayMetricsNames[\"Euclidean\"] = \"Euclidean\";\n})(BitArrayMetricsNames || (BitArrayMetricsNames = {}));\nexport var IntArrayMetricsNames;\n(function (IntArrayMetricsNames) {\n    IntArrayMetricsNames[\"TanimotoIntArray\"] = \"TanimotoIntArray\";\n})(IntArrayMetricsNames || (IntArrayMetricsNames = {}));\nexport var DistanceMetricsSubjects;\n(function (DistanceMetricsSubjects) {\n    DistanceMetricsSubjects[\"Vector\"] = \"Vector\";\n    DistanceMetricsSubjects[\"String\"] = \"String\";\n    DistanceMetricsSubjects[\"BitArray\"] = \"BitArray\";\n    DistanceMetricsSubjects[\"MacroMolecule\"] = \"MacroMolecule\";\n    DistanceMetricsSubjects[\"Number\"] = \"Number\";\n    DistanceMetricsSubjects[\"IntArray\"] = \"IntArray\";\n    DistanceMetricsSubjects[\"NumberArray\"] = \"NumberArray\";\n})(DistanceMetricsSubjects || (DistanceMetricsSubjects = {}));\nexport var NumberMetricsNames;\n(function (NumberMetricsNames) {\n    NumberMetricsNames[\"Difference\"] = \"Difference\";\n})(NumberMetricsNames || (NumberMetricsNames = {}));\nexport var NumberArrayMetricsNames;\n(function (NumberArrayMetricsNames) {\n    NumberArrayMetricsNames[\"CommonItems\"] = \"Common Items\";\n})(NumberArrayMetricsNames || (NumberArrayMetricsNames = {}));\n//# sourceMappingURL=data:application/json;base64,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","export default class BitArray {\n    constructor(arg, defaultValue = false) {\n        this._length = 0;\n        this._version = 0;\n        this._updateLevel = 0;\n        this._selectedCount = 0;\n        this._selectedCountVersion = -1;\n        this._selectedIndexesVersion = -1;\n        this._versionedName = '';\n        this._versionedNameVersion = -1;\n        this.SHRINK_THRESHOLD = 0x100;\n        if (typeof arg === 'number') {\n            const length = arg;\n            const buff = BitArray._createBuffer(length);\n            if (defaultValue) {\n                for (let i = 0; i < buff.length; i++)\n                    buff[i] = -1;\n            }\n            this._data = buff;\n            this._length = length;\n        }\n        else if (arg instanceof Uint32Array) {\n            this._data = arg;\n            this._length = defaultValue;\n        }\n        else {\n            throw new Error('Invalid constructor');\n        }\n    }\n    getRawData() { return this._data; }\n    assureGoez(num, argName) {\n        if (num < 0)\n            throw new Error(`${argName} should be greater than zero`);\n    }\n    assureInRange(value, min, max, argName) {\n        if ((value < min) || (value > max))\n            throw new Error(`Argument ${argName} (${value}) out of range (${min}, ${max})`);\n    }\n    copy(src, dst, count) {\n        for (let i = 0; i < count; i++)\n            dst[i] = src[i];\n    }\n    copyFrom(other) {\n        if (this._length != other._length)\n            throw new Error(`Lengths differ (${this._length} != ${other._length})`);\n        this.copy(other._data, this._data, this.lengthInInts);\n        this._version++;\n    }\n    get length() {\n        return this._length;\n    }\n    get buffer() {\n        return this._data;\n    }\n    set buffer(data) {\n        this._data = data;\n        this._version++;\n    }\n    get version() {\n        return this._version;\n    }\n    set version(value) {\n        this._version = value;\n    }\n    incrementVersion(notify = true) {\n        this._version++;\n    }\n    get lengthInInts() {\n        return Math.floor((this._length + 0x1f) / 0x20);\n    }\n    get versionedName() {\n        return this._version == this._versionedNameVersion ? this._versionedName : '';\n    }\n    set versionedName(name) {\n        this._versionedName = name;\n        this._versionedNameVersion = this._version;\n    }\n    get self() {\n        return this;\n    }\n    setLength(value) {\n        if (value < 0)\n            throw new Error('should be >= 0');\n        if (value == this._length)\n            return;\n        const nIntsNeeded = Math.floor((value + 0x1f) / 0x20);\n        if ((nIntsNeeded > this._data.length) || ((nIntsNeeded + this.SHRINK_THRESHOLD) < this._data.length)) {\n            const newData = new Uint32Array(nIntsNeeded);\n            this.copy(this._data, newData, (nIntsNeeded > this._data.length) ? this._data.length : nIntsNeeded);\n            this._data = newData;\n        }\n        if (value > this._length) {\n            if (this._length % 0x20 > 0)\n                this._data[this.lengthInInts - 1] &= (1 << ((this._length % 0x20) & 0x1f)) - 1;\n            this._data.fill(0, this.lengthInInts, nIntsNeeded);\n        }\n        this._length = value;\n        this._version++;\n    }\n    static fromAnd(set1, set2) {\n        if (set1._length != set2._length)\n            throw new Error(`Lengths differ (${set1._length} != ${set2._length})`);\n        const temp = new BitArray(set1._length);\n        temp._length = set1._length;\n        temp._data = BitArray._createBuffer(temp._length);\n        temp._version = 0;\n        const len = set1.lengthInInts;\n        for (let i = 0; i < len; i++)\n            temp._data[i] = set1._data[i] & set2._data[i];\n        return temp;\n    }\n    static _createBuffer(length) {\n        return new Uint32Array(Math.floor((length + 0x1f) / 0x20));\n    }\n    static fromValues(values) {\n        const temp = new BitArray(values.length);\n        temp._version = 0;\n        for (let i = 0; i < temp._length; i++) {\n            if (values[i])\n                temp._data[Math.floor(i / 0x20)] |= 1 << ((i % 0x20) & 0x1f);\n        }\n        return temp;\n    }\n    /// Constructs a [BitSet] of length [count], where idx-th bit is determined by a call to [flag] (idx).\n    static fromSeq(count, flag) {\n        const temp = new BitArray(count);\n        for (let i = 0; i < count; ++i)\n            temp.setBit(i, flag(i));\n        temp._version = 0;\n        return temp;\n    }\n    /// Constructs a [BitSet] from a string [s] containing '0' or '1'.\n    static fromString(s) {\n        return BitArray.fromSeq(s.length, (i) => s.charAt(i) == '1');\n    }\n    /// Constructs a [BitSet], based on length [_length] and byte array [_data].\n    static fromUint32Array(_length, _data) {\n        const temp = new BitArray(_length);\n        temp._data = _data;\n        return temp;\n    }\n    /// Deserializes a [BitSet] from [bytes].\n    static fromBytes(bytes) {\n        const len = bytes.length;\n        const temp = new BitArray(len * 8);\n        temp._data = new Uint32Array(Math.floor((len + 3) / 4));\n        temp._length = len * 8;\n        let num1 = 0;\n        let num2 = 0;\n        while ((len - num2) >= 4) {\n            temp._data[num1++] = (((bytes[num2] & 0xff) | ((bytes[num2 + 1] & 0xff) << 8)) |\n                ((bytes[num2 + 2] & 0xff) << 0x10)) | ((bytes[num2 + 3] & 0xff) << 0x18);\n            num2 += 4;\n        }\n        if (len - num2 == 3)\n            temp._data[num1] = (bytes[num2 + 2] & 0xff) << 0x10;\n        if (len - num2 == 2)\n            temp._data[num1] |= (bytes[num2 + 1] & 0xff) << 8;\n        if (len - num2 == 1)\n            temp._data[num1] |= bytes[num2] & 0xff;\n        temp._version = 0;\n        return temp;\n    }\n    toString() {\n        return `${this._length} bits, ${this.countBits(true)} set`;\n    }\n    /// Performs deep comparison of two bitsets.\n    equals(other) {\n        if (this == other)\n            return true;\n        if (other == null)\n            return false;\n        if (this._length != other._length)\n            return false;\n        if (this._length == 0)\n            return true;\n        for (let i = 0; i < this._data.length - 1; i++)\n            if (this._data[i] != other._data[i])\n                return false;\n        for (let i = (this._data.length - 1) * 8; i < this._length; i++) {\n            if (this.getBit(i) != other.getBit(i))\n                return false;\n        }\n        return true;\n    }\n    /** Clones a bitset. */\n    clone() {\n        const bitArray = new BitArray(0, false);\n        bitArray._data = Uint32Array.from(this._data); // effective length: (lengthInInts)\n        bitArray._length = this._length;\n        bitArray._version = this._version;\n        return bitArray;\n    }\n    /** Initializes a bitset. */\n    init(flag, notify) {\n        this.setAll(false, false);\n        for (let i = 0; i < this._length; i++) {\n            if (flag(i))\n                this._data[Math.floor(i / 0x20)] |= 1 << ((i % 0x20) & 0x1f);\n        }\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Inverts a bitset.\n    invert(notify = true) {\n        for (let i = 0; i < this._data.length; i++)\n            this._data[i] ^= -1;\n        this.incrementVersion(notify);\n    }\n    /// Sets all bits to [value], optionally suppressing notifications.\n    setAll(value, notify = false) {\n        const flags = value ? -1 : 0;\n        const len = this.lengthInInts;\n        for (let i = 0; i < len; i++) //todo: optimize\n            this._data[i] = flags;\n        this.incrementVersion(notify);\n    }\n    /// Sets bits at [indexes] position to [value].\n    /// Clears the bitset if [clear] flag is true.\n    /// Change notification is raised when [notify] is true.\n    setIndexes(indexes, value = true, clear = true, notify = true) {\n        if (clear)\n            this.setAll(!value, false);\n        for (const i of indexes)\n            this.setFast(i, value);\n        this.incrementVersion(notify);\n    }\n    everyIndex(indexes, value = true) {\n        for (const index of indexes) {\n            if (this.getBit(index) != value)\n                return false;\n        }\n        return true;\n    }\n    anyIndex(indexes, value = true) {\n        for (const index of indexes) {\n            if (this.getBit(index) == value)\n                return true;\n        }\n        return false;\n    }\n    setWhere(check, value = true, clear = true, notify = true, allowClear = true) {\n        if (clear && allowClear)\n            this.setAll(!value, false);\n        if (allowClear) {\n            for (let i = 0; i < this._length; i++) {\n                if (check(i))\n                    this.setFast(i, value);\n            }\n        }\n        else {\n            for (let i = 0; i < this._length; i++)\n                this.setFast(i, check(i) ? value : !value);\n        }\n        this.incrementVersion(notify);\n    }\n    getRange(from, to) {\n        this.assureInRange(from, 0, this._length - 1, 'from');\n        this.assureInRange(to, 0, this._length, 'to');\n        const arr = [];\n        for (let i = from; i < to; ++i)\n            arr.push(this.getBit(i));\n        return BitArray.fromValues(arr);\n    }\n    getRangeAsList(from, to) {\n        this.assureInRange(from, 0, this._length - 1, 'from');\n        this.assureInRange(to, 0, this._length, 'to');\n        const arr = [];\n        for (let i = from; i < to; ++i)\n            arr.push(this.getBit(i));\n        return arr;\n    }\n    setRange(from, to, value, notify = true) {\n        this.assureInRange(from, 0, this._length - 1, 'from');\n        this.assureInRange(to, 0, this._length - 1, 'to');\n        const start = Math.min(from, to);\n        const end = Math.max(from, to);\n        //todo: optimize\n        if (value) {\n            for (let i = start; i <= end; i++)\n                this.setTrue(i);\n        }\n        else {\n            for (let i = start; i <= end; i++)\n                this.setFalse(i);\n        }\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Sets n randomly chosen bits to value, remaining bits to !value.\n    setRandom(n, value, notify = true) {\n        if (n < 0 || n > this._length)\n            throw new Error('n must be >= 0 && <= Count');\n        if (n > this._length / 2)\n            this.setRandom(this._length - n, !value);\n        this.setAll(!value);\n        for (let k = 0; k < n;) {\n            const i = Math.floor(Math.random() * this._length);\n            if (this.getBit(i) == value)\n                continue;\n            this.setFast(i, value);\n            k++;\n        }\n        this.incrementVersion(notify);\n    }\n    /// Modifies current bitset by performing the bitwise AND operation against the\n    /// corresponding elements in the specified bitset.\n    and(value, notify = true) {\n        if (this._length != value._length)\n            throw new Error('Array lengths differ.');\n        for (let i = 0, len = this.lengthInInts; i < len; i++)\n            this._data[i] &= value._data[i];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Performs the bitwise AND NOT operation on the elements in the current bitset\n    /// against the corresponding elements in the specified bitset.\n    andNot(value, notify = true) {\n        if (this._length != value._length)\n            throw new Error('Array lengths differ.');\n        const len = this.lengthInInts;\n        for (let num2 = 0; num2 < len; num2++)\n            this._data[num2] &= ~value._data[num2];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Performs the bitwise NOT AND operation on the elements in the current bitset\n    /// against the corresponding elements in the specified bitset.\n    notAnd(value, notify = true) {\n        if (this._length != value._length)\n            throw new Error('Array lengths differ.');\n        for (let i = 0, len = this.lengthInInts; i < len; i++)\n            this._data[i] = (~this._data[i]) & value._data[i];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Inverts all bit values in the current bitset\n    not(notify = true) {\n        for (let i = 0, len = this.lengthInInts; i < len; i++)\n            this._data[i] = ~this._data[i];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Performs the bitwise OR operation on the elements in the current bitset\n    /// against the corresponding elements in the specified bitset.\n    or(value, notify = true) {\n        if (this._length != value._length)\n            throw new Error('Array lengths differ.');\n        for (let i = 0, len = this.lengthInInts; i < len; i++)\n            this._data[i] |= value._data[i];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Performs the bitwise exclusive OR operation on the elements in the current bitset\n    /// against the corresponding elements in the specified bitset.\n    xor(value, notify = true) {\n        if (this._length != value._length)\n            throw new Error('Array lengths differ.');\n        for (let i = 0, len = this.lengthInInts; i < len; i++)\n            this._data[i] ^= value._data[i];\n        this.incrementVersion(notify);\n        return this;\n    }\n    /// Inserts n 0-bits at position pos, resizing self and shifting bits appropriately.\n    insertAt(pos, n, flag = false) {\n        this.assureInRange(pos, 0, this._length, 'pos');\n        if (n == 0)\n            return;\n        //TODO: optimize\n        //the most primitive implementation, optimize it later!\n        // beginUpdate();\n        const oldlength = this._length;\n        this.setLength(this._length + n);\n        //if (!contains(!flag)) return; // nothing to do\n        for (let i = oldlength - 1; i >= pos; i--)\n            this.setBit(i + n, this.getBit(i));\n        for (let i = pos; i < pos + n; i++)\n            this.setBit(i, flag);\n        // endUpdate();\n    }\n    /// Deletes n bits beginning at position pos, resizing self and shifting remaining\n    /// bits appropriately.\n    removeAt(pos, n = 1) {\n        // the most primitive implementation, optimize it later!\n        if (n < 0)\n            throw new Error('n cannot be negative');\n        this.assureInRange(pos, 0, this._length - n, 'pos');\n        if (this.contains(true)) {\n            for (let i = pos; i < this._length - n; i++)\n                this.setBit(i, this.getBit(i + n));\n        }\n        this.setLength(this._length - n);\n    }\n    removeByMask(mask, flag = true) {\n        if (this._length != mask.length)\n            throw new Error('length != mask.length');\n        if (mask == this) { // no need to iterate\n            this.setLength(mask.countBits(!flag));\n            this.setAll(!flag);\n        }\n        else {\n            let dstIdx = 0;\n            for (let srcIdx = -1; (srcIdx = mask.findNext(srcIdx, !flag)) != -1;)\n                this.setFast(dstIdx++, this.getBit(srcIdx));\n            this._length = dstIdx;\n            this._version++;\n        }\n        return this;\n    }\n    /// Similar to the [] operator.\n    getBit(pos) {\n        return (this._data[Math.floor(pos / 0x20)] & (1 << (pos & 0x1f))) != 0;\n    }\n    /// Similar to the [] operator.\n    setBit(pos, bit, notify = true) {\n        this.setFast(pos, bit);\n        if (notify)\n            this._version++;\n        else\n            this._version++;\n    }\n    /// Sets [i]-th bit to [value], does not check bounds, does not increment version\n    setFast(i, value) {\n        if (value)\n            this._data[Math.floor(i / 0x20)] |= 1 << (i & 0x1f);\n        else\n            this._data[Math.floor(i / 0x20)] &= ~(1 << (i & 0x1f));\n    }\n    setTrue(pos) {\n        this._data[Math.floor(pos / 0x20)] |= 1 << (pos & 0x1f);\n    }\n    setFalse(pos) {\n        this._data[Math.floor(pos / 0x20)] &= ~(1 << (pos & 0x1f));\n    }\n    trueCount() {\n        return this.countBits(true);\n    }\n    falseCount() {\n        return this.countBits(false);\n    }\n    /// Counts bits of the specified value.\n    countBits(value) {\n        if (this._length == 0)\n            return 0;\n        if (this._selectedCountVersion != this._version) {\n            this._selectedCount = 0;\n            const len = this.lengthInInts;\n            let i = 0;\n            for (; i < len - 1; i++) {\n                for (let k = this._data[i]; k != 0; k >>>= 8) { //todo: cast data[i] to uint\n                    this._selectedCount += BitArray._onBitCount[k & 0xff];\n                }\n            }\n            // The last int.\n            let k = this._data[i];\n            const remainingBits = this._length & 0x1f;\n            if (remainingBits != 0) /* if remainingBits == 0, the last int is fully used and ALL bits should be left as is */\n                k &= ~((4294967295) << remainingBits);\n            for (; k != 0; k >>>= 8)\n                this._selectedCount += BitArray._onBitCount[k & 0xff];\n            this._selectedCountVersion = this._version;\n        }\n        return (value ? this._selectedCount : this._length - this._selectedCount);\n    }\n    /// Returns a number of set bits where also [check] is true\n    countWhere(check) {\n        let result = 0;\n        if (this.trueCount() == this._length) {\n            for (let i = 0; i < this._length; i++)\n                result += check(i) ? 1 : 0;\n        }\n        else {\n            for (let i = -1; (i = this.findNext(i, true)) != -1;)\n                result += check(i) ? 1 : 0;\n        }\n        return result;\n    }\n    /// Performs bit \"and\" and counts bits of the specified value, without bitset modification.\n    andWithCountBits(second, value) {\n        if (this._length == 0)\n            return 0;\n        let count = 0;\n        const len = this.lengthInInts;\n        let i = 0;\n        for (; i < len - 1; i++) {\n            for (let k = this._data[i] & second._data[i]; k != 0; k >>>= 8)\n                count += BitArray._onBitCount[k & 0xff];\n        }\n        // The last int.\n        let k = this._data[i] & second._data[i];\n        const remainingBits = this._length & 0x1f;\n        if (remainingBits != 0)\n            k &= ~((4294967295) << remainingBits);\n        for (; k != 0; k >>>= 8)\n            count += BitArray._onBitCount[k & 0xff];\n        return (value ? count : this._length - count);\n    }\n    clear() {\n        this.setLength(0);\n    }\n    contains(value) {\n        return this.findNext(-1, value) >= 0;\n    }\n    get allTrue() {\n        return this.countBits(true) == this._length;\n    }\n    get allFalse() {\n        return this.countBits(false) == this._length;\n    }\n    get anyTrue() {\n        return this.countBits(true) > 0;\n    }\n    get anyFalse() {\n        return this.countBits(false) > 0;\n    }\n    /// Returns the position of the next bit of the specified value, starting from the specified position.\n    /// Returns -1, if there are no such bits.\n    findNext(index, value = true) {\n        this.assureInRange(index, -1, this._length, 'index');\n        if (index >= this._length - 1)\n            return -1;\n        index = index < 0 ? 0 : index + 1; // skip start\n        let unusedBits = index & 0x1f;\n        const numInts = this.lengthInInts;\n        for (let i = Math.floor(index / 32); i < numInts; i++) {\n            let k = (value ? this._data[i] : ~this._data[i]); // uint cast\n            if (unusedBits != 0) {\n                k &= ((0xffffffff << unusedBits) & 0xffffffff);\n                unusedBits = 0;\n            }\n            else if (!value && k == -4294967296) /* looking for false, all bits are set */ {\n                continue;\n            }\n            for (let j = 0; k != 0; j += 8, k >>>= 8) {\n                const p = BitArray._firstOnBit[k & 0xff];\n                if (p >= 0) {\n                    index = p + (i * 32) + j;\n                    if (index >= this._length)\n                        return -1;\n                    return index;\n                }\n            }\n        }\n        return -1;\n    }\n    /// Finds previous bit of the specified value in the bitset.\n    findPrev(index, value = true) {\n        if (index == 0)\n            return -1;\n        this.assureInRange(index, -1, this._length, 'index');\n        index = index < 0 ? this._length - 1 : index - 1; // skip start\n        const lastIntIdx = Math.floor(index / 0x20);\n        let remainingBits = (index + 1) & 0x1f;\n        for (let i = lastIntIdx; i >= 0; i--) {\n            let k = (value ? this._data[i] : ~this._data[i]); // cast\n            if (remainingBits != 0) {\n                k &= ~((4294967295) << remainingBits);\n                remainingBits = 0;\n            }\n            for (let j = 24; k != 0; j -= 8, k <<= 8) {\n                const p = BitArray._lastOnBit[k >>> 0x18];\n                if (p >= 0)\n                    return p + (i * 32) + j;\n            }\n        }\n        return -1;\n    }\n}\nBitArray._onBitCount = Int8Array.from([\n    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8\n]);\nBitArray._firstOnBit = Int8Array.from([\n    -1, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0\n]);\nBitArray._lastOnBit = Int8Array.from([\n    -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,\n    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7\n]);\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bit-array.js","sourceRoot":"","sources":["bit-array.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,QAAQ;IAoE3B,YAAY,GAAyB,EAAE,eAAiC,KAAK;QAZrE,YAAO,GAAG,CAAC,CAAC;QACZ,aAAQ,GAAG,CAAC,CAAC;QACb,iBAAY,GAAG,CAAC,CAAC;QACjB,mBAAc,GAAG,CAAC,CAAC;QACnB,0BAAqB,GAAG,CAAC,CAAC,CAAC;QAC3B,4BAAuB,GAAG,CAAC,CAAC,CAAC;QAC7B,mBAAc,GAAG,EAAE,CAAC;QACpB,0BAAqB,GAAG,CAAC,CAAC,CAAC;QACnC,qBAAgB,GAAG,KAAK,CAAC;QAKvB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;YAC3B,MAAM,MAAM,GAAG,GAAG,CAAC;YACnB,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC5C,IAAI,YAAY,EAAE;gBAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE;oBAClC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;aAChB;YACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;SACvB;aAAM,IAAI,GAAG,YAAY,WAAW,EAAE;YACrC,IAAI,CAAC,KAAK,GAAG,GAAkB,CAAC;YAChC,IAAI,CAAC,OAAO,GAAG,YAAsB,CAAC;SACvC;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SACxC;IACH,CAAC;IAGD,UAAU,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAEnC,UAAU,CAAC,GAAW,EAAE,OAAe;QACrC,IAAI,GAAG,GAAG,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,GAAG,OAAO,8BAA8B,CAAC,CAAC;IACzE,CAAC;IAED,aAAa,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW,EAAE,OAAe;QACpE,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,YAAY,OAAO,KAAK,KAAK,mBAAmB,GAAG,KAAK,GAAG,GAAG,CAAC,CAAC;IACpF,CAAC;IAED,IAAI,CAAC,GAAgB,EAAE,GAAgB,EAAE,KAAa;QACpD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE;YAC5B,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,KAAe;QACtB,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,OAAO,OAAO,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,MAAM,CAAC,IAAiB;QAC1B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,OAAO,CAAC,KAAa;QACvB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IAED,gBAAgB,CAAC,MAAM,GAAG,IAAI;QAC5B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;IAChF,CAAC;IAED,IAAI,aAAa,CAAC,IAAY;QAC5B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC7C,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC;IACd,CAAC;IAED,SAAS,CAAC,KAAa;QACrB,IAAI,KAAK,GAAG,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAEpC,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAClC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACtD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YACpG,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;YAC7C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;YACpG,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC;SACtB;QAED,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE;YACxB,IAAI,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC;gBACzB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YAEjF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;SACpD;QACD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,IAAc,EAAE,IAAc;QAC3C,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;YAC9B,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,OAAO,OAAO,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QAEzE,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAElB,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YAC1B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAEhD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,MAAM,CAAC,aAAa,CAAC,MAAc;QACzC,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,MAAsB;QACtC,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;YACrC,IAAI,MAAM,CAAC,CAAC,CAAC;gBACX,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SAChE;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sGAAsG;IACtG,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,IAAc;QAC1C,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1B,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kEAAkE;IAClE,MAAM,CAAC,UAAU,CAAC,CAAS;QACzB,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;IACvE,CAAC;IAED,4EAA4E;IAC5E,MAAM,CAAC,eAAe,CAAC,OAAe,EAAE,KAAkB;QACxD,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yCAAyC;IACzC,MAAM,CAAC,SAAS,CAAC,KAAiB;QAChC,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;QACzB,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;QACnC,IAAI,CAAC,KAAK,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,OAAO,GAAG,GAAG,GAAG,CAAC,CAAC;QACvB,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,IAAI,IAAI,GAAG,CAAC,CAAC;QAEb,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE;YACxB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CACnB,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxD,CAAC,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,CACnC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;YAEvC,IAAI,IAAI,CAAC,CAAC;SACX;QAED,IAAI,GAAG,GAAG,IAAI,IAAI,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC;QAEtD,IAAI,GAAG,GAAG,IAAI,IAAI,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAEpD,IAAI,GAAG,GAAG,IAAI,IAAI,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAEzC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,OAAO,UAAU,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;IAC7D,CAAC;IAED,4CAA4C;IAC5C,MAAM,CAAC,KAAe;QACpB,IAAI,IAAI,IAAI,KAAK;YAAE,OAAO,IAAI,CAAC;QAC/B,IAAI,KAAK,IAAI,IAAI;YAAE,OAAO,KAAK,CAAC;QAChC,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAChD,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAEnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE;YAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBAAE,OAAO,KAAK,CAAC;QAEpD,KAAK,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;YAC/D,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;gBACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uBAAuB;IACvB,KAAK;QACH,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACxC,QAAQ,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,mCAAmC;QAClF,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,4BAA4B;IAC5B,IAAI,CAAC,IAAc,EAAE,MAAe;QAClC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAE1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;YACrC,IAAI,IAAI,CAAC,CAAC,CAAC;gBACT,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SAChE;QAED,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,qBAAqB;IACrB,MAAM,CAAC,MAAM,GAAG,IAAI;QAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE;YACxC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAEtB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,mEAAmE;IACnE,MAAM,CAAC,KAAc,EAAE,MAAM,GAAG,KAAK;QACnC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,gBAAgB;YAC5C,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QAExB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,+CAA+C;IAC/C,8CAA8C;IAC9C,wDAAwD;IACxD,UAAU,CAAC,OAAsB,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI;QAC1E,IAAI,KAAK;YACP,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAE7B,KAAK,MAAM,CAAC,IAAI,OAAO;YACrB,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAEzB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,UAAU,CAAC,OAAsB,EAAE,KAAK,GAAG,IAAI;QAC7C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YAC3B,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK;gBAC7B,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,CAAC,OAAsB,EAAE,KAAK,GAAG,IAAI;QAC3C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YAC3B,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK;gBAC7B,OAAO,IAAI,CAAC;SACf;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,QAAQ,CAAC,KAAe,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,GAAG,IAAI;QACpF,IAAI,KAAK,IAAI,UAAU;YACrB,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAE7B,IAAI,UAAU,EAAE;YACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;gBACrC,IAAI,KAAK,CAAC,CAAC,CAAC;oBACV,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;aAC1B;SACF;aAAM;YACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;gBACnC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;SAC9C;QAED,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,QAAQ,CAAC,IAAY,EAAE,EAAU;QAC/B,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAmB,EAAE,CAAC;QAC/B,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC;YAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,OAAO,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED,cAAc,CAAC,IAAY,EAAE,EAAU;QACrC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAc,EAAE,CAAC;QAC1B,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC;YAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,OAAO,GAAG,CAAC;IACb,CAAC;IAGD,QAAQ,CAAC,IAAY,EAAE,EAAU,EAAE,KAAc,EAAE,MAAM,GAAG,IAAI;QAC9D,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;QAElD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAE/B,gBAAgB;QAChB,IAAI,KAAK,EAAE;YACT,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE;gBAC/B,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;SACnB;aAAM;YACL,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE;gBAC/B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;SACpB;QAED,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,mEAAmE;IACnE,SAAS,CAAC,CAAS,EAAE,KAAc,EAAE,MAAM,GAAG,IAAI;QAChD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO;YAC3B,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAEhD,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC;YACtB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAE3C,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;QAEpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG;YACtB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;YACnD,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK;gBAAE,SAAS;YACtC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YACvB,CAAC,EAAE,CAAC;SACL;QAED,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,+EAA+E;IAC/E,mDAAmD;IACnD,GAAG,CAAC,KAAe,EAAE,MAAM,GAAG,IAAI;QAChC,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAElC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,+DAA+D;IAC/D,MAAM,CAAC,KAAe,EAAE,MAAM,GAAG,IAAI;QACnC,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9B,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE;YACnC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEzC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gFAAgF;IAChF,+DAA+D;IAC/D,MAAM,CAAC,KAAe,EAAE,MAAM,GAAG,IAAI;QACnC,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAEpD,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gDAAgD;IAChD,GAAG,CAAC,MAAM,GAAG,IAAI;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAEjC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,2EAA2E;IAC3E,+DAA+D;IAC/D,EAAE,CAAC,KAAe,EAAE,MAAM,GAAG,IAAI;QAC/B,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAElC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,qFAAqF;IACrF,+DAA+D;IAC/D,GAAG,CAAC,KAAe,EAAE,MAAM,GAAG,IAAI;QAChC,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO;YAC/B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAElC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,oFAAoF;IACpF,QAAQ,CAAC,GAAW,EAAE,CAAS,EAAE,IAAI,GAAG,KAAK;QAC3C,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEhD,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO;QAEnB,gBAAgB;QAChB,uDAAuD;QAEvD,iBAAiB;QACjB,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QAEjC,gDAAgD;QAEhD,KAAK,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE;YACvC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAErC,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE;YAChC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAEvB,eAAe;IACjB,CAAC;IAED,kFAAkF;IAClF,uBAAuB;IACvB,QAAQ,CAAC,GAAW,EAAE,CAAC,GAAG,CAAC;QACzB,wDAAwD;QACxD,IAAI,CAAC,GAAG,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAE1C,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QAEpD,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;YACvB,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC,EAAE;gBACzC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;SACtC;QAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,YAAY,CAAC,IAAc,EAAE,IAAI,GAAG,IAAI;QACtC,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM;YAC7B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3C,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,qBAAqB;YACvC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;SACpB;aAAM;YACL,IAAI,MAAM,GAAG,CAAC,CAAC;YAEf,KAAK,IAAI,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;gBACjE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAE9C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjB;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,+BAA+B;IAC/B,MAAM,CAAC,GAAW;QAChB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACzE,CAAC;IAED,+BAA+B;IAC/B,MAAM,CAAC,GAAW,EAAE,GAAY,EAAE,MAAM,GAAG,IAAI;QAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QACvB,IAAI,MAAM;YACR,IAAI,CAAC,QAAQ,EAAE,CAAC;;YAEhB,IAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC;IAED,iFAAiF;IACjF,OAAO,CAAC,CAAS,EAAE,KAAc;QAC/B,IAAI,KAAK;YACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;;YAEpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,QAAQ,CAAC,GAAW;QAClB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,uCAAuC;IACvC,SAAS,CAAC,KAAc;QACtB,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC;QAEhC,IAAI,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/C,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;YACxB,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;YAC9B,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBACvB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,EAAE,4BAA4B;oBAC1E,IAAI,CAAC,cAAc,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;iBACvD;aACF;YAED,gBAAgB;YAChB,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YAC1C,IAAI,aAAa,IAAI,CAAC,EAAE,yFAAyF;gBAC/G,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,aAAa,CAAC,CAAC;YAExC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC;gBACrB,IAAI,CAAC,cAAc,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;YAExD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC;SAC5C;QAED,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;IAC5E,CAAC;IAED,2DAA2D;IAC3D,UAAU,CAAC,KAAe;QACxB,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,IAAI,CAAC,SAAS,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE;YACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;gBACnC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC9B;aAAM;YACL,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;gBACjD,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC9B;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,2FAA2F;IAC3F,gBAAgB,CAAC,MAAgB,EAAE,KAAc;QAC/C,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC;QAEhC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9B,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YACvB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC;gBAC5D,KAAK,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;SAC3C;QAED,gBAAgB;QAChB,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAC1C,IAAI,aAAa,IAAI,CAAC;YACpB,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,aAAa,CAAC,CAAC;QACxC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC;YACrB,KAAK,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAE1C,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,KAAK;QACH,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,KAAc;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC;IAC9C,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC;IAC/C,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,sGAAsG;IACtG,0CAA0C;IAC1C,QAAQ,CAAC,KAAa,EAAE,KAAK,GAAG,IAAI;QAClC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAErD,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC;QACzC,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,aAAa;QAChD,IAAI,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC;QAC9B,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE;YACrD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY;YAC9D,IAAI,UAAU,IAAI,CAAC,EAAE;gBACnB,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,UAAU,CAAC,GAAG,UAAU,CAAC,CAAC;gBAC/C,UAAU,GAAG,CAAC,CAAC;aAChB;iBAAM,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,yCAAyC,CAAA;gBAC9E,SAAS;aACV;YAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE;gBACxC,MAAM,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;gBACzC,IAAI,CAAC,IAAI,CAAC,EAAE;oBACV,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;oBACzB,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO;wBAAE,OAAO,CAAC,CAAC,CAAC;oBACrC,OAAO,KAAK,CAAC;iBACd;aACF;SACF;QACD,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;IAED,4DAA4D;IAC5D,QAAQ,CAAC,KAAa,EAAE,KAAK,GAAG,IAAI;QAClC,IAAI,KAAK,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAErD,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,aAAa;QAE/D,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;QAC5C,IAAI,aAAa,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;QAEvC,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACpC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO;YACzD,IAAI,aAAa,IAAI,CAAC,EAAE;gBACtB,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,aAAa,CAAC,CAAC;gBACtC,aAAa,GAAG,CAAC,CAAC;aACnB;YACD,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE;gBACxC,MAAM,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;gBAC1C,IAAI,CAAC,IAAI,CAAC;oBACR,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;aAC3B;SACF;QACD,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;;AAruBM,oBAAW,GAAG,SAAS,CAAC,IAAI,CAAC;IAClC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;CAAC,CAAC,CAAC;AAE5C,oBAAW,GAAG,SAAS,CAAC,IAAI,CAAC;IAClC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC/C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;CAAC,CAAC,CAAC;AAE5C,mBAAU,GAAG,SAAS,CAAC,IAAI,CAAC;IACjC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC/C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;CAAC,CAAC,CAAC","sourcesContent":["export default class BitArray {\n  static _onBitCount = Int8Array.from([\n    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,\n    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8]);\n\n  static _firstOnBit = Int8Array.from([\n    -1, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,\n    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0]);\n\n  static _lastOnBit = Int8Array.from([\n    -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,\n    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]);\n\n  private _data: Uint32Array;\n  private _length = 0;\n  private _version = 0;\n  private _updateLevel = 0;\n  private _selectedCount = 0;\n  private _selectedCountVersion = -1;\n  private _selectedIndexesVersion = -1;\n  private _versionedName = '';\n  private _versionedNameVersion = -1;\n  SHRINK_THRESHOLD = 0x100;\n\n  constructor(data: Uint32Array, length: number)\n  constructor(length: number, defaultValue?: boolean)\n  constructor(arg: number | Uint32Array, defaultValue: boolean | number = false) {\n    if (typeof arg === 'number') {\n      const length = arg;\n      const buff = BitArray._createBuffer(length);\n      if (defaultValue) {\n        for (let i = 0; i < buff.length; i++)\n          buff[i] = -1;\n      }\n      this._data = buff;\n      this._length = length;\n    } else if (arg instanceof Uint32Array) {\n      this._data = arg as Uint32Array;\n      this._length = defaultValue as number;\n    } else {\n      throw new Error('Invalid constructor');\n    }\n  }\n\n\n  getRawData() { return this._data; }\n\n  assureGoez(num: number, argName: String): void {\n    if (num < 0) throw new Error(`${argName} should be greater than zero`);\n  }\n\n  assureInRange(value: number, min: number, max: number, argName: String): void {\n    if ((value < min) || (value > max))\n      throw new Error(`Argument ${argName} (${value}) out of range (${min}, ${max})`);\n  }\n\n  copy(src: Uint32Array, dst: Uint32Array, count: number): void {\n    for (let i = 0; i < count; i++)\n      dst[i] = src[i];\n  }\n\n  copyFrom(other: BitArray): void {\n    if (this._length != other._length)\n      throw new Error(`Lengths differ (${this._length} != ${other._length})`);\n    this.copy(other._data, this._data, this.lengthInInts);\n    this._version++;\n  }\n\n  get length() {\n    return this._length;\n  }\n\n  get buffer() {\n    return this._data;\n  }\n\n  set buffer(data: Uint32Array) {\n    this._data = data;\n    this._version++;\n  }\n\n  get version() {\n    return this._version;\n  }\n\n  set version(value: number) {\n    this._version = value;\n  }\n\n  incrementVersion(notify = true): void {\n    this._version++;\n  }\n\n  get lengthInInts() {\n    return Math.floor((this._length + 0x1f) / 0x20);\n  }\n\n  get versionedName() {\n    return this._version == this._versionedNameVersion ? this._versionedName : '';\n  }\n\n  set versionedName(name: string) {\n    this._versionedName = name;\n    this._versionedNameVersion = this._version;\n  }\n\n  get self() {\n    return this;\n  }\n\n  setLength(value: number): void {\n    if (value < 0)\n      throw new Error('should be >= 0');\n\n    if (value == this._length) return;\n    const nIntsNeeded = Math.floor((value + 0x1f) / 0x20);\n    if ((nIntsNeeded > this._data.length) || ((nIntsNeeded + this.SHRINK_THRESHOLD) < this._data.length)) {\n      const newData = new Uint32Array(nIntsNeeded);\n      this.copy(this._data, newData, (nIntsNeeded > this._data.length) ? this._data.length : nIntsNeeded);\n      this._data = newData;\n    }\n\n    if (value > this._length) {\n      if (this._length % 0x20 > 0)\n        this._data[this.lengthInInts - 1] &= (1 << ((this._length % 0x20) & 0x1f)) - 1;\n\n      this._data.fill(0, this.lengthInInts, nIntsNeeded);\n    }\n    this._length = value;\n    this._version++;\n  }\n\n  static fromAnd(set1: BitArray, set2: BitArray): BitArray {\n    if (set1._length != set2._length)\n      throw new Error(`Lengths differ (${set1._length} != ${set2._length})`);\n\n    const temp = new BitArray(set1._length);\n    temp._length = set1._length;\n    temp._data = BitArray._createBuffer(temp._length);\n    temp._version = 0;\n\n    const len = set1.lengthInInts;\n    for (let i = 0; i < len; i++)\n      temp._data[i] = set1._data[i] & set2._data[i];\n\n    return temp;\n  }\n\n  private static _createBuffer(length: number): Uint32Array {\n    return new Uint32Array(Math.floor((length + 0x1f) / 0x20));\n  }\n\n  static fromValues(values: Array<boolean>): BitArray {\n    const temp = new BitArray(values.length);\n    temp._version = 0;\n\n    for (let i = 0; i < temp._length; i++) {\n      if (values[i])\n        temp._data[Math.floor(i / 0x20)] |= 1 << ((i % 0x20) & 0x1f);\n    }\n    return temp;\n  }\n\n  /// Constructs a [BitSet] of length [count], where idx-th bit is determined by a call to [flag] (idx).\n  static fromSeq(count: number, flag: Function): BitArray {\n    const temp = new BitArray(count);\n    for (let i = 0; i < count; ++i)\n      temp.setBit(i, flag(i));\n\n    temp._version = 0;\n    return temp;\n  }\n\n  /// Constructs a [BitSet] from a string [s] containing '0' or '1'.\n  static fromString(s: string): BitArray {\n    return BitArray.fromSeq(s.length, (i: number) => s.charAt(i) == '1');\n  }\n\n  /// Constructs a [BitSet], based on length [_length] and byte array [_data].\n  static fromUint32Array(_length: number, _data: Uint32Array): BitArray {\n    const temp = new BitArray(_length);\n    temp._data = _data;\n    return temp;\n  }\n\n  /// Deserializes a [BitSet] from [bytes].\n  static fromBytes(bytes: Uint8Array): BitArray {\n    const len = bytes.length;\n    const temp = new BitArray(len * 8);\n    temp._data = new Uint32Array(Math.floor((len + 3) / 4));\n    temp._length = len * 8;\n    let num1 = 0;\n    let num2 = 0;\n\n    while ((len - num2) >= 4) {\n      temp._data[num1++] = (\n        ((bytes[num2] & 0xff) | ((bytes[num2 + 1] & 0xff) << 8)) |\n        ((bytes[num2 + 2] & 0xff) << 0x10)\n      ) | ((bytes[num2 + 3] & 0xff) << 0x18);\n\n      num2 += 4;\n    }\n\n    if (len - num2 == 3)\n      temp._data[num1] = (bytes[num2 + 2] & 0xff) << 0x10;\n\n    if (len - num2 == 2)\n      temp._data[num1] |= (bytes[num2 + 1] & 0xff) << 8;\n\n    if (len - num2 == 1)\n      temp._data[num1] |= bytes[num2] & 0xff;\n\n    temp._version = 0;\n    return temp;\n  }\n\n  toString(): string {\n    return `${this._length} bits, ${this.countBits(true)} set`;\n  }\n\n  /// Performs deep comparison of two bitsets.\n  equals(other: BitArray): boolean {\n    if (this == other) return true;\n    if (other == null) return false;\n    if (this._length != other._length) return false;\n    if (this._length == 0) return true;\n\n    for (let i = 0; i < this._data.length - 1; i++)\n      if (this._data[i] != other._data[i]) return false;\n\n    for (let i = (this._data.length - 1) * 8; i < this._length; i++) {\n      if (this.getBit(i) != other.getBit(i))\n        return false;\n    }\n    return true;\n  }\n\n  /** Clones a bitset. */\n  clone(): BitArray {\n    const bitArray = new BitArray(0, false);\n    bitArray._data = Uint32Array.from(this._data); // effective length: (lengthInInts)\n    bitArray._length = this._length;\n    bitArray._version = this._version;\n    return bitArray;\n  }\n\n  /** Initializes a bitset. */\n  init(flag: Function, notify: boolean): BitArray {\n    this.setAll(false, false);\n\n    for (let i = 0; i < this._length; i++) {\n      if (flag(i))\n        this._data[Math.floor(i / 0x20)] |= 1 << ((i % 0x20) & 0x1f);\n    }\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Inverts a bitset.\n  invert(notify = true): void {\n    for (let i = 0; i < this._data.length; i++)\n      this._data[i] ^= -1;\n\n    this.incrementVersion(notify);\n  }\n\n  /// Sets all bits to [value], optionally suppressing notifications.\n  setAll(value: boolean, notify = false): void {\n    const flags = value ? -1 : 0;\n    const len = this.lengthInInts;\n\n    for (let i = 0; i < len; i++) //todo: optimize\n      this._data[i] = flags;\n\n    this.incrementVersion(notify);\n  }\n\n  /// Sets bits at [indexes] position to [value].\n  /// Clears the bitset if [clear] flag is true.\n  /// Change notification is raised when [notify] is true.\n  setIndexes(indexes: Array<number>, value = true, clear = true, notify = true): void {\n    if (clear)\n      this.setAll(!value, false);\n\n    for (const i of indexes)\n      this.setFast(i, value);\n\n    this.incrementVersion(notify);\n  }\n\n  everyIndex(indexes: Array<number>, value = true): boolean {\n    for (const index of indexes) {\n      if (this.getBit(index) != value)\n        return false;\n    }\n    return true;\n  }\n\n  anyIndex(indexes: Array<number>, value = true): boolean {\n    for (const index of indexes) {\n      if (this.getBit(index) == value)\n        return true;\n    }\n    return false;\n  }\n\n  setWhere(check: Function, value = true, clear = true, notify = true, allowClear = true): void {\n    if (clear && allowClear)\n      this.setAll(!value, false);\n\n    if (allowClear) {\n      for (let i = 0; i < this._length; i++) {\n        if (check(i))\n          this.setFast(i, value);\n      }\n    } else {\n      for (let i = 0; i < this._length; i++)\n        this.setFast(i, check(i) ? value : !value);\n    }\n\n    this.incrementVersion(notify);\n  }\n\n  getRange(from: number, to: number): BitArray {\n    this.assureInRange(from, 0, this._length - 1, 'from');\n    this.assureInRange(to, 0, this._length, 'to');\n    const arr: Array<boolean> = [];\n    for (let i = from; i < to; ++i)\n      arr.push(this.getBit(i));\n    return BitArray.fromValues(arr);\n  }\n\n  getRangeAsList(from: number, to: number): boolean[] {\n    this.assureInRange(from, 0, this._length - 1, 'from');\n    this.assureInRange(to, 0, this._length, 'to');\n    const arr: boolean[] = [];\n    for (let i = from; i < to; ++i)\n      arr.push(this.getBit(i));\n    return arr;\n  }\n\n\n  setRange(from: number, to: number, value: boolean, notify = true): BitArray {\n    this.assureInRange(from, 0, this._length - 1, 'from');\n    this.assureInRange(to, 0, this._length - 1, 'to');\n\n    const start = Math.min(from, to);\n    const end = Math.max(from, to);\n\n    //todo: optimize\n    if (value) {\n      for (let i = start; i <= end; i++)\n        this.setTrue(i);\n    } else {\n      for (let i = start; i <= end; i++)\n        this.setFalse(i);\n    }\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Sets n randomly chosen bits to value, remaining bits to !value.\n  setRandom(n: number, value: boolean, notify = true): void {\n    if (n < 0 || n > this._length)\n      throw new Error('n must be >= 0 && <= Count');\n\n    if (n > this._length / 2)\n      this.setRandom(this._length - n, !value);\n\n    this.setAll(!value);\n\n    for (let k = 0; k < n;) {\n      const i = Math.floor(Math.random() * this._length);\n      if (this.getBit(i) == value) continue;\n      this.setFast(i, value);\n      k++;\n    }\n\n    this.incrementVersion(notify);\n  }\n\n  /// Modifies current bitset by performing the bitwise AND operation against the\n  /// corresponding elements in the specified bitset.\n  and(value: BitArray, notify = true): BitArray {\n    if (this._length != value._length)\n      throw new Error('Array lengths differ.');\n\n    for (let i = 0, len = this.lengthInInts; i < len; i++)\n      this._data[i] &= value._data[i];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Performs the bitwise AND NOT operation on the elements in the current bitset\n  /// against the corresponding elements in the specified bitset.\n  andNot(value: BitArray, notify = true): BitArray {\n    if (this._length != value._length)\n      throw new Error('Array lengths differ.');\n\n    const len = this.lengthInInts;\n    for (let num2 = 0; num2 < len; num2++)\n      this._data[num2] &= ~value._data[num2];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Performs the bitwise NOT AND operation on the elements in the current bitset\n  /// against the corresponding elements in the specified bitset.\n  notAnd(value: BitArray, notify = true): BitArray {\n    if (this._length != value._length)\n      throw new Error('Array lengths differ.');\n\n    for (let i = 0, len = this.lengthInInts; i < len; i++)\n      this._data[i] = (~this._data[i]) & value._data[i];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Inverts all bit values in the current bitset\n  not(notify = true): BitArray {\n    for (let i = 0, len = this.lengthInInts; i < len; i++)\n      this._data[i] = ~this._data[i];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Performs the bitwise OR operation on the elements in the current bitset\n  /// against the corresponding elements in the specified bitset.\n  or(value: BitArray, notify = true) {\n    if (this._length != value._length)\n      throw new Error('Array lengths differ.');\n\n    for (let i = 0, len = this.lengthInInts; i < len; i++)\n      this._data[i] |= value._data[i];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Performs the bitwise exclusive OR operation on the elements in the current bitset\n  /// against the corresponding elements in the specified bitset.\n  xor(value: BitArray, notify = true) {\n    if (this._length != value._length)\n      throw new Error('Array lengths differ.');\n\n    for (let i = 0, len = this.lengthInInts; i < len; i++)\n      this._data[i] ^= value._data[i];\n\n    this.incrementVersion(notify);\n    return this;\n  }\n\n  /// Inserts n 0-bits at position pos, resizing self and shifting bits appropriately.\n  insertAt(pos: number, n: number, flag = false): void {\n    this.assureInRange(pos, 0, this._length, 'pos');\n\n    if (n == 0) return;\n\n    //TODO: optimize\n    //the most primitive implementation, optimize it later!\n\n    // beginUpdate();\n    const oldlength = this._length;\n    this.setLength(this._length + n);\n\n    //if (!contains(!flag)) return; // nothing to do\n\n    for (let i = oldlength - 1; i >= pos; i--)\n      this.setBit(i + n, this.getBit(i));\n\n    for (let i = pos; i < pos + n; i++)\n      this.setBit(i, flag);\n\n    // endUpdate();\n  }\n\n  /// Deletes n bits beginning at position pos, resizing self and shifting remaining\n  /// bits appropriately.\n  removeAt(pos: number, n = 1): void {\n    // the most primitive implementation, optimize it later!\n    if (n < 0)\n      throw new Error('n cannot be negative');\n\n    this.assureInRange(pos, 0, this._length - n, 'pos');\n\n    if (this.contains(true)) {\n      for (let i = pos; i < this._length - n; i++)\n        this.setBit(i, this.getBit(i + n));\n    }\n\n    this.setLength(this._length - n);\n  }\n\n  removeByMask(mask: BitArray, flag = true): BitArray {\n    if (this._length != mask.length)\n      throw new Error('length != mask.length');\n\n    if (mask == this) { // no need to iterate\n      this.setLength(mask.countBits(!flag));\n      this.setAll(!flag);\n    } else {\n      let dstIdx = 0;\n\n      for (let srcIdx = -1; (srcIdx = mask.findNext(srcIdx, !flag)) != -1;)\n        this.setFast(dstIdx++, this.getBit(srcIdx));\n\n      this._length = dstIdx;\n      this._version++;\n    }\n\n    return this;\n  }\n\n  /// Similar to the [] operator.\n  getBit(pos: number): boolean {\n    return (this._data[Math.floor(pos / 0x20)] & (1 << (pos & 0x1f))) != 0;\n  }\n\n  /// Similar to the [] operator.\n  setBit(pos: number, bit: boolean, notify = true) {\n    this.setFast(pos, bit);\n    if (notify)\n      this._version++;\n    else\n      this._version++;\n  }\n\n  /// Sets [i]-th bit to [value], does not check bounds, does not increment version\n  setFast(i: number, value: boolean): void {\n    if (value)\n      this._data[Math.floor(i / 0x20)] |= 1 << (i & 0x1f);\n    else\n      this._data[Math.floor(i / 0x20)] &= ~(1 << (i & 0x1f));\n  }\n\n  setTrue(pos: number): void {\n    this._data[Math.floor(pos / 0x20)] |= 1 << (pos & 0x1f);\n  }\n\n  setFalse(pos: number) {\n    this._data[Math.floor(pos / 0x20)] &= ~(1 << (pos & 0x1f));\n  }\n\n  trueCount(): number {\n    return this.countBits(true);\n  }\n\n  falseCount(): number {\n    return this.countBits(false);\n  }\n\n  /// Counts bits of the specified value.\n  countBits(value: boolean): number {\n    if (this._length == 0) return 0;\n\n    if (this._selectedCountVersion != this._version) {\n      this._selectedCount = 0;\n      const len = this.lengthInInts;\n      let i = 0;\n      for (; i < len - 1; i++) {\n        for (let k = this._data[i]; k != 0; k >>>= 8) { //todo: cast data[i] to uint\n          this._selectedCount += BitArray._onBitCount[k & 0xff];\n        }\n      }\n\n      // The last int.\n      let k = this._data[i];\n      const remainingBits = this._length & 0x1f;\n      if (remainingBits != 0) /* if remainingBits == 0, the last int is fully used and ALL bits should be left as is */\n        k &= ~((4294967295) << remainingBits);\n\n      for (; k != 0; k >>>= 8)\n        this._selectedCount += BitArray._onBitCount[k & 0xff];\n\n      this._selectedCountVersion = this._version;\n    }\n\n    return (value ? this._selectedCount : this._length - this._selectedCount);\n  }\n\n  /// Returns a number of set bits where also [check] is true\n  countWhere(check: Function): number {\n    let result = 0;\n    if (this.trueCount() == this._length) {\n      for (let i = 0; i < this._length; i++)\n        result += check(i) ? 1 : 0;\n    } else {\n      for (let i = -1; (i = this.findNext(i, true)) != -1;)\n        result += check(i) ? 1 : 0;\n    }\n    return result;\n  }\n\n  /// Performs bit \"and\" and counts bits of the specified value, without bitset modification.\n  andWithCountBits(second: BitArray, value: boolean): number {\n    if (this._length == 0) return 0;\n\n    let count = 0;\n    const len = this.lengthInInts;\n    let i = 0;\n    for (; i < len - 1; i++) {\n      for (let k = this._data[i] & second._data[i]; k != 0; k >>>= 8)\n        count += BitArray._onBitCount[k & 0xff];\n    }\n\n    // The last int.\n    let k = this._data[i] & second._data[i];\n    const remainingBits = this._length & 0x1f;\n    if (remainingBits != 0)\n      k &= ~((4294967295) << remainingBits);\n    for (; k != 0; k >>>= 8)\n      count += BitArray._onBitCount[k & 0xff];\n\n    return (value ? count : this._length - count);\n  }\n\n  clear(): void {\n    this.setLength(0);\n  }\n\n  contains(value: boolean): boolean {\n    return this.findNext(-1, value) >= 0;\n  }\n\n  get allTrue() {\n    return this.countBits(true) == this._length;\n  }\n\n  get allFalse() {\n    return this.countBits(false) == this._length;\n  }\n\n  get anyTrue() {\n    return this.countBits(true) > 0;\n  }\n\n  get anyFalse() {\n    return this.countBits(false) > 0;\n  }\n\n  /// Returns the position of the next bit of the specified value, starting from the specified position.\n  /// Returns -1, if there are no such bits.\n  findNext(index: number, value = true): number {\n    this.assureInRange(index, -1, this._length, 'index');\n\n    if (index >= this._length - 1) return -1;\n    index = index < 0 ? 0 : index + 1; // skip start\n    let unusedBits = index & 0x1f;\n    const numInts = this.lengthInInts;\n\n    for (let i = Math.floor(index / 32); i < numInts; i++) {\n      let k = (value ? this._data[i] : ~this._data[i]); // uint cast\n      if (unusedBits != 0) {\n        k &= ((0xffffffff << unusedBits) & 0xffffffff);\n        unusedBits = 0;\n      } else if (!value && k == -4294967296) /* looking for false, all bits are set */{\n        continue;\n      }\n\n      for (let j = 0; k != 0; j += 8, k >>>= 8) {\n        const p = BitArray._firstOnBit[k & 0xff];\n        if (p >= 0) {\n          index = p + (i * 32) + j;\n          if (index >= this._length) return -1;\n          return index;\n        }\n      }\n    }\n    return -1;\n  }\n\n  /// Finds previous bit of the specified value in the bitset.\n  findPrev(index: number, value = true): number {\n    if (index == 0) return -1;\n    this.assureInRange(index, -1, this._length, 'index');\n\n    index = index < 0 ? this._length - 1 : index - 1; // skip start\n\n    const lastIntIdx = Math.floor(index / 0x20);\n    let remainingBits = (index + 1) & 0x1f;\n\n    for (let i = lastIntIdx; i >= 0; i--) {\n      let k = (value ? this._data[i] : ~this._data[i]); // cast\n      if (remainingBits != 0) {\n        k &= ~((4294967295) << remainingBits);\n        remainingBits = 0;\n      }\n      for (let j = 24; k != 0; j -= 8, k <<= 8) {\n        const p = BitArray._lastOnBit[k >>> 0x18];\n        if (p >= 0)\n          return p + (i * 32) + j;\n      }\n    }\n    return -1;\n  }\n}\n"]}","const peq = new Uint32Array(0x10000);\nconst myers_32 = (a, b) => {\n    const n = a.length;\n    const m = b.length;\n    const lst = 1 << (n - 1);\n    let pv = -1;\n    let mv = 0;\n    let sc = n;\n    let i = n;\n    while (i--) {\n        peq[a.charCodeAt(i)] |= 1 << i;\n    }\n    for (i = 0; i < m; i++) {\n        let eq = peq[b.charCodeAt(i)];\n        const xv = eq | mv;\n        eq |= ((eq & pv) + pv) ^ pv;\n        mv |= ~(eq | pv);\n        pv &= eq;\n        if (mv & lst) {\n            sc++;\n        }\n        if (pv & lst) {\n            sc--;\n        }\n        mv = (mv << 1) | 1;\n        pv = (pv << 1) | ~(xv | mv);\n        mv &= xv;\n    }\n    i = n;\n    while (i--) {\n        peq[a.charCodeAt(i)] = 0;\n    }\n    return sc;\n};\nconst myers_x = (b, a) => {\n    const n = a.length;\n    const m = b.length;\n    const mhc = [];\n    const phc = [];\n    const hsize = Math.ceil(n / 32);\n    const vsize = Math.ceil(m / 32);\n    for (let i = 0; i < hsize; i++) {\n        phc[i] = -1;\n        mhc[i] = 0;\n    }\n    let j = 0;\n    for (; j < vsize - 1; j++) {\n        let mv = 0;\n        let pv = -1;\n        const start = j * 32;\n        const vlen = Math.min(32, m) + start;\n        for (let k = start; k < vlen; k++) {\n            peq[b.charCodeAt(k)] |= 1 << k;\n        }\n        for (let i = 0; i < n; i++) {\n            const eq = peq[a.charCodeAt(i)];\n            const pb = (phc[(i / 32) | 0] >>> i) & 1;\n            const mb = (mhc[(i / 32) | 0] >>> i) & 1;\n            const xv = eq | mv;\n            const xh = ((((eq | mb) & pv) + pv) ^ pv) | eq | mb;\n            let ph = mv | ~(xh | pv);\n            let mh = pv & xh;\n            if ((ph >>> 31) ^ pb) {\n                phc[(i / 32) | 0] ^= 1 << i;\n            }\n            if ((mh >>> 31) ^ mb) {\n                mhc[(i / 32) | 0] ^= 1 << i;\n            }\n            ph = (ph << 1) | pb;\n            mh = (mh << 1) | mb;\n            pv = mh | ~(xv | ph);\n            mv = ph & xv;\n        }\n        for (let k = start; k < vlen; k++) {\n            peq[b.charCodeAt(k)] = 0;\n        }\n    }\n    let mv = 0;\n    let pv = -1;\n    const start = j * 32;\n    const vlen = Math.min(32, m - start) + start;\n    for (let k = start; k < vlen; k++) {\n        peq[b.charCodeAt(k)] |= 1 << k;\n    }\n    let score = m;\n    for (let i = 0; i < n; i++) {\n        const eq = peq[a.charCodeAt(i)];\n        const pb = (phc[(i / 32) | 0] >>> i) & 1;\n        const mb = (mhc[(i / 32) | 0] >>> i) & 1;\n        const xv = eq | mv;\n        const xh = ((((eq | mb) & pv) + pv) ^ pv) | eq | mb;\n        let ph = mv | ~(xh | pv);\n        let mh = pv & xh;\n        score += (ph >>> (m - 1)) & 1;\n        score -= (mh >>> (m - 1)) & 1;\n        if ((ph >>> 31) ^ pb) {\n            phc[(i / 32) | 0] ^= 1 << i;\n        }\n        if ((mh >>> 31) ^ mb) {\n            mhc[(i / 32) | 0] ^= 1 << i;\n        }\n        ph = (ph << 1) | pb;\n        mh = (mh << 1) | mb;\n        pv = mh | ~(xv | ph);\n        mv = ph & xv;\n    }\n    for (let k = start; k < vlen; k++) {\n        peq[b.charCodeAt(k)] = 0;\n    }\n    return score;\n};\nconst distance = (a, b) => {\n    if (a.length < b.length) {\n        const tmp = b;\n        b = a;\n        a = tmp;\n    }\n    if (b.length === 0) {\n        return a.length;\n    }\n    if (a.length <= 32) {\n        return myers_32(a, b);\n    }\n    return myers_x(a, b);\n};\nconst closest = (str, arr) => {\n    let min_distance = Infinity;\n    let min_index = 0;\n    for (let i = 0; i < arr.length; i++) {\n        const dist = distance(str, arr[i]);\n        if (dist < min_distance) {\n            min_distance = dist;\n            min_index = i;\n        }\n    }\n    return arr[min_index];\n};\nexport { closest, distance };\n","import { hamming } from './hamming';\nimport { levenstein } from './levenstein';\nimport { needlemanWunch } from './needleman-wunsch';\n/** Enum containing currently supported macromolecule distance functions\n * Hamming distance will be used if the sequences are already aligned\n * Needleman distance will be used for protein sequences with known BLOSUM62 matrix\n * Levenshtein distance will be used for nucleotide sequences as for them substitution matrix is same as identity matrix\n */\nexport var MmDistanceFunctionsNames;\n(function (MmDistanceFunctionsNames) {\n    MmDistanceFunctionsNames[\"HAMMING\"] = \"Hamming\";\n    MmDistanceFunctionsNames[\"LEVENSHTEIN\"] = \"Levenshtein\";\n    MmDistanceFunctionsNames[\"NEEDLEMANN_WUNSCH\"] = \"Needlemann-Wunsch\";\n    MmDistanceFunctionsNames[\"MONOMER_CHEMICAL_DISTANCE\"] = \"Monomer chemical distance\";\n})(MmDistanceFunctionsNames || (MmDistanceFunctionsNames = {}));\n;\nexport const mmDistanceFunctions = {\n    [MmDistanceFunctionsNames.HAMMING]: hamming,\n    [MmDistanceFunctionsNames.LEVENSHTEIN]: levenstein,\n    [MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]: needlemanWunch,\n    [MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE]: hamming\n};\n//# sourceMappingURL=data:application/json;base64,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","import BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport { BitArrayMetricsNames } from './typed-metrics/consts';\nimport { MmDistanceFunctionsNames } from './macromolecule-distance-functions';\nexport const similarityMetric = {\n    [BitArrayMetricsNames.Tanimoto]: tanimotoSimilarity,\n    [BitArrayMetricsNames.Dice]: diceSimilarity,\n    [BitArrayMetricsNames.Asymmetric]: asymmetricSimilarity,\n    [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetSimilarity,\n    [BitArrayMetricsNames.Cosine]: cosineSimilarity,\n    [BitArrayMetricsNames.Kulczynski]: kulczynskiSimilarity,\n    [BitArrayMetricsNames.McConnaughey]: mcConnaugheySimilarity,\n    [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergSimilarity,\n    [BitArrayMetricsNames.Russel]: russelSimilarity,\n    [BitArrayMetricsNames.Sokal]: sokalSimilarity,\n    [BitArrayMetricsNames.Hamming]: hammingSimilarity,\n    [BitArrayMetricsNames.Euclidean]: euclideanSimilarity,\n};\nexport const distanceMetrics = {\n    [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n    [BitArrayMetricsNames.Dice]: diceDistance,\n    [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n    [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n    [BitArrayMetricsNames.Cosine]: cosineDistance,\n    [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n    [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n    [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n    [BitArrayMetricsNames.Russel]: russelDistance,\n    [BitArrayMetricsNames.Sokal]: sokalDistance,\n    [BitArrayMetricsNames.Hamming]: hammingDistance,\n    [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\nexport const CHEM_SIMILARITY_METRICS = [\n    BitArrayMetricsNames.Tanimoto,\n    BitArrayMetricsNames.Dice,\n    BitArrayMetricsNames.Cosine\n];\nexport const SEQ_SPACE_SIMILARITY_METRICS = [\n    BitArrayMetricsNames.Tanimoto,\n    BitArrayMetricsNames.Asymmetric,\n    BitArrayMetricsNames.Cosine,\n    BitArrayMetricsNames.Sokal\n];\nexport const MACROMOLECULE_SIMILARITY_METRICS = [\n    MmDistanceFunctionsNames.HAMMING,\n    MmDistanceFunctionsNames.LEVENSHTEIN,\n    MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE,\n    MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH\n];\nexport function tanimotoSimilarity(x, y) {\n    const total = x.trueCount() + y.trueCount();\n    if (total == 0)\n        return 1.0;\n    const common = x.andWithCountBits(y, true);\n    return common / (total - common);\n}\nexport function tanimotoDistance(x, y) {\n    return 1 - tanimotoSimilarity(x, y);\n}\nexport function tanimotoDistanceIntArray(x, y) {\n    const xb = new BitArray(x, x.length * 32);\n    const yb = new BitArray(y, y.length * 32);\n    return getDistanceFromSimilarity(tanimotoSimilarity(xb, yb));\n}\nexport function diceSimilarity(x, y) {\n    const total = x.trueCount() + y.trueCount();\n    if (total == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return 2 * common / total;\n}\nexport function diceDistance(x, y) {\n    return 1 - diceSimilarity(x, y);\n}\nexport function cosineSimilarity(x, y) {\n    const total = x.trueCount() * y.trueCount();\n    if (total == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return common / Math.sqrt(total);\n}\nexport function cosineDistance(x, y) {\n    return 1 - cosineSimilarity(x, y);\n}\nexport function euclideanSimilarity(x, y) {\n    return getSimilarityFromDistance(euclideanDistance(x, y));\n}\nexport function euclideanDistance(x, y) {\n    return Math.sqrt(x.trueCount() + y.trueCount() - 2 * x.andWithCountBits(y, true));\n}\nexport function hammingSimilarity(x, y) {\n    return getSimilarityFromDistance(hammingDistance(x, y));\n}\nexport function hammingDistance(x, y) {\n    return x.trueCount() + y.trueCount() - 2 * x.andWithCountBits(y, true);\n}\nexport function sokalSimilarity(x, y) {\n    const total = x.trueCount() + y.trueCount();\n    const common = x.andWithCountBits(y, true);\n    return common / (2 * total - 3 * common);\n}\nexport function sokalDistance(x, y) {\n    return 1 - sokalSimilarity(x, y);\n}\nexport function kulczynskiSimilarity(x, y) {\n    const total = x.trueCount() + y.trueCount();\n    const totalProd = x.trueCount() * y.trueCount();\n    if (totalProd == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return (common * total) / (2 * totalProd);\n}\nexport function kulczynskiDistance(x, y) {\n    return getDistanceFromSimilarity(kulczynskiSimilarity(x, y));\n}\nexport function mcConnaugheySimilarity(x, y) {\n    const total = x.trueCount() + y.trueCount();\n    const totalProd = x.trueCount() * y.trueCount();\n    if (totalProd == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return (common * total - totalProd) / totalProd;\n}\nexport function mcConnaugheyDistance(x, y) {\n    return getDistanceFromSimilarity(mcConnaugheySimilarity(x, y));\n}\nexport function asymmetricSimilarity(x, y) {\n    const min = Math.min(x.trueCount(), y.trueCount());\n    if (min == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return common / min;\n}\nexport function asymmetricDistance(x, y) {\n    return 1 - asymmetricSimilarity(x, y);\n}\nexport function braunBlanquetSimilarity(x, y) {\n    const max = Math.max(x.trueCount(), y.trueCount());\n    if (max == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return common / max;\n}\nexport function braunBlanquetDistance(x, y) {\n    return getDistanceFromSimilarity(braunBlanquetSimilarity(x, y));\n}\nexport function russelSimilarity(x, y) {\n    if (x.length == 0)\n        return 0.0;\n    const common = x.andWithCountBits(y, true);\n    return common / x.length;\n}\nexport function russelDistance(x, y) {\n    return getDistanceFromSimilarity(russelSimilarity(x, y));\n}\nexport function rogotGoldbergSimilarity(x, y) {\n    const common = x.andWithCountBits(y, true);\n    const total = x.countBits(true) + y.countBits(true);\n    const len = x.length;\n    const diff = len - total + common;\n    if ((common == len) || (diff == len))\n        return 1.0;\n    else\n        return common / total + diff / (2 * len - total);\n}\nexport function rogotGoldbergDistance(x, y) {\n    return getDistanceFromSimilarity(rogotGoldbergSimilarity(x, y));\n}\nexport function getSimilarityFromDistance(distance) {\n    return 1 / (1 + distance);\n}\nexport function getDistanceFromSimilarity(similarity) {\n    return similarity === 0 ? 3.402823E+38 : (1 / similarity) - 1;\n}\nexport function numericDistance(args) {\n    if (args && args.range != undefined && args.range > 0) {\n        const range = args.range;\n        return (a, b) => Math.abs(a - b) / range;\n    }\n    return (a, b) => Math.abs(a - b);\n}\nexport function commonItemsCount(args) {\n    const mostCommon = args?.mostCommon ?? new Set();\n    return (arr1, arr2) => {\n        const len1 = arr1.length;\n        const len2 = arr2.length;\n        let count = 0;\n        let i1 = 0;\n        let i2 = 0;\n        while ((i1 < len1) && (i2 < len2)) {\n            if (arr1[i1] === arr2[i2]) {\n                if (!mostCommon?.has(arr1[i1]))\n                    ++count;\n                ++i1;\n                ++i2;\n            }\n            else if (arr1[i1] < arr2[i2]) {\n                ++i1;\n            }\n            else {\n                ++i2;\n            }\n        }\n        return count;\n    };\n}\nexport function inverseCommonItemsCount(args) {\n    const f = commonItemsCount(args);\n    return (arr1, arr2) => {\n        if (arr2.length === 0 || arr1.length === 0)\n            return 10000;\n        return Math.min(arr1.length, arr2.length) / (f(arr1, arr2) + 0.0001);\n    };\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distance-metrics-methods.js","sourceRoot":"","sources":["distance-metrics-methods.ts"],"names":[],"mappings":"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","sourcesContent":["import BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport {BitArrayMetricsNames} from './typed-metrics/consts';\nimport {MmDistanceFunctionsNames} from './macromolecule-distance-functions';\n\nexport const similarityMetric: { [name: string]: (x: BitArray, y: BitArray) => number } = {\n  [BitArrayMetricsNames.Tanimoto]: tanimotoSimilarity,\n  [BitArrayMetricsNames.Dice]: diceSimilarity,\n  [BitArrayMetricsNames.Asymmetric]: asymmetricSimilarity,\n  [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetSimilarity,\n  [BitArrayMetricsNames.Cosine]: cosineSimilarity,\n  [BitArrayMetricsNames.Kulczynski]: kulczynskiSimilarity,\n  [BitArrayMetricsNames.McConnaughey]: mcConnaugheySimilarity,\n  [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergSimilarity,\n  [BitArrayMetricsNames.Russel]: russelSimilarity,\n  [BitArrayMetricsNames.Sokal]: sokalSimilarity,\n  [BitArrayMetricsNames.Hamming]: hammingSimilarity,\n  [BitArrayMetricsNames.Euclidean]: euclideanSimilarity,\n};\n\nexport const distanceMetrics: { [name: string]: (x: BitArray, y: BitArray) => number } = {\n  [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n  [BitArrayMetricsNames.Dice]: diceDistance,\n  [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n  [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n  [BitArrayMetricsNames.Cosine]: cosineDistance,\n  [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n  [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n  [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n  [BitArrayMetricsNames.Russel]: russelDistance,\n  [BitArrayMetricsNames.Sokal]: sokalDistance,\n  [BitArrayMetricsNames.Hamming]: hammingDistance,\n  [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\n\nexport const CHEM_SIMILARITY_METRICS = [\n  BitArrayMetricsNames.Tanimoto,\n  BitArrayMetricsNames.Dice,\n  BitArrayMetricsNames.Cosine];\nexport const SEQ_SPACE_SIMILARITY_METRICS = [\n  BitArrayMetricsNames.Tanimoto,\n  BitArrayMetricsNames.Asymmetric,\n  BitArrayMetricsNames.Cosine,\n  BitArrayMetricsNames.Sokal];\nexport const MACROMOLECULE_SIMILARITY_METRICS = [\n  MmDistanceFunctionsNames.HAMMING,\n  MmDistanceFunctionsNames.LEVENSHTEIN,\n  MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE,\n  MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH\n];\n\n\nexport function tanimotoSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  if (total == 0) return 1.0;\n  const common = x.andWithCountBits(y, true);\n  return common / (total - common);\n}\n\nexport function tanimotoDistance(x: BitArray, y: BitArray): number {\n  return 1 - tanimotoSimilarity(x, y);\n}\n\nexport function tanimotoDistanceIntArray(x: Uint32Array, y: Uint32Array): number {\n  const xb = new BitArray(x, x.length * 32);\n  const yb = new BitArray(y, y.length * 32);\n  return getDistanceFromSimilarity(tanimotoSimilarity(xb, yb));\n}\n\nexport function diceSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  if (total == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return 2 * common / total;\n}\n\nexport function diceDistance(x: BitArray, y: BitArray): number {\n  return 1 - diceSimilarity(x, y);\n}\n\nexport function cosineSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() * y.trueCount();\n  if (total == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / Math.sqrt(total);\n}\n\nexport function cosineDistance(x: BitArray, y: BitArray): number {\n  return 1 - cosineSimilarity(x, y);\n}\n\nexport function euclideanSimilarity(x: BitArray, y: BitArray): number {\n  return getSimilarityFromDistance(euclideanDistance(x, y));\n}\n\nexport function euclideanDistance(x: BitArray, y: BitArray): number {\n  return Math.sqrt(x.trueCount() + y.trueCount() - 2 * x.andWithCountBits(y, true));\n}\n\nexport function hammingSimilarity(x: BitArray, y: BitArray): number {\n  return getSimilarityFromDistance(hammingDistance(x, y));\n}\n\nexport function hammingDistance(x: BitArray, y: BitArray): number {\n  return x.trueCount() + y.trueCount() - 2 * x.andWithCountBits(y, true);\n}\n\nexport function sokalSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const common = x.andWithCountBits(y, true);\n  return common / (2 * total - 3 * common);\n}\n\nexport function sokalDistance(x: BitArray, y: BitArray): number {\n  return 1 - sokalSimilarity(x, y);\n}\n\nexport function kulczynskiSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const totalProd = x.trueCount() * y.trueCount();\n  if (totalProd == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return (common * total) / (2 * totalProd);\n}\n\nexport function kulczynskiDistance(x: BitArray, y: BitArray): number {\n  return getDistanceFromSimilarity(kulczynskiSimilarity(x, y));\n}\n\nexport function mcConnaugheySimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const totalProd = x.trueCount() * y.trueCount();\n  if (totalProd == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return (common * total - totalProd) / totalProd;\n}\n\nexport function mcConnaugheyDistance(x: BitArray, y: BitArray): number {\n  return getDistanceFromSimilarity(mcConnaugheySimilarity(x, y));\n}\n\nexport function asymmetricSimilarity(x: BitArray, y: BitArray): number {\n  const min = Math.min(x.trueCount(), y.trueCount());\n  if (min == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / min;\n}\n\nexport function asymmetricDistance(x: BitArray, y: BitArray): number {\n  return 1 - asymmetricSimilarity(x, y);\n}\n\nexport function braunBlanquetSimilarity(x: BitArray, y: BitArray): number {\n  const max = Math.max(x.trueCount(), y.trueCount());\n  if (max == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / max;\n}\n\nexport function braunBlanquetDistance(x: BitArray, y: BitArray): number {\n  return getDistanceFromSimilarity(braunBlanquetSimilarity(x, y));\n}\n\nexport function russelSimilarity(x: BitArray, y: BitArray): number {\n  if (x.length == 0) return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / x.length;\n}\n\nexport function russelDistance(x: BitArray, y: BitArray): number {\n  return getDistanceFromSimilarity(russelSimilarity(x, y));\n}\n\nexport function rogotGoldbergSimilarity(x: BitArray, y: BitArray): number {\n  const common = x.andWithCountBits(y, true);\n  const total = x.countBits(true) + y.countBits(true);\n  const len = x.length;\n  const diff = len - total + common;\n  if ((common == len) || (diff == len)) return 1.0;\n  else return common / total + diff / (2 * len - total);\n}\n\nexport function rogotGoldbergDistance(x: BitArray, y: BitArray): number {\n  return getDistanceFromSimilarity(rogotGoldbergSimilarity(x, y));\n}\n\nexport function getSimilarityFromDistance(distance: number) {\n  return 1 / (1 + distance);\n}\n\nexport function getDistanceFromSimilarity(similarity: number) { //in case similarity is 0, use max number for float32\n  return similarity === 0 ? 3.402823E+38 : (1 / similarity) - 1;\n}\n\nexport function numericDistance(args?: {range?: number}) {\n  if (args && args.range != undefined && args.range > 0) {\n    const range = args.range;\n    return (a: number, b: number) => Math.abs(a - b) / range;\n  }\n\n  return (a: number, b: number) => Math.abs(a - b);\n}\n\nexport function commonItemsCount(args?: {mostCommon?: Set<number>}) {\n  const mostCommon = args?.mostCommon ?? new Set<number>();\n  return (arr1: ArrayLike<number>, arr2: ArrayLike<number>) => {\n    const len1 = arr1.length;\n    const len2 = arr2.length;\n    let count = 0;\n    let i1 = 0;\n    let i2 = 0;\n\n    while ((i1 < len1) && (i2 < len2)) {\n      if (arr1[i1] === arr2[i2]) {\n        if (!mostCommon?.has(arr1[i1]))\n          ++count;\n        ++i1;\n        ++i2;\n      } else if (arr1[i1] < arr2[i2]) { ++i1; } else { ++i2; }\n    }\n\n    return count;\n  };\n}\n\nexport function inverseCommonItemsCount(args?: {mostCommon?: Set<number>}) {\n  const f = commonItemsCount(args);\n  return (arr1: ArrayLike<number>, arr2: ArrayLike<number>) => {\n    if (arr2.length === 0 || arr1.length === 0)\n      return 10000;\n\n    return Math.min(arr1.length, arr2.length) / (f(arr1, arr2) + 0.0001);\n  };\n}\n"]}","import '../types/helm';\n// core fields of HELM library object used in toAtomicLevel function\nexport const HELM_CORE_FIELDS = [\n    \"symbol\" /* HELM_FIELDS.SYMBOL */,\n    \"molfile\" /* HELM_FIELDS.MOLFILE */,\n    \"rgroups\" /* HELM_FIELDS.RGROUPS */,\n    \"name\" /* HELM_FIELDS.NAME */,\n    // HELM_FIELDS.MONOMER_TYPE, // add if terminal monomers for PEPTIDEs to be\n    // supported\n];\nexport const SDF_MONOMER_NAME = 'MonomerName';\n// todo: ideally, keys should be expressed via constants\nexport const jsonSdfMonomerLibDict = {\n    'monomerType': null,\n    'smiles': null,\n    'name': 'Name',\n    'author': null,\n    'molfile': 'molecule',\n    'naturalAnalog': 'MonomerNaturalAnalogCode',\n    'rgroups': 'MonomerCaps',\n    'createDate': null,\n    'id': null,\n    'polymerType': 'MonomerType',\n    'symbol': 'MonomerName'\n};\nexport const DUMMY_MONOMER = {\n    'monomerType': 'Backbone',\n    'smiles': '',\n    'name': '',\n    'author': 'Datagrok',\n    'molfile': '',\n    'naturalAnalog': '',\n    'rgroups': [],\n    'createDate': null,\n    'id': 0,\n    'polymerType': 'PEPTIDE',\n    'symbol': ''\n};\n// range of hex nubers used in PepSea library to endode monomers\nexport const MONOMER_ENCODE_MIN = 0x100;\nexport const MONOMER_ENCODE_MAX = 0x40A;\nexport const RIBOSE_SYMBOL = 'r';\nexport const DEOXYRIBOSE_SYMBOL = 'd';\nexport const PHOSPHATE_SYMBOL = 'p';\nexport const HELM_WRAPPERS_REGEXP = new RegExp(`[${RIBOSE_SYMBOL}${DEOXYRIBOSE_SYMBOL}]\\\\((\\\\w)\\\\)${PHOSPHATE_SYMBOL}?`, 'g');\n//# sourceMappingURL=const.js.map","/** Canonical gap symbol */\nexport const GAP_SYMBOL = '';\n/** Alphabet candidate type */\nexport class CandidateType {\n    constructor(name, alphabet, cutoff) {\n        this.name = name;\n        this.alphabet = alphabet;\n        this.cutoff = cutoff;\n    }\n}\n/** Alphabet candidate similarity type */\nexport class CandidateSimType extends CandidateType {\n    constructor(candidate, freq, similarity) {\n        super(candidate.name, candidate.alphabet, candidate.cutoff);\n        this.freq = freq;\n        this.similarity = similarity;\n    }\n}\n//# sourceMappingURL=types.js.map","import { CandidateType } from './types';\n/** enum type to simplify setting \"user-friendly\" notation if necessary */\nexport var NOTATION;\n(function (NOTATION) {\n    NOTATION[\"FASTA\"] = \"fasta\";\n    NOTATION[\"SEPARATOR\"] = \"separator\";\n    NOTATION[\"HELM\"] = \"helm\";\n})(NOTATION || (NOTATION = {}));\nexport var ALPHABET;\n(function (ALPHABET) {\n    ALPHABET[\"DNA\"] = \"DNA\";\n    ALPHABET[\"RNA\"] = \"RNA\";\n    ALPHABET[\"PT\"] = \"PT\";\n    /** Unknown */\n    ALPHABET[\"UN\"] = \"UN\";\n})(ALPHABET || (ALPHABET = {}));\nexport var TAGS;\n(function (TAGS) {\n    TAGS[\"aligned\"] = \"aligned\";\n    TAGS[\"alphabet\"] = \"alphabet\";\n    TAGS[\"alphabetSize\"] = \".alphabetSize\";\n    TAGS[\"alphabetIsMultichar\"] = \".alphabetIsMultichar\";\n    TAGS[\"separator\"] = \"separator\";\n    TAGS[\"isHelmCompatible\"] = \".isHelmCompatible\";\n    TAGS[\"positionNames\"] = \".positionNames\";\n    TAGS[\"positionLabels\"] = \".positionLabels\";\n    TAGS[\"regions\"] = \".regions\";\n})(TAGS || (TAGS = {}));\nexport const positionSeparator = ', ';\nexport const monomerRe = /(?:\\[([A-Za-z0-9_\\-,()]+)\\])|([A-Za-z\\-])/g;\nexport const helmRe = /(PEPTIDE1|DNA1|RNA1)\\{([^}]+)}/g;\nexport const helmPp1Re = /\\[([^\\[\\]]+)]/g;\nexport const Alphabets = new class {\n    constructor() {\n        this.fasta = {\n            peptide: new Set([\n                'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',\n                'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',\n            ]),\n            dna: new Set(['A', 'C', 'G', 'T']),\n            rna: new Set(['A', 'C', 'G', 'U']),\n        };\n    }\n}();\nexport const candidateAlphabets = [\n    new CandidateType(ALPHABET.PT, Alphabets.fasta.peptide, 0.50),\n    new CandidateType(ALPHABET.DNA, Alphabets.fasta.dna, 0.55),\n    new CandidateType(ALPHABET.RNA, Alphabets.fasta.rna, 0.55),\n];\n//# sourceMappingURL=consts.js.map","const __WEBPACK_NAMESPACE_OBJECT__ = wu;","/**\n * Denotes a vector of floating poit values.\n *\n * @export\n * @class Vector\n * @extends {Float32Array}\n */\nexport class Vector extends Float32Array {\n}\n/**\n * Denotes a two-dimensional matrix.\n *\n * @export\n * @class Matrix\n * @extends {Array<Vector>}\n */\nexport class Matrix extends Array {\n}\n/**\n * Denotes cartesian coordinates.\n *\n * @export\n * @class Coordinates\n * @extends {Matrix}\n */\nexport class Coordinates extends Matrix {\n}\n/**\n * Denotes an array of arbitrary-typed vectors.\n *\n * @export\n * @class Vectors\n * @extends {Array<any>}\n */\nexport class Vectors extends Array {\n}\n//# sourceMappingURL=data:application/json;base64,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","export class SeqPaletteBase {\n    static makePalette(dt, simplified = false, PaletteType = SeqPaletteBase) {\n        const palette = {};\n        dt.forEach((cp) => {\n            const objList = cp[0];\n            const colour = cp[1];\n            objList.forEach((obj, ind) => {\n                palette[obj] = this.colourPalette[colour][simplified ? 0 : ind];\n            });\n        });\n        return new PaletteType(palette);\n    }\n    constructor(palette) {\n        this._palette = palette;\n    }\n    get(m) {\n        return this._palette[m];\n    }\n}\nSeqPaletteBase.undefinedColor = 'rgb(100,100,100)';\n/** Palette with shades of primary colors */\nSeqPaletteBase.colourPalette = {\n    'orange': ['rgb(255,187,120)', 'rgb(245,167,100)', 'rgb(235,137,70)', 'rgb(205, 111, 71)'],\n    'all_green': ['rgb(44,160,44)', 'rgb(74,160,74)', 'rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)',\n        'rgb(24,110,79)', 'rgb(152,223,138)', 'rgb(182, 223, 138)', 'rgb(152, 193, 138)'],\n    'all_blue': ['rgb(31,119,180)', 'rgb(23,190,207)', 'rgb(122, 102, 189)', 'rgb(158,218,229)', 'rgb(141, 124, 217)',\n        'rgb(31, 120, 150)'],\n    'magenta': ['rgb(162,106,192)', 'rgb(197,165,224)', 'rgb(208,113,218)'],\n    'red': ['rgb(214,39,40)', 'rgb(255,152,150)'],\n    'st_blue': ['rgb(23,190,207)', 'rgb(158,218,229)', 'rgb(31,119,180)'],\n    'dark_blue': ['rgb(31,119,180)', 'rgb(31, 120, 150)'],\n    'light_blue': ['rgb(23,190,207)', 'rgb(158,218,229)', 'rgb(108, 218, 229)', 'rgb(23,190,227)'],\n    'lilac_blue': ['rgb(124,102,211)', 'rgb(149,134,217)', 'rgb(97, 81, 150)'],\n    'dark_green': ['rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)', 'rgb(24,110,79)'],\n    'green': ['rgb(44,160,44)', 'rgb(74,160,74)'],\n    'light_green': ['rgb(152,223,138)', 'rgb(182, 223, 138)', 'rgb(152, 193, 138)'],\n    'st_green': ['rgb(44,160,44)', 'rgb(152,223,138)', 'rgb(39, 174, 96)', 'rgb(74,160,74)'],\n    'pink': ['rgb(247,182,210)'],\n    'brown': ['rgb(140,86,75)', 'rgb(102, 62, 54)'],\n    'gray': ['rgb(127,127,127)', 'rgb(199,199,199)', 'rgb(196,156,148)', 'rgb(222, 222, 180)'],\n    'yellow': ['rgb(188,189,34)'],\n    'white': ['rgb(230,230,230)'],\n};\n//# sourceMappingURL=seq-palettes.js.map","import { SeqPaletteBase } from './seq-palettes';\nexport class AminoacidsPalettes extends SeqPaletteBase {\n    static get Lesk() {\n        if (this.lesk === void 0) {\n            this.lesk = this.makePalette([\n                [['G', 'A', 'S', 'T'], 'orange'],\n                [['C', 'V', 'I', 'L', 'P', 'F', 'Y', 'M', 'W'], 'all_green'],\n                [['N', 'Q', 'H'], 'magenta'],\n                [['D', 'E'], 'red'],\n                [['K', 'R'], 'all_blue'],\n            ], false, AminoacidsPalettes);\n        }\n        return this.lesk;\n    }\n    static get GrokGroups() {\n        if (this.grokGroups === void 0) {\n            this.grokGroups = this.makePalette([\n                [['C', 'U'], 'yellow'],\n                [['G', 'P'], 'red'],\n                [['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'], 'all_green'],\n                [['R', 'H', 'K'], 'light_blue'],\n                [['D', 'E'], 'dark_blue'],\n                [['S', 'T', 'N', 'Q'], 'orange'],\n            ], false, AminoacidsPalettes);\n        }\n        return this.grokGroups;\n    }\n    static get RasMol() {\n        if (this.rasMol === void 0) {\n            this.rasMol = new AminoacidsPalettes({\n                // http://acces.ens-lyon.fr/biotic/rastop/help/colour.htm\n                'D': '#E60A0A',\n                'E': '#E60A0A',\n                'C': '#E6E600',\n                'M': '#E6E600',\n                'K': '#145AFF',\n                'R': '#145AFF',\n                'S': '#FA9600',\n                'T': '#FA9600',\n                'F': '#3232AA',\n                'Y': '#3232AA',\n                'N': '#00DCDC',\n                'Q': '#00DCDC',\n                'G': '#EBEBEB',\n                'L': '#0F820F',\n                'V': '#0F820F',\n                'I': '#0F820F',\n                'A': '#C8C8C8',\n                'W': '#B45AB4',\n                'H': '#8282D2',\n                'P': '#DC9682',\n                'others': '#BEA06E',\n            });\n        }\n        return this.rasMol;\n    }\n    get(m) {\n        const resM = m in AminoacidsPalettes.aaSynonyms ? AminoacidsPalettes.aaSynonyms[m] : m;\n        const res = super.get(resM);\n        return res;\n    }\n}\n/** Only some of the synonyms. These were obtained from the clustered oligopeptide dataset. */\nAminoacidsPalettes.aaSynonyms = {\n    'MeNle': 'L',\n    'MeA': 'A',\n    'MeG': 'G',\n    'MeF': 'F',\n};\nexport class Aminoacids {\n    static getPalette(scheme = 'grok') {\n        switch (scheme) {\n            case 'grok':\n                return AminoacidsPalettes.GrokGroups;\n            case 'lesk':\n                return AminoacidsPalettes.Lesk;\n            default:\n                throw new Error(`ChemPalette: scheme \\`${scheme}\\` does not exist`);\n        }\n    }\n    /**\n     * Returns divided amino acid with its content in the bracket, if the content is number, then its omitted\n     *\n     * @param {string} c raw amino\n     * @return {[string, string]} outer and inner content\n     */\n    static getInnerOuter(c) {\n        let isInner = 0;\n        let inner = '';\n        let outer = '';\n        for (const char of c) {\n            if (char == '(')\n                isInner++;\n            else if (char == ')')\n                isInner--;\n            else if (isInner)\n                inner += char;\n            else\n                outer += char;\n        }\n        return !isNaN(parseInt(inner)) ? [outer, ''] : [outer, inner];\n    }\n    static getColorAAPivot(monomer = '', scheme = 'grok') {\n        //const chemPaletteInstance = AAPalettes.GrokGroups();\n        const chemPaletteInstance = this.getPalette(scheme);\n        let [outerMonomer, innerMonomer] = this.getInnerOuter(monomer);\n        outerMonomer = (outerMonomer.length > 6 ? `${outerMonomer.slice(0, 3)}...` : outerMonomer);\n        innerMonomer = (innerMonomer.length > 6 ? `${innerMonomer.slice(0, 3)}...` : innerMonomer);\n        if (monomer.length == 1 || monomer[1] == '(') {\n            const amino = monomer[0]?.toUpperCase();\n            return amino in chemPaletteInstance ?\n                [chemPaletteInstance.get(amino), amino, innerMonomer, 1] :\n                [this.undefinedColor, outerMonomer, innerMonomer, 1];\n        }\n        if (monomer[0] == 'd' && monomer[1] in chemPaletteInstance) {\n            if (monomer.length == 2 || monomer[2] == '(') {\n                const amino = monomer[1]?.toUpperCase();\n                return amino in chemPaletteInstance ?\n                    [chemPaletteInstance.get(amino), amino, innerMonomer, 2] :\n                    [this.undefinedColor, outerMonomer, innerMonomer, 2];\n            }\n        }\n        if (monomer.substring(0, 3) in this.AAFullNames) {\n            if (monomer.length == 3 || monomer[3] == '(') {\n                const amino = this.AAFullNames[monomer.substring(0, 3)];\n                return amino in chemPaletteInstance ?\n                    [chemPaletteInstance.get(amino), amino, innerMonomer, 3] :\n                    [this.undefinedColor, outerMonomer, innerMonomer, 3];\n            }\n        }\n        if (monomer[0]?.toLowerCase() == monomer[0]) {\n            if (monomer.substring(1, 3) in this.AAFullNames) {\n                if (monomer.length == 4 || monomer[4] == '(') {\n                    const amino = this.AAFullNames[monomer.substring(1, 3)];\n                    return amino in chemPaletteInstance ?\n                        [chemPaletteInstance.get(amino), amino, innerMonomer, 4] :\n                        [this.undefinedColor, outerMonomer, innerMonomer, 4];\n                }\n            }\n        }\n        return [this.undefinedColor, outerMonomer, innerMonomer, 0];\n    }\n}\nAminoacids.SemType = 'Aminoacids';\nAminoacids.SemTypeMultipleAlignment = 'AminoacidsMultipleAlignment';\nAminoacids.undefinedColor = 'rgb(100,100,100)';\nAminoacids.Names = {\n    'G': 'Glycine',\n    'L': 'Leucine',\n    'Y': 'Tyrosine',\n    'S': 'Serine',\n    'E': 'Glutamic acid',\n    'Q': 'Glutamine',\n    'D': 'Aspartic acid',\n    'N': 'Asparagine',\n    'F': 'Phenylalanine',\n    'A': 'Alanine',\n    'K': 'Lysine',\n    'R': 'Arginine',\n    'H': 'Histidine',\n    'C': 'Cysteine',\n    'V': 'Valine',\n    'P': 'Proline',\n    'W': 'Tryptophan',\n    'I': 'Isoleucine',\n    'M': 'Methionine',\n    'T': 'Threonine',\n};\nAminoacids.AASmiles = {\n    'G': 'NCC(=O)O',\n    'L': 'N[C@H](CC(C)C)C(=O)O',\n    'Y': 'NC(CC1=CC=C(O)C=C1)C(=O)O',\n    'S': 'NC(CO)C(=O)O',\n    'E': 'N[C@@H](CCC(O)=O)C(=O)O',\n    'Q': 'N[C@@H](CCC(N)=O)C(=O)O',\n    'D': 'N[C@@H](CC(O)=O)C(=O)O',\n    'N': 'N[C@@H](CC(N)=O)C(=O)O',\n    'F': 'NC(CC1=CC=CC=C1)C(=O)O',\n    'A': 'N[C@H](C)C(=O)O',\n    'K': 'NC(CCCCN)C(=O)O',\n    'R': 'N[C@H](CCCNC(=N)C)C(=O)O',\n    'H': 'NC(CC1=CN=C[N]1)C(=O)O',\n    'C': 'N[C@@H](CS)C(=O)O',\n    'V': 'NC(C(C)C)C(=O)O',\n    'P': 'N(CCC1)C1C(=O)O',\n    'W': 'N[C@@H](Cc1c2ccccc2n([H])c1)C(=O)O',\n    'I': 'N[C@H]([C@H](C)CC)C(=O)O',\n    'M': 'NC(CCSC)C(=O)O',\n    'T': 'NC(C(O)C)C(=O)O',\n};\nAminoacids.AASmilesTruncated = {\n    'G': '*C*',\n    'L': 'CC(C)C[C@H](*)*',\n    'Y': 'C1=CC(=CC=C1CC(*)*)O',\n    'S': 'OCC(*)C*',\n    'E': '*[C@@H](CCC(O)=O)*',\n    'Q': '*N[C@@H](CCC(N)=O)*',\n    'D': '*[C@@H](CC(O)=O)*',\n    'N': '*[C@@H](CC(N)=O)*',\n    'F': 'C1=CC=C(C=C1)CC(*)*',\n    'A': 'C[C@H](*)*',\n    'K': 'C(CCN)CC(*)*',\n    'R': '*[C@H](CCCNC(=N)C)*',\n    'H': 'C1=C(NC=N1)CC(*)*',\n    'C': 'C([C@@H](*)*)S',\n    'V': 'CC(C)C(*)*',\n    'P': 'C1CCN(*)C1*',\n    'W': '*[C@@H](Cc1c2ccccc2n([H])c1)*',\n    'I': 'CC[C@H](C)[C@H](*)*',\n    'M': 'CSCCC(*)*',\n    'T': 'CC(O)C(*)*',\n};\n/** TODO: Full?\n */\nAminoacids.AAFullNames = {\n    'Ala': 'A',\n    'Arg': 'R',\n    'Asn': 'N',\n    'Asp': 'D',\n    'Cys': 'C',\n    'Gln': 'Q',\n    'Glu': 'E',\n    'Gly': 'G',\n    'His': 'H',\n    'Ile': 'I',\n    'Leu': 'L',\n    'Lys': 'K',\n    'Met': 'M',\n    'Phe': 'F',\n    'Pro': 'P',\n    'Ser': 'S',\n    'Thr': 'T',\n    'Trp': 'W',\n    'Tyr': 'Y',\n    'Val': 'V',\n};\n//# sourceMappingURL=aminoacids.js.map","import { SeqPaletteBase } from './seq-palettes';\nexport class NucleotidesPalettes extends SeqPaletteBase {\n    static get Chromatogram() {\n        if (this.chromatogram === void 0) {\n            this.chromatogram = new NucleotidesPalettes({\n                'A': 'green',\n                'C': 'blue',\n                'G': 'black',\n                'T': 'red',\n                'U': 'red',\n                'others': 'gray',\n            });\n        }\n        return this.chromatogram;\n    }\n}\nexport class Nucleotides {\n}\nNucleotides.SemType = 'Nucleotides';\nNucleotides.SemTypeMultipleAlignment = 'NucleotidesMultipleAlignment';\nNucleotides.Names = {\n    'A': 'Adenine',\n    'C': 'Cytosine',\n    'G': 'Guanine',\n    'T': 'Thymine',\n    'U': 'Uracil',\n};\n//# sourceMappingURL=nucleotides.js.map","import * as DG from 'datagrok-api/dg';\n/** makes the color less white, makes the transparency effect always perceptible\n * @param {string} color x coordinate.\n * */\nfunction correctColor(color) {\n    if (color == null)\n        return 'rgb(100,100,100)';\n    const dgColor = DG.Color.fromHtml(color);\n    const g = DG.Color.g(dgColor);\n    const r = DG.Color.r(dgColor);\n    const b = DG.Color.b(dgColor);\n    // calculate euclidean distance to white\n    const distToBlack = Math.sqrt(Math.pow(0 - r, 2) + Math.pow(0 - g, 2) + Math.pow(0 - b, 2));\n    // normalize vector r g b\n    const normR = r / distToBlack;\n    const normG = g / distToBlack;\n    const normB = b / distToBlack;\n    if (distToBlack > 210) {\n        return `rgb(${normR * 210},${normG * 210},${normB * 210})`;\n    }\n    return DG.Color.toRgb(dgColor);\n}\nexport class StringUtils {\n    static hashCode(s) {\n        let hash = 0;\n        if (s.length === 0)\n            return hash;\n        for (let i = 0; i < s.length; i++) {\n            const chr = s.charCodeAt(i);\n            hash = ((hash << 5) - hash) + chr;\n            hash |= 0; // Convert to 32bit integer\n        }\n        return hash;\n    }\n}\nimport { SeqPaletteBase } from './seq-palettes';\nexport class UnknownSeqPalette {\n}\nexport class GrayAllPalette extends UnknownSeqPalette {\n    get(m) {\n        return '#666666';\n    }\n}\nexport class UnknownColorPalette extends UnknownSeqPalette {\n    static buildPalette() {\n        const res = [].concat(...Object.values(SeqPaletteBase.colourPalette));\n        return res;\n    }\n    get(m) {\n        const hash = StringUtils.hashCode(m);\n        const pI = hash % UnknownColorPalette.palette.length;\n        return correctColor(UnknownColorPalette.palette[pI]);\n    }\n}\nUnknownColorPalette.palette = UnknownColorPalette.buildPalette();\nexport class UnknownSeqPalettes extends SeqPaletteBase {\n    static get Gray() {\n        if (this.gray === void 0)\n            this.gray = new GrayAllPalette();\n        return this.gray;\n    }\n    static get Color() {\n        if (this.color === void 0)\n            this.color = new UnknownColorPalette();\n        return this.color;\n    }\n}\n//# sourceMappingURL=unknown.js.map","import * as DG from 'datagrok-api/dg';\nimport wu from 'wu';\nimport { TAGS, ALPHABET, NOTATION, candidateAlphabets, positionSeparator, splitterAsFasta, getSplitterWithSeparator, splitterAsHelm, } from './macromolecule';\nimport { GAP_SYMBOL, } from './macromolecule/types';\nimport { detectAlphabet, splitterAsFastaSimple, StringListSeqSplitted } from './macromolecule/utils';\nimport { mmDistanceFunctions, MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';\nimport { getMonomerLibHelper } from '../monomer-works/monomer-utils';\nimport { HELM_WRAPPERS_REGEXP, PHOSPHATE_SYMBOL } from './const';\nexport const SeqTemps = new class {\n    constructor() {\n        /** Column's temp slot name for a SeqHandler object */\n        this.seqHandler = `seq-handler`;\n        this.notationProvider = `seq-handler.notation-provider`;\n    }\n}();\nexport const GapOriginals = {\n    [NOTATION.FASTA]: '-',\n    [NOTATION.SEPARATOR]: '',\n    [NOTATION.HELM]: '*',\n};\n/** Class for handling notation units in Macromolecule columns and\n * conversion of notation systems in Macromolecule columns\n */\nexport class SeqHandler {\n    constructor(col) {\n        this._splitter = null;\n        this.cached = true;\n        this._splitted = null;\n        this.columnVersion = null;\n        this._stats = null;\n        this._maxLength = null;\n        this._posList = null;\n        this._joiner = undefined;\n        if (col.type !== DG.TYPE.STRING)\n            throw new Error(`Unexpected column type '${col.type}', must be '${DG.TYPE.STRING}'.`);\n        this._column = col;\n        const units = this._column.getTag(DG.TAGS.UNITS);\n        if (units !== null && units !== undefined)\n            this._units = units;\n        else\n            throw new Error('Units are not specified in column');\n        this._notation = this.getNotation();\n        this._defaultGapOriginal = (this.isFasta()) ? GapOriginals[NOTATION.FASTA] :\n            (this.isHelm()) ? GapOriginals[NOTATION.HELM] :\n                GapOriginals[NOTATION.SEPARATOR];\n        if (!this.column.tags.has(TAGS.aligned) || !this.column.tags.has(TAGS.alphabet) ||\n            (!this.column.tags.has(TAGS.alphabetIsMultichar) && !this.isHelm() && this.alphabet === ALPHABET.UN)) {\n            // The following detectors and setters are to be called because the column is likely\n            // as the UnitsHandler constructor was called on the column.\n            if (this.isFasta())\n                SeqHandler.setUnitsToFastaColumn(this);\n            else if (this.isSeparator()) {\n                const separator = col.getTag(TAGS.separator);\n                SeqHandler.setUnitsToSeparatorColumn(this, separator);\n            }\n            else if (this.isHelm())\n                SeqHandler.setUnitsToHelmColumn(this);\n            else\n                throw new Error(`Unexpected units '${this.column.getTag(DG.TAGS.UNITS)}'.`);\n        }\n        // if (!this.column.tags.has(TAGS.alphabetSize)) {\n        //   if (this.isHelm())\n        //     throw new Error(`For column '${this.column.name}' of notation '${this.notation}' ` +\n        //       `tag '${TAGS.alphabetSize}' is mandatory.`);\n        //   else if (['UN'].includes(this.alphabet))\n        //     throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +\n        //       `tag '${TAGS.alphabetSize}' is mandatory.`);\n        // }\n        if (!this.column.tags.has(TAGS.alphabetIsMultichar)) {\n            if (this.isHelm())\n                this.column.setTag(TAGS.alphabetIsMultichar, 'true');\n            else if (['UN'].includes(this.alphabet)) {\n                throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +\n                    `tag '${TAGS.alphabetIsMultichar}' is mandatory.`);\n            }\n        }\n        this.notationProvider = this.column.temp[SeqTemps.notationProvider] ?? null;\n        this.columnVersion = this.column.version;\n    }\n    static setUnitsToFastaColumn(uh) {\n        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.getTag(DG.TAGS.UNITS) !== NOTATION.FASTA)\n            throw new Error(`The column of notation '${NOTATION.FASTA}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);\n        uh.column.setTag(DG.TAGS.UNITS, NOTATION.FASTA);\n        SeqHandler.setTags(uh);\n    }\n    static setUnitsToSeparatorColumn(uh, separator) {\n        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.getTag(DG.TAGS.UNITS) !== NOTATION.SEPARATOR)\n            throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);\n        if (!separator)\n            throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must have the separator tag.`);\n        uh.column.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);\n        uh.column.setTag(TAGS.separator, separator);\n        SeqHandler.setTags(uh);\n    }\n    static setUnitsToHelmColumn(uh) {\n        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE)\n            throw new Error(`The column of notation '${NOTATION.HELM}' must be '${DG.SEMTYPE.MACROMOLECULE}'`);\n        uh.column.setTag(DG.TAGS.UNITS, NOTATION.HELM);\n        SeqHandler.setTags(uh);\n    }\n    /** From detectMacromolecule */\n    static setTags(uh) {\n        const units = uh.column.getTag(DG.TAGS.UNITS);\n        if ([NOTATION.FASTA, NOTATION.SEPARATOR].includes(units)) {\n            // Empty monomer alphabet is allowed, only if alphabet tag is annotated\n            if (!uh.column.getTag(TAGS.alphabet) && Object.keys(uh.stats.freq).length === 0)\n                throw new Error('Alphabet is empty and not annotated.');\n            let aligned = uh.column.getTag(TAGS.aligned);\n            if (aligned === null) {\n                aligned = uh.stats.sameLength ? \"SEQ.MSA\" /* ALIGNMENT.SEQ_MSA */ : \"SEQ\" /* ALIGNMENT.SEQ */;\n                uh.column.setTag(TAGS.aligned, aligned);\n            }\n            let alphabet = uh.column.getTag(TAGS.alphabet);\n            if (alphabet === null) {\n                alphabet = detectAlphabet(uh.stats.freq, candidateAlphabets);\n                uh.column.setTag(TAGS.alphabet, alphabet);\n            }\n            if (alphabet === ALPHABET.UN) {\n                const alphabetSize = Object.keys(uh.stats.freq).length;\n                const alphabetIsMultichar = Object.keys(uh.stats.freq).some((m) => m.length > 1);\n                uh.column.setTag(TAGS.alphabetSize, alphabetSize.toString());\n                uh.column.setTag(TAGS.alphabetIsMultichar, alphabetIsMultichar ? 'true' : 'false');\n            }\n        }\n    }\n    get column() { return this._column; }\n    get length() { return this._column.length; }\n    get units() { return this._units; }\n    get notation() { return this._notation; }\n    get defaultGapOriginal() { return this._defaultGapOriginal; }\n    get separator() {\n        const separator = this.column.getTag(TAGS.separator) ?? undefined;\n        if (this.notation === NOTATION.SEPARATOR && separator === undefined)\n            throw new Error(`Separator is mandatory  for column '${this.column.name}' of notation '${this.notation}'.`);\n        return separator;\n    }\n    get aligned() {\n        const aligned = this.column.getTag(TAGS.aligned);\n        // TAGS.aligned is mandatory for columns of NOTATION.FASTA and NOTATION.SEPARATOR\n        if (!aligned && (this.isFasta() || this.isSeparator()))\n            throw new Error('Tag aligned not set');\n        return aligned;\n    }\n    /** Alphabet name (upper case) */\n    get alphabet() {\n        const alphabet = this.column.getTag(TAGS.alphabet);\n        // TAGS.alphabet is mandatory for columns of NOTATION.FASTA and NOTATION.SEPARATOR\n        if (!alphabet && (this.isFasta() || this.isSeparator()))\n            throw new Error('Tag alphabet not set');\n        return alphabet;\n    }\n    get helmCompatible() {\n        return this.column.getTag(TAGS.isHelmCompatible);\n    }\n    getAlphabetSize() {\n        if (this.notation == NOTATION.HELM || this.alphabet == ALPHABET.UN) {\n            const alphabetSizeStr = this.column.getTag(TAGS.alphabetSize);\n            let alphabetSize;\n            if (alphabetSizeStr)\n                alphabetSize = parseInt(alphabetSizeStr);\n            else {\n                // calculate alphabetSize on demand\n                const stats = this.stats;\n                alphabetSize = Object.keys(stats.freq).length;\n            }\n            return alphabetSize;\n        }\n        else {\n            switch (this.alphabet) {\n                case ALPHABET.PT:\n                    return 20;\n                case ALPHABET.DNA:\n                case ALPHABET.RNA:\n                    return 4;\n                case 'NT':\n                    console.warn(`Unexpected alphabet 'NT'.`);\n                    return 4;\n                default:\n                    throw new Error(`Unexpected alphabet '${this.alphabet}'.`);\n            }\n        }\n    }\n    getAlphabetIsMultichar() {\n        if (this.notation === NOTATION.HELM)\n            return true;\n        else if (this.alphabet !== ALPHABET.UN)\n            return false;\n        else\n            return this.column.getTag(TAGS.alphabetIsMultichar) === 'true';\n    }\n    // /** */\n    // public get splitted(): ISeqSplitted[] {\n    //   // TODO: Disable cache or invalidate on changing data\n    //   if (this._splitted === null) {\n    //     const splitter = this.splitter;\n    //     const colLength: number = this._column.length;\n    //     this._splitted = new Array(colLength);\n    //     const catIdxList = this._column.getRawData();\n    //     const catList: string[] = this._column.categories;\n    //     for (let rowIdx: number = 0; rowIdx < colLength; rowIdx++) {\n    //       const seq: string = catList[catIdxList[rowIdx]];\n    //       this._splitted[rowIdx] = splitter(seq);\n    //     }\n    //   }\n    //   return this._splitted;\n    // }\n    getSplitted(rowIdx, limit) {\n        if (!this.cached || limit !== undefined) {\n            const seq = this.column.get(rowIdx);\n            return this.getSplitter(limit)(seq);\n        }\n        else {\n            if (this.column.version !== this.columnVersion || this._splitted === null) {\n                this.columnVersion = this.column.version;\n                this._splitted = new Array(this.column.length);\n            }\n            let resSS = this._splitted[rowIdx] ? this._splitted[rowIdx].deref() : undefined;\n            if (!resSS) {\n                const seq = this.column.get(rowIdx);\n                resSS = this.splitter(seq);\n                this._splitted[rowIdx] = new WeakRef(resSS);\n            }\n            return resSS;\n        }\n    }\n    get stats() {\n        if (this._stats === null) {\n            const freq = {};\n            let sameLength = true;\n            let firstLength = null;\n            const colLen = this.column.length;\n            for (let rowIdx = 0; rowIdx < colLen; ++rowIdx) {\n                const mSeq = this.getSplitted(rowIdx);\n                if (firstLength == null)\n                    firstLength = mSeq.length;\n                else if (mSeq.length !== firstLength)\n                    sameLength = false;\n                for (const cm of mSeq.canonicals) {\n                    if (!(cm in freq))\n                        freq[cm] = 0;\n                    freq[cm] += 1;\n                }\n            }\n            this._stats = { freq: freq, sameLength: sameLength };\n        }\n        return this._stats;\n    }\n    get maxLength() {\n        if (this._maxLength === null) {\n            this._maxLength = this.column.length === 0 ? 0 :\n                Math.max(...wu.count(0).take(this.column.length).map((rowIdx) => this.getSplitted(rowIdx).length));\n        }\n        return this._maxLength;\n    }\n    get posList() {\n        if (this._posList === null) {\n            const posListTxt = this.column.getTag(TAGS.positionNames);\n            this._posList = posListTxt ? posListTxt.split(positionSeparator).map((p) => p.trim()) :\n                wu.count(1).take(this.maxLength).map((pos) => pos.toString()).toArray();\n        }\n        return this._posList;\n    }\n    isFasta() { return this.notation === NOTATION.FASTA; }\n    isSeparator() { return this.notation === NOTATION.SEPARATOR; }\n    isHelm() { return this.notation === NOTATION.HELM; }\n    isRna() { return this.alphabet === ALPHABET.RNA; }\n    isDna() { return this.alphabet === ALPHABET.DNA; }\n    isPeptide() { return this.alphabet === ALPHABET.PT; }\n    isMsa() { return this.aligned ? this.aligned.toUpperCase().includes('MSA') : false; }\n    isHelmCompatible() { return this.helmCompatible === 'true'; }\n    /** Checks {@link om} for being a gap\n     * @param {string} om Original monomer of sequence symbol\n     * @return {boolean}\n     */\n    isGap(om) {\n        return !om || om === this._defaultGapOriginal;\n    }\n    /** Associate notation types with the corresponding units */\n    /**\n     * @return {NOTATION}     Notation associated with the units type\n     */\n    getNotation() {\n        if (this.units.toLowerCase().startsWith(NOTATION.FASTA))\n            return NOTATION.FASTA;\n        else if (this.units.toLowerCase().startsWith(NOTATION.SEPARATOR))\n            return NOTATION.SEPARATOR;\n        else if (this.units.toLowerCase().startsWith(NOTATION.HELM))\n            return NOTATION.HELM;\n        else\n            throw new Error(`Column '${this.column.name}' has unexpected notation '${this.units}'.`);\n    }\n    /**\n     * Get the wrapper strings for HELM, depending on the type of the\n     * macromolecule (peptide, DNA, RNA)\n     *\n     * @return {string[]} Array of wrappers\n     */\n    getHelmWrappers() {\n        const prefix = (this.isDna()) ? 'RNA1{' :\n            (this.isRna() || this.isHelmCompatible()) ? 'RNA1{' : 'PEPTIDE1{';\n        const postfix = '}$$$$';\n        const leftWrapper = (this.isDna()) ? 'd(' :\n            (this.isRna()) ? 'r(' : '';\n        const rightWrapper = (this.isDna() || this.isRna()) ? ')p' : '';\n        return [prefix, leftWrapper, rightWrapper, postfix];\n    }\n    /**\n     * Create a new empty column of the specified notation type and the same\n     * length as column\n     *\n     * @param {NOTATION} tgtNotation\n     * @return {DG.Column}\n     */\n    getNewColumn(tgtNotation, tgtSeparator, colName, data) {\n        const col = this.column;\n        const name = tgtNotation.toLowerCase() + '(' + col.name + ')';\n        const newColName = colName ?? col.dataFrame.columns.getUnusedName(name);\n        const newColumn = DG.Column.fromList('string', newColName, data ?? new Array(this.column.length).fill(''));\n        newColumn.semType = DG.SEMTYPE.MACROMOLECULE;\n        newColumn.setTag(DG.TAGS.UNITS, tgtNotation);\n        if (tgtNotation === NOTATION.SEPARATOR) {\n            if (!tgtSeparator)\n                throw new Error(`Notation \\'${NOTATION.SEPARATOR}\\' requires separator value.`);\n            newColumn.setTag(TAGS.separator, tgtSeparator);\n        }\n        newColumn.setTag(DG.TAGS.CELL_RENDERER, tgtNotation === NOTATION.HELM ? 'helm' : 'sequence'); // cell.renderer\n        const srcAligned = col.getTag(TAGS.aligned);\n        if (srcAligned)\n            newColumn.setTag(TAGS.aligned, srcAligned);\n        let srcAlphabet = col.getTag(TAGS.alphabet);\n        if (!srcAlphabet && this.notation === NOTATION.HELM && tgtNotation !== NOTATION.HELM)\n            srcAlphabet = ALPHABET.UN;\n        if (srcAlphabet != null)\n            newColumn.setTag(TAGS.alphabet, srcAlphabet);\n        let srcAlphabetSize = col.getTag(TAGS.alphabetSize);\n        if (srcAlphabet != null && srcAlphabetSize)\n            newColumn.setTag(TAGS.alphabetSize, srcAlphabetSize);\n        const srcAlphabetIsMultichar = col.getTag(TAGS.alphabetIsMultichar);\n        if (srcAlphabet != null && srcAlphabetIsMultichar !== undefined)\n            newColumn.setTag(TAGS.alphabetIsMultichar, srcAlphabetIsMultichar);\n        if (tgtNotation == NOTATION.HELM) {\n            srcAlphabetSize = this.getAlphabetSize().toString();\n            newColumn.setTag(TAGS.alphabetSize, srcAlphabetSize);\n        }\n        return newColumn;\n    }\n    /** Creates a new column on data of {@link seqList} with the same tags */\n    getNewColumnFromList(name, seqList) {\n        return this.getNewColumn(this.notation, this.separator, name, seqList);\n    }\n    /**\n     * Create a new empty column using templateCol as a template\n     *\n     * @param {DG.Column} templateCol  the properties and units of this column are used as a\n     * template to build the new one\n     * @return {DG.Column}\n     */\n    static getNewColumn(templateCol) {\n        const col = SeqHandler.forColumn(templateCol);\n        const targetNotation = col.notation;\n        return col.getNewColumn(targetNotation);\n    }\n    /**\n     * A helper function checking the validity of the 'units' string\n     *\n     * @param {string} units  the string to be validated\n     * @return {boolean}\n     */\n    static unitsStringIsValid(units) {\n        units = units.toLowerCase();\n        const prefixes = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];\n        const postfixes = ['rna', 'dna', 'pt'];\n        const prefixCriterion = prefixes.some((p) => units.startsWith(p.toLowerCase()));\n        return prefixCriterion;\n    }\n    /**\n     * Construct a new column of semantic type MACROMOLECULE from the list of\n     * specified parameters\n     *\n     * @param {number}    len  the length of the new column\n     * @param {string}    name  the name of the new column\n     * @param {string}    units  the units of the new column\n     * @return {DG.Column}\n     */\n    static getNewColumnFromParams(len, name, units) {\n        // WARNING: in this implementation is is impossible to verify the uniqueness\n        // of the new column's name\n        // TODO: verify the validity of units parameter\n        if (!SeqHandler.unitsStringIsValid(units))\n            throw new Error('Invalid format of \\'units\\' parameter');\n        const newColumn = DG.Column.fromList('string', name, new Array(len).fill(''));\n        newColumn.semType = DG.SEMTYPE.MACROMOLECULE;\n        newColumn.setTag(DG.TAGS.UNITS, units);\n        return newColumn;\n    }\n    /** Gets function to split seq value to monomers */\n    getSplitter(limit) {\n        let splitter = null;\n        splitter = this.notationProvider ? this.notationProvider.splitter : null;\n        if (splitter)\n            return splitter;\n        if (this.units.toLowerCase().startsWith(NOTATION.FASTA)) {\n            const alphabet = this.column.getTag(TAGS.alphabet);\n            if (alphabet !== null && !this.getAlphabetIsMultichar())\n                return splitterAsFastaSimple;\n            else\n                return splitterAsFasta;\n        }\n        else if (this.units.toLowerCase().startsWith(NOTATION.SEPARATOR))\n            return getSplitterWithSeparator(this.separator, limit);\n        else if (this.units.toLowerCase().startsWith(NOTATION.HELM))\n            return splitterAsHelm;\n        else\n            throw new Error(`Unexpected units ${this.units} .`);\n        // TODO: Splitter for HELM\n    }\n    split(seq) {\n        return this.splitter(seq);\n    }\n    getDistanceFunctionName() {\n        // TODO add support for helm and separator notation\n        if (!this.isFasta())\n            throw new Error('Only FASTA notation is supported');\n        if (this.isMsa())\n            return MmDistanceFunctionsNames.HAMMING;\n        switch (this.alphabet) {\n            case ALPHABET.DNA:\n            case ALPHABET.RNA:\n                // As DNA and RNA scoring matrices are same as identity matrices(mostly),\n                // we can use very fast and optimized Levenshtein distance library\n                return MmDistanceFunctionsNames.LEVENSHTEIN;\n            case ALPHABET.PT:\n                return MmDistanceFunctionsNames.LEVENSHTEIN;\n            // For default case, let's use Levenshtein distance\n            default:\n                return MmDistanceFunctionsNames.LEVENSHTEIN;\n        }\n    }\n    getDistanceFunction() {\n        return mmDistanceFunctions[this.getDistanceFunctionName()]();\n    }\n    // checks if the separator notation is compatible with helm library\n    async checkHelmCompatibility() {\n        // check first for the column tag to avoid extra processing\n        if (this.column.tags.has(TAGS.isHelmCompatible))\n            return this.column.getTag(TAGS.isHelmCompatible) === 'true';\n        // get the monomer lib and check against the column\n        const monomerLibHelper = await getMonomerLibHelper();\n        const bioLib = monomerLibHelper.getBioLib();\n        // retrieve peptides\n        const peptides = bioLib.getMonomerSymbolsByType(\"PEPTIDE\" /* HELM_POLYMER_TYPE.PEPTIDE */);\n        // convert the peptides list to a set for faster lookup\n        const peptidesSet = new Set(peptides);\n        // get splitter for given separator and check if all monomers are in the lib\n        const splitterFunc = getSplitterWithSeparator(this.separator);\n        // iterate over the columns, split them and check if all monomers are in the lib\n        //TODO maybe add missing threshold so that if there are not too many missing monomers\n        // the column is still considered helm compatible\n        const catIdxSet = new Set();\n        const rowCount = this.column.length;\n        const colRawData = this.column.getRawData();\n        for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {\n            const catI = colRawData[rowIdx];\n            if (!(catI in catIdxSet)) {\n                catIdxSet.add(catI);\n                const monomers = this.getSplitted(rowIdx);\n                for (const cm of monomers.canonicals) {\n                    if (!peptidesSet.has(cm)) {\n                        this.column.setTag(TAGS.isHelmCompatible, 'false');\n                        return false;\n                    }\n                }\n            }\n        }\n        this.column.setTag(TAGS.isHelmCompatible, 'true');\n        return true;\n    }\n    // -- Notation Converter --\n    get splitter() {\n        if (this._splitter === null)\n            this._splitter = this.getSplitter();\n        return this._splitter;\n    }\n    toFasta(targetNotation) { return targetNotation === NOTATION.FASTA; }\n    toSeparator(targetNotation) { return targetNotation === NOTATION.SEPARATOR; }\n    toHelm(targetNotation) { return targetNotation === NOTATION.HELM; }\n    /**\n     *  Convert HELM string to FASTA/SEPARATOR\n     *\n     * @param {string} srcSeq    A string to be converted\n     * @param {string} tgtNotation    Target notation: FASTA or SEPARATOR\n     * @param {string} tgtSeparator   Optional target separator (for HELM ->\n     * @param {string | null} tgtGapOriginal   Optional target gap symbol\n     * SEPARATOR)\n     * @return {string} Converted string\n     */\n    convertHelmToFastaSeparator(srcSeq, tgtNotation, tgtSeparator, tgtGapOriginal) {\n        if (!tgtGapOriginal) {\n            tgtGapOriginal = (this.toFasta(tgtNotation)) ?\n                GapOriginals[NOTATION.FASTA] :\n                GapOriginals[NOTATION.SEPARATOR];\n        }\n        if (!tgtSeparator)\n            tgtSeparator = (this.toFasta(tgtNotation)) ? '' : this.separator;\n        const isNucleotide = srcSeq.startsWith('RNA');\n        // items can be monomers or helms\n        const helmItemsArray = this.splitter(srcSeq);\n        const tgtMonomersArray = [];\n        for (let posIdx = 0; posIdx < helmItemsArray.length; ++posIdx) {\n            let om = helmItemsArray.getOriginal(posIdx);\n            if (isNucleotide)\n                om = om.replace(HELM_WRAPPERS_REGEXP, '');\n            if (om === GapOriginals[NOTATION.HELM])\n                tgtMonomersArray.push(tgtGapOriginal);\n            else if (this.toFasta(tgtNotation) && om.length > 1) {\n                // the case of a multi-character monomer converted to FASTA\n                const monomer = '[' + om + ']';\n                tgtMonomersArray.push(monomer);\n            }\n            else\n                tgtMonomersArray.push(om);\n        }\n        return tgtMonomersArray.join(tgtSeparator);\n    }\n    /** Dispatcher method for notation conversion\n     *\n     * @param {NOTATION} tgtNotation   Notation we want to convert to\n     * @param {string | null} tgtSeparator   Possible separator\n     * @return {DG.Column}                Converted column\n     */\n    convert(tgtNotation, tgtSeparator) {\n        // Get joiner from the source column units handler (this) knowing about the source sequence.\n        // For example, converting DNA Helm to fasta requires removing the r(X)p decoration.\n        const joiner = this.getJoiner({ notation: tgtNotation, separator: tgtSeparator });\n        const newColumn = this.getNewColumn(tgtNotation, tgtSeparator);\n        // assign the values to the newly created empty column\n        newColumn.init((rowIdx) => {\n            const srcSS = this.getSplitted(rowIdx);\n            return joiner(srcSS);\n        });\n        return newColumn;\n    }\n    /**\n     * @param name\n     * @param startIdx Start position index of the region (0-based)\n     * @param endIdx   End position index of the region (0-based, inclusive)\n     */\n    getRegion(startIdx, endIdx, name) {\n        const regCol = this.getNewColumn(this.notation, this.separator);\n        regCol.name = name;\n        const startIdxVal = startIdx ?? 0;\n        const endIdxVal = endIdx ?? this.maxLength - 1;\n        const joiner = this.getJoiner();\n        const regLength = endIdxVal - startIdxVal + 1;\n        const gapOM = GapOriginals[this.notation];\n        regCol.init((rowI) => {\n            const seqS = this.getSplitted(rowI);\n            // Custom slicing instead of array method to maintain gaps\n            const regOMList = new Array(regLength);\n            for (let regJPos = 0; regJPos < regLength; ++regJPos) {\n                const seqJPos = startIdxVal + regJPos;\n                regOMList[regJPos] = seqJPos < seqS.length ? seqS.getOriginal(seqJPos) : gapOM;\n            }\n            return joiner(new StringListSeqSplitted(regOMList, gapOM));\n        });\n        const getRegionOfPositionNames = (str) => {\n            const srcPosList = str.split(',').map((p) => p.trim());\n            const regPosList = new Array(regLength);\n            for (let regJPos = 0; regJPos < regLength; ++regJPos) {\n                const srcJPos = startIdxVal + regJPos;\n                regPosList[regJPos] = srcJPos < srcPosList.length ? srcPosList[srcJPos] : '?';\n            }\n            return regPosList.join(positionSeparator);\n        };\n        const srcPositionNamesStr = this.column.getTag(TAGS.positionNames);\n        if (srcPositionNamesStr)\n            regCol.setTag(TAGS.positionNames, getRegionOfPositionNames(srcPositionNamesStr));\n        const srcPositionLabelsStr = this.column.getTag(TAGS.positionLabels);\n        if (srcPositionLabelsStr)\n            regCol.setTag(TAGS.positionLabels, getRegionOfPositionNames(srcPositionLabelsStr));\n        return regCol;\n    }\n    get joiner() {\n        if (!this._joiner)\n            this._joiner = this.getJoiner();\n        return this._joiner;\n    }\n    getJoiner(opts) {\n        const notation = opts ? opts.notation : this.notation;\n        const separator = opts ? opts.separator : this.separator;\n        let res;\n        const srcSh = this;\n        switch (notation) {\n            case NOTATION.FASTA: {\n                res = function (srcSS) { return srcSh.joinToFasta(srcSS, srcSh.isHelm()); };\n                break;\n            }\n            case NOTATION.SEPARATOR: {\n                if (!separator)\n                    throw new Error(`Separator is mandatory for notation '${notation}'.`);\n                res = function (srcSS) { return joinToSeparator(srcSS, separator, srcSh.isHelm()); };\n                break;\n            }\n            case NOTATION.HELM: {\n                const isDnaOrRna = srcSh.alphabet === ALPHABET.DNA || srcSh.alphabet === ALPHABET.RNA;\n                const wrappers = srcSh.getHelmWrappers();\n                res = function (srcSS) { return joinToHelm(srcSS, wrappers, isDnaOrRna); };\n                break;\n            }\n            default:\n                throw new Error(`Unexpected notation '${notation}'.`);\n        }\n        return res;\n    }\n    getConverter(tgtUnits, tgtSeparator = undefined) {\n        if (tgtUnits === NOTATION.SEPARATOR && !tgtSeparator)\n            throw new Error(`Target separator is not specified for target units '${NOTATION.SEPARATOR}'.`);\n        const srcSh = this;\n        if (tgtUnits === NOTATION.FASTA)\n            return function (srcSeq) { return srcSh.convertToFasta(srcSeq); };\n        if (tgtUnits === NOTATION.HELM)\n            return function (srcSeq) { return srcSh.convertToHelm(srcSeq); };\n        else if (tgtUnits === NOTATION.SEPARATOR)\n            return function (srcSeq) { return srcSh.convertToSeparator(srcSeq, tgtSeparator); };\n        else\n            throw new Error();\n    }\n    /** Gets a column's UnitsHandler object from temp slot or creates a new and stores it to the temp slot. */\n    static forColumn(col) {\n        // TODO: Invalidate col.temp[Temps.uh] checking column's metadata\n        let res = col.temp[SeqTemps.seqHandler];\n        if (!res || res.columnVersion !== col.version)\n            res = col.temp[SeqTemps.seqHandler] = new SeqHandler(col);\n        return res;\n    }\n    // -- joiners & converters --\n    joinToFasta(seqS, isHelm) {\n        const resMList = new Array(seqS.length);\n        for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {\n            const cm = seqS.getOriginal(posIdx);\n            let om = seqS.getOriginal(posIdx);\n            if (isHelm)\n                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');\n            if (cm === GAP_SYMBOL)\n                om = GapOriginals[NOTATION.FASTA];\n            else if (cm === PHOSPHATE_SYMBOL)\n                om = '';\n            else if (om.length > 1)\n                om = '[' + om + ']';\n            resMList[posIdx] = om;\n        }\n        return resMList.join('');\n    }\n    convertToFasta(src) {\n        const srcUhSplitter = this.splitter;\n        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : srcUhSplitter(src);\n        return this.joinToFasta(srcSS, this.isHelm());\n    }\n    convertToSeparator(src, tgtSeparator) {\n        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : this.splitter(src);\n        return joinToSeparator(srcSS, tgtSeparator, this.isHelm());\n    }\n    convertToHelm(src) {\n        const wrappers = this.getHelmWrappers();\n        const isDnaOrRna = src.startsWith('DNA') || src.startsWith('RNA');\n        const srcSS = this.splitter(src);\n        return joinToHelm(srcSS, wrappers, isDnaOrRna);\n    }\n    /** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus. */\n    splitterAsHelmNucl(src) {\n        const srcMList = this.splitter(src);\n        const tgtMList = new Array(srcMList.length);\n        const isDna = src.startsWith('DNA');\n        const isRna = src.startsWith('RNA');\n        for (let posIdx = 0; posIdx < srcMList.length; ++posIdx) {\n            let om = srcMList.getOriginal(posIdx);\n            if (isDna || isRna) {\n                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');\n                om = om === PHOSPHATE_SYMBOL ? null : om;\n            }\n            tgtMList[posIdx] = om ? om : null;\n        }\n        return new StringListSeqSplitted(tgtMList.filter((om) => !!om), GapOriginals[NOTATION.HELM]);\n    }\n}\n// -- joiners --\nfunction joinToSeparator(seqS, tgtSeparator, isHelm) {\n    const resMList = new Array(seqS.length);\n    for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {\n        const cm = seqS.getCanonical(posIdx);\n        let om = seqS.getOriginal(posIdx);\n        if (isHelm)\n            om = om.replace(HELM_WRAPPERS_REGEXP, '$1');\n        if (cm === GAP_SYMBOL)\n            om = GapOriginals[NOTATION.SEPARATOR];\n        else if (cm === PHOSPHATE_SYMBOL)\n            om = '';\n        resMList[posIdx] = om;\n    }\n    return resMList.join(tgtSeparator);\n}\nfunction joinToHelm(srcSS, wrappers, isDnaOrRna) {\n    const [prefix, leftWrapper, rightWrapper, postfix] = wrappers;\n    const resOMList = new Array(srcSS.length);\n    for (let posIdx = 0; posIdx < srcSS.length; ++posIdx) {\n        const cm = srcSS.getCanonical(posIdx);\n        let om = srcSS.getOriginal(posIdx);\n        if (cm === GAP_SYMBOL)\n            om = GapOriginals[NOTATION.HELM];\n        else {\n            if (isDnaOrRna)\n                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');\n            om = om.length === 1 ? `${leftWrapper}${om}${rightWrapper}` : `${leftWrapper}[${om}]${rightWrapper}`;\n        }\n        resOMList[posIdx] = om;\n    }\n    return `${prefix}${resOMList.join('.')}${postfix}`;\n}\n//# sourceMappingURL=seq-handler.js.map","import * as DG from 'datagrok-api/dg';\n\nimport {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';\nimport {IMonomerLib} from '@datagrok-libraries/bio/src/types';\n\nimport {APP_NAME} from '../view/const';\nimport {DEFAULT_LIB_FILENAME, LIB_PATH} from './data-loader/const';\nimport {tryCatch} from './helpers';\n\nexport class OligoToolkitPackage extends DG.Package {\n  private _monomerLib?: IMonomerLib;\n\n  get monomerLib(): IMonomerLib {\n    if (!this._monomerLib)\n      throw new Error('Monomer lib not loaded');\n    return this._monomerLib!;\n  }\n\n  async initMonomerLib(): Promise<void> {\n    if (this._monomerLib !== undefined)\n      return;\n\n    const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create(\n      `Initializing ${APP_NAME.COMBINED} monomer library ...`);\n    await tryCatch(async () => {\n      const libHelper: IMonomerLibHelper = await getMonomerLibHelper();\n      this._monomerLib = await libHelper.readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);\n    }, () => pi.close());\n  }\n}\n","// import * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport * as grok from 'datagrok-api/grok';\nimport { tanimotoSimilarity } from '@datagrok-libraries/ml/src/distance-metrics-methods';\nimport { HELM_CORE_FIELDS, jsonSdfMonomerLibDict, MONOMER_ENCODE_MAX, MONOMER_ENCODE_MIN, SDF_MONOMER_NAME, } from '../utils/const';\nimport { GAP_SYMBOL } from '../utils/macromolecule/types';\nimport { SeqHandler } from '../utils/seq-handler';\nimport { splitAlignedSequences } from '../utils/splitter';\nexport function encodeMonomers(col) {\n    let encodeSymbol = MONOMER_ENCODE_MIN;\n    const monomerSymbolDict = {};\n    const sh = SeqHandler.forColumn(col);\n    const encodedStringArray = [];\n    const rowCount = col.length;\n    for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {\n        let encodedMonomerStr = '';\n        const monomers = sh.getSplitted(rowIdx);\n        for (const cm of monomers.canonicals) {\n            if (!monomerSymbolDict[cm]) {\n                if (encodeSymbol > MONOMER_ENCODE_MAX) {\n                    grok.shell.error(`Not enough symbols to encode monomers`);\n                    return null;\n                }\n                monomerSymbolDict[cm] = encodeSymbol;\n                encodeSymbol++;\n            }\n            encodedMonomerStr += String.fromCodePoint(monomerSymbolDict[cm]);\n        }\n        encodedStringArray.push(encodedMonomerStr);\n    }\n    return DG.Column.fromStrings('encodedMolecules', encodedStringArray);\n}\nexport function getMolfilesFromSeq(col, monomersLibObject) {\n    const sh = SeqHandler.forColumn(col);\n    const monomersDict = createMomomersMolDict(monomersLibObject);\n    const molFiles = [];\n    const rowCount = col.length;\n    for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {\n        const monomers = sh.getSplitted(rowIdx);\n        const molFilesForSeq = [];\n        for (let j = 0; j < monomers.length; ++j) {\n            const cm = monomers.getCanonical(j);\n            if (cm) {\n                if (!monomersDict[cm]) {\n                    grok.shell.warning(`Monomer ${cm} is missing in HELM library. Structure cannot be created`);\n                    return null;\n                }\n                // what is the reason of double conversion?\n                molFilesForSeq.push(JSON.parse(JSON.stringify(monomersDict[cm])));\n            }\n        }\n        molFiles.push(molFilesForSeq);\n    }\n    return molFiles;\n}\nexport function getMolfilesFromSingleSeq(cell, monomersLibObject) {\n    const sh = SeqHandler.forColumn(cell.column);\n    const monomersDict = createMomomersMolDict(monomersLibObject);\n    const molFiles = [];\n    const monomers = sh.getSplitted(cell.rowIndex);\n    const molFilesForSeq = [];\n    for (let j = 0; j < monomers.length; ++j) {\n        const cm = monomers.getCanonical(j);\n        if (cm) {\n            if (!monomersDict[cm]) {\n                grok.shell.warning(`Monomer ${cm} is missing in HELM library. Structure cannot be created`);\n                return null;\n            }\n            molFilesForSeq.push(JSON.parse(JSON.stringify(monomersDict[cm])));\n        }\n    }\n    molFiles.push(molFilesForSeq);\n    return molFiles;\n}\nexport function createMomomersMolDict(lib) {\n    const dict = {};\n    lib.forEach((it) => {\n        if (it['polymerType'] === 'PEPTIDE') {\n            const monomerObject = {};\n            HELM_CORE_FIELDS.forEach((field) => {\n                monomerObject[field] = it[field];\n            });\n            dict[it[\"symbol\" /* HELM_FIELDS.SYMBOL */]] = monomerObject;\n        }\n    });\n    return dict;\n}\nexport function createJsonMonomerLibFromSdf(table) {\n    var _a, _b, _c, _d, _e;\n    const resultLib = [];\n    for (let i = 0; i < table.rowCount; i++) {\n        const monomer = {};\n        Object.keys(jsonSdfMonomerLibDict).forEach((key) => {\n            if (key === \"symbol\" /* HELM_FIELDS.SYMBOL */) {\n                const monomerSymbol = table.get(jsonSdfMonomerLibDict[key], i);\n                monomer[key] = monomerSymbol === '.' ? table.get(SDF_MONOMER_NAME, i) : monomerSymbol;\n            }\n            else if (key === \"rgroups\" /* HELM_FIELDS.RGROUPS */) {\n                const rgroups = table.get(jsonSdfMonomerLibDict[key], i).split('\\n');\n                const jsonRgroups = [];\n                rgroups.forEach((g) => {\n                    const rgroup = {};\n                    const altAtom = g.substring(g.lastIndexOf(']') + 1);\n                    const radicalNum = g.match(/\\[R(\\d+)\\]/)[1];\n                    rgroup[\"capGroupSmiles\" /* HELM_RGROUP_FIELDS.CAP_GROUP_SMILES */] = altAtom === 'H' ? `[*:${radicalNum}][H]` : `O[*:${radicalNum}]`;\n                    rgroup[\"alternateId\" /* HELM_RGROUP_FIELDS.ALTERNATE_ID */] = altAtom === 'H' ? `R${radicalNum}-H` : `R${radicalNum}-OH`;\n                    rgroup[\"capGroupName\" /* HELM_RGROUP_FIELDS.CAP_GROUP_NAME */] = altAtom === 'H' ? `H` : `OH`;\n                    rgroup[\"label\" /* HELM_RGROUP_FIELDS.LABEL */] = `R${radicalNum}`;\n                    jsonRgroups.push(rgroup);\n                });\n                monomer[key] = jsonRgroups;\n            }\n            else {\n                if (jsonSdfMonomerLibDict[key])\n                    monomer[key] = table.get(jsonSdfMonomerLibDict[key], i);\n            }\n        });\n        monomer[_a = \"author\" /* HELM_REQUIRED_FIELD.AUTHOR */] ?? (monomer[_a] = '');\n        monomer[_b = \"id\" /* HELM_REQUIRED_FIELD.ID */] ?? (monomer[_b] = 0);\n        monomer[_c = \"smiles\" /* HELM_REQUIRED_FIELD.SMILES */] ?? (monomer[_c] = '');\n        monomer[_d = \"monomerType\" /* HELM_REQUIRED_FIELD.MONOMER_TYPE */] ?? (monomer[_d] = 'Backbone');\n        monomer[_e = \"createDate\" /* HELM_REQUIRED_FIELD.CREATE_DATE */] ?? (monomer[_e] = null);\n        resultLib.push(monomer);\n    }\n    return resultLib;\n}\nexport async function getMonomerLibHelper() {\n    const funcList = DG.Func.find({ package: 'Bio', name: 'getMonomerLibHelper' });\n    if (funcList.length === 0)\n        throw new Error('Package \"Bio\" must be installed for MonomerLibHelper.');\n    const res = (await funcList[0].prepare().call()).getOutputParamValue();\n    return res;\n}\nexport async function sequenceChemSimilarity(positionColumns, referenceSequence) {\n    /* eslint-enable max-len */\n    if (positionColumns instanceof DG.Column)\n        positionColumns = splitAlignedSequences(positionColumns).columns.toList();\n    const libHelper = await getMonomerLibHelper();\n    const monomerLib = libHelper.getBioLib();\n    // const smilesCols: DG.Column<string>[] = new Array(monomerCols.length);\n    const rawCols = new Array(positionColumns.length);\n    const rowCount = positionColumns[0].length;\n    const totalSimilarity = new Float32Array(rowCount);\n    // Calculate base similarity\n    for (let position = 0; position < positionColumns.length; ++position) {\n        const referenceMonomerCanonical = referenceSequence.getCanonical(position);\n        const referenceMol = monomerLib.getMonomer('PEPTIDE', referenceMonomerCanonical)?.smiles ?? '';\n        const monomerCol = positionColumns[position];\n        const monomerColData = monomerCol.getRawData();\n        const monomerColCategories = monomerCol.categories;\n        const emptyCategoryIdx = monomerColCategories.indexOf('');\n        rawCols[position] = { categories: monomerColCategories, data: monomerColData, emptyIndex: emptyCategoryIdx };\n        if (typeof referenceMonomerCanonical === 'undefined')\n            continue;\n        // Calculating similarity for\n        const molCol = DG.Column.fromStrings('smiles', monomerColCategories.map((cat) => monomerLib.getMonomer('PEPTIDE', cat)?.smiles ?? ''));\n        const _df = DG.DataFrame.fromColumns([molCol]); // getSimilarities expects that column is in dataframe\n        const similarityCol = (await grok.chem.getSimilarities(molCol, referenceMol));\n        const similarityColData = similarityCol.getRawData();\n        for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {\n            const monomerCategoryIdx = monomerColData[rowIdx];\n            totalSimilarity[rowIdx] += referenceMonomerCanonical !== GAP_SYMBOL && monomerCategoryIdx !== emptyCategoryIdx ?\n                similarityColData[monomerCategoryIdx] :\n                referenceMonomerCanonical === GAP_SYMBOL && monomerCategoryIdx === emptyCategoryIdx ? 1 : 0;\n        }\n    }\n    for (let similarityIndex = 0; similarityIndex < totalSimilarity.length; ++similarityIndex) {\n        let updatedSimilarity = totalSimilarity[similarityIndex] / referenceSequence.length;\n        for (let position = 0; position < positionColumns.length; ++position) {\n            const currentRawCol = rawCols[position];\n            if ((position >= referenceSequence.length && currentRawCol.data[similarityIndex] !== currentRawCol.emptyIndex) ||\n                (currentRawCol.data[similarityIndex] === currentRawCol.emptyIndex && position < referenceSequence.length)) {\n                updatedSimilarity = DG.FLOAT_NULL;\n                break;\n            }\n        }\n        totalSimilarity[similarityIndex] = updatedSimilarity;\n    }\n    const similarityCol = DG.Column.fromFloat32Array('Similarity', totalSimilarity);\n    return similarityCol;\n}\n/* eslint-disable max-len */\n/** Calculates chemical similarity between each pair of monomers.\n * @param {string[]} monomerSet Set of unique monomers.\n * @returns {Promise<{scoringMatrix: number[][], alphabetIndexes: {[monomerId: string]: number}}>} Ojbect containing similarity scoring matrix and monomer to index mapping. */\nexport async function calculateMonomerSimilarity(monomerSet) {\n    /* eslint-enable max-len */\n    const libHelper = await getMonomerLibHelper();\n    const monomerLib = libHelper.getBioLib();\n    const scoringMatrix = [];\n    const alphabetIndexes = {};\n    const monomerMolecules = monomerSet.map((monomer) => monomerLib.getMonomer('PEPTIDE', monomer)?.smiles ?? '');\n    const monomerMoleculesCol = DG.Column.fromStrings('smiles', monomerMolecules);\n    for (let monomerIndex = 0; monomerIndex < monomerMolecules.length; ++monomerIndex) {\n        const monomer = monomerSet[monomerIndex];\n        alphabetIndexes[monomer] = monomerIndex;\n        const monomerMol = monomerMolecules[monomerIndex];\n        const similarityScores = monomerMol === '' ? new Array(monomerMolecules.length).fill(0) :\n            (await grok.chem.getSimilarities(monomerMoleculesCol, monomerMol)).getRawData();\n        similarityScores[monomerIndex] = 1;\n        scoringMatrix[monomerIndex] = Array.from(similarityScores);\n    }\n    return { scoringMatrix, alphabetIndexes };\n}\nexport async function getMonomerSubstitutionMatrix(monomerSet, fingerprintType = 'Morgan') {\n    const libHelper = await getMonomerLibHelper();\n    const monomerLib = libHelper.getBioLib();\n    const scoringMatrix = new Array(monomerSet.length).fill(0).map(() => new Array(monomerSet.length).fill(0));\n    const alphabetIndexes = {};\n    const monomerMolecules = monomerSet.map((monomer) => monomerLib.getMonomer('PEPTIDE', monomer)?.smiles ?? '');\n    const fingerprintsFunc = DG.Func.find({ package: 'Chem', name: 'getFingerprints' })[0];\n    if (!fingerprintsFunc) {\n        console.warn('Function \"Chem:getFingerprints\" is not found in chem package. falling back to Morgan fingerprints');\n        return await calculateMonomerSimilarity(monomerSet);\n    }\n    const monomerMoleculesCol = DG.Column.fromStrings('smiles', monomerMolecules);\n    // needed for function to work\n    const _unusedMolDf = DG.DataFrame.fromColumns([monomerMoleculesCol]);\n    const fingerPrints = (await fingerprintsFunc.apply({ col: monomerMoleculesCol, fingerprintType: fingerprintType }))?.entries;\n    if (!fingerPrints) {\n        console.warn(`${fingerprintType} Fingerprints could not be calculated for monomers from chem package.\n      falling back to Morgan fingerprints`);\n        return await calculateMonomerSimilarity(monomerSet);\n    }\n    for (let i = 0; i < fingerPrints.length; ++i) {\n        scoringMatrix[i][i] = 1;\n        alphabetIndexes[monomerSet[i]] = i;\n        if (!fingerPrints[i])\n            continue;\n        for (let j = i + 1; j < fingerPrints.length; ++j) {\n            if (!fingerPrints[j])\n                continue;\n            scoringMatrix[i][j] = scoringMatrix[j][i] = tanimotoSimilarity(fingerPrints[i], fingerPrints[j]);\n        }\n    }\n    return { scoringMatrix, alphabetIndexes };\n}\n;\n//# sourceMappingURL=monomer-utils.js.map","const __WEBPACK_NAMESPACE_OBJECT__ = ui;","import {StrandType} from './types';\n\nexport const enum STRAND {\n  SENSE = 'SS',\n  ANTISENSE = 'AS',\n};\nexport const STRANDS = [STRAND.SENSE, STRAND.ANTISENSE] as const;\nexport const STRAND_LABEL: Record<StrandType, string> = {\n  [STRAND.SENSE]: 'Sense strand',\n  [STRAND.ANTISENSE]: 'Anti sense',\n};\n\nexport const enum STRAND_END {\n  LEFT,\n  RIGHT,\n};\n\nexport const STRAND_ENDS = [STRAND_END.LEFT, STRAND_END.RIGHT] as const;\n\nexport const enum TERMINUS {\n  FIVE_PRIME = '5\\'',\n  THREE_PRIME = '3\\'',\n};\nexport const TERMINI = [TERMINUS.THREE_PRIME, TERMINUS.FIVE_PRIME] as const;\n\nexport const STRAND_TO_END_TERMINUS_MAP = {\n  [STRAND.SENSE]: {\n    [STRAND_END.LEFT]: TERMINUS.THREE_PRIME,\n    [STRAND_END.RIGHT]: TERMINUS.FIVE_PRIME\n  },\n  [STRAND.ANTISENSE]: {\n    [STRAND_END.LEFT]: TERMINUS.FIVE_PRIME,\n    [STRAND_END.RIGHT]: TERMINUS.THREE_PRIME\n  }\n} as const;\n\nexport const MAX_SEQUENCE_LENGTH = 34;\n\nexport const STORAGE_NAME: string = 'OligoToolkit';\nexport const EXAMPLE_MIN_WIDTH: string = '400px';\n\nexport const OTHER_USERS = 'Other users';\n\nexport namespace GRAPH_SETTINGS_KEYS {\n  export const IS_ANTISENSE_STRAND_INCLUDED = 'isAntisenseStrandIncluded';\n  export const NUCLEOTIDE_SEQUENCES = 'nucleotideSequences';\n  export const PHOSPHOROTHIOATE_LINKAGE_FLAGS = 'phosphorothioateLinkageFlags';\n  export const STRAND_TERMINUS_MODIFICATIONS = 'strandTerminusModifications';\n}\n\nexport namespace LEGEND_SETTINGS_KEYS {\n  export const PATTERN_NAME = 'patternName';\n  export const PATTERN_COMMENT = 'patternComment';\n  export const NUCLEOTIDES_WITH_NUMERIC_LABELS = 'nucleotidesWithNumericLabels';\n}\n\nexport namespace PATTERN_RECORD_KEYS {\n  export const PATTERN_CONFIG = 'patternConfig';\n  export const AUTHOR_ID = 'authorID';\n}\n\nexport const GRAPH_SETTINGS_KEY_LIST = [\n  GRAPH_SETTINGS_KEYS.IS_ANTISENSE_STRAND_INCLUDED,\n  GRAPH_SETTINGS_KEYS.NUCLEOTIDE_SEQUENCES,\n  GRAPH_SETTINGS_KEYS.PHOSPHOROTHIOATE_LINKAGE_FLAGS,\n  GRAPH_SETTINGS_KEYS.STRAND_TERMINUS_MODIFICATIONS\n];\n\nexport const LEGEND_SETTINGS_KEY_LIST = [\n  LEGEND_SETTINGS_KEYS.PATTERN_NAME,\n  LEGEND_SETTINGS_KEYS.PATTERN_COMMENT,\n  LEGEND_SETTINGS_KEYS.NUCLEOTIDES_WITH_NUMERIC_LABELS\n];\n\nexport const PATTERN_RECORD_KEY_LIST = [\n  PATTERN_RECORD_KEYS.PATTERN_CONFIG,\n  PATTERN_RECORD_KEYS.AUTHOR_ID\n];\n\nexport const EXAMPLE_PATTERN_CONFIG =\n{\n  'patternConfig': {\n    'patternName': '<default example>',\n    'isAntisenseStrandIncluded': true,\n    'nucleotideSequences': {\n      'SS': [\n        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA',\n        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA'\n      ],\n      'AS': [\n        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA',\n        'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA', 'RNA'\n      ]\n    },\n    'phosphorothioateLinkageFlags': {\n      'SS': [\n        true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,\n        true, true, true, true, true, true, true, true\n      ],\n      'AS': [\n        true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,\n        true, true, true, true, true, true, true, true\n      ]\n    },\n    'strandTerminusModifications': {\n      'SS': {\n        '3\\'': '',\n        '5\\'': ''\n      },\n      'AS': {\n        '3\\'': '',\n        '5\\'': ''\n      }\n    },\n    'patternComment': '',\n    'nucleotidesWithNumericLabels': [\n      'RNA'\n    ]\n  },\n  'authorID': ''\n};\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {\n  TERMINI, STRANDS,\n  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R\n} from './const';\n\nexport type StrandType = typeof STRANDS[number];\nexport type TerminalType = typeof TERMINI[number];\n\nexport type NucleotideSequences = Record<StrandType, string[]>;\nexport type PhosphorothioateLinkageFlags = Record<StrandType, boolean[]>;\nexport type StrandTerminusModifications = Record<StrandType, Record<TerminalType, string>>;\n\nexport type PatternGraphSettings = {\n  [G.IS_ANTISENSE_STRAND_INCLUDED]: boolean,\n  [G.NUCLEOTIDE_SEQUENCES]: NucleotideSequences,\n  [G.PHOSPHOROTHIOATE_LINKAGE_FLAGS]: PhosphorothioateLinkageFlags,\n  [G.STRAND_TERMINUS_MODIFICATIONS]: StrandTerminusModifications,\n}\n\nexport type PatternLegendSettings = {\n  [L.PATTERN_NAME]: string,\n  [L.PATTERN_COMMENT]: string,\n  [L.NUCLEOTIDES_WITH_NUMERIC_LABELS]: string[],\n}\n\nexport type PatternConfiguration = PatternGraphSettings & PatternLegendSettings;\n\nexport type PatternConfigRecord = {\n  [R.PATTERN_CONFIG]: PatternConfiguration,\n  [R.AUTHOR_ID]: string,\n}\n\nexport class PatternNameExistsError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'PatternNameExistsError';\n  }\n}\n\nexport class PatternExistsError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'PatternExistsError';\n  }\n}\n\nexport type RawPatternRecords = {[patternName: string]: string};\n","const __WEBPACK_NAMESPACE_OBJECT__ = rxjs;","import * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\n\nimport {PATTERN_APP_DATA} from '../../common/model/data-loader/json-loader';\nimport {NucleotideSequences} from './types';\n\n\nexport function isOverhangNucleotide(nucleotide: string): boolean {\n  return nucleotide.endsWith('(o)');\n}\n\n\nexport function getUniqueNucleotides(sequences: NucleotideSequences): string[] {\n  const nucleotides = Object.values(sequences).flat();\n  return getUniqueSortedStrings(nucleotides);\n}\n\n\nexport function getUniqueNucleotidesWithNumericLabels(\n  modificationsWithNumericLabels: string[]\n): string[] {\n  const uniqueLabelledNucleotides = getUniqueSortedStrings(modificationsWithNumericLabels);\n\n  return uniqueLabelledNucleotides.filter((nucleotide) => !isOverhangNucleotide(nucleotide));\n}\n\n\nexport function getMostFrequentNucleotide(sequences: NucleotideSequences): string {\n  const nucleotideToFrequencyMap = Object.values(sequences).flat().reduce((acc, nucleotide) => {\n    acc[nucleotide] = (acc[nucleotide] || 0) + 1;\n    return acc;\n  }, {} as {[key: string]: number});\n\n  const mostFrequentNucleotide = Object.entries(nucleotideToFrequencyMap)\n    .reduce((a, b) => a[1] > b[1] ? a : b, ['', 0])[0];\n\n  return mostFrequentNucleotide;\n}\n\n// export function addColumnWithIds(tableName: string, columnName: string, patternName: string) {\n//   const nameOfNewColumn = 'ID ' + patternName;\n//   const columns = grok.shell.table(tableName).columns;\n//   if (columns.contains(nameOfNewColumn))\n//     columns.remove(nameOfNewColumn);\n//   const columnWithIds = columns.byName(columnName);\n//   return columns.addNewString(nameOfNewColumn).init((i: number) => {\n//     return (columnWithIds.getString(i) === '') ? '' : columnWithIds.get(i) + '_' + patternName;\n//   });\n// }\n\n// export function addColumnWithTranslatedSequences(\n//   tableName: string,\n//   columnName: string,\n//   bases: DG.InputBase[],\n//   ptoLinkages: DG.InputBase[],\n//   startModification: DG.InputBase,\n//   endModification: DG.InputBase,\n//   firstPtoExist: boolean) {\n//   const nameOfNewColumn = 'Axolabs ' + columnName;\n//   const columns = grok.shell.table(tableName).columns;\n//   if (columns.contains(nameOfNewColumn))\n//     columns.remove(nameOfNewColumn);\n//   const columnWithInputSequences = columns.byName(columnName);\n//   return columns.addNewString(nameOfNewColumn).init((i: number) => {\n//     return columnWithInputSequences.getString(i) === '' ?\n//       '' :\n//       translateSequence(columnWithInputSequences.getString(i), bases, ptoLinkages, startModification, endModification,\n//         firstPtoExist);\n//   });\n// }\n\nexport namespace StrandEditingUtils {\n  export function getTruncatedStrandData(\n    originalNucleotides: string[],\n    originalPTOFlags: boolean[],\n    newStrandLength: number\n  ): {nucleotides: string[], ptoFlags: boolean[]} {\n    const nucleotides = originalNucleotides.slice(0, newStrandLength);\n    const ptoFlags = originalPTOFlags.slice(0, newStrandLength + 1);\n    return {nucleotides, ptoFlags};\n  }\n\n  export function getExtendedStrandData(\n    originalNucleotides: string[],\n    originalPTOFlags: boolean[],\n    newStrandLength: number,\n    sequenceBase: string\n  ): {nucleotides: string[], ptoFlags: boolean[]} {\n    const appendedNucleotidesLength = newStrandLength - originalNucleotides.length;\n    const nucleotides = originalNucleotides.concat(\n      new Array(newStrandLength - originalNucleotides.length).fill(sequenceBase)\n    );\n\n    const appendedFlagsLength = (originalNucleotides.length === 0) ? newStrandLength + 1 : appendedNucleotidesLength;\n    const ptoFlags = originalPTOFlags.concat(\n      new Array(appendedFlagsLength).fill(true)\n    );\n\n    return {nucleotides, ptoFlags};\n  }\n}\n\nfunction getUniqueSortedStrings(array: string[]): string[] {\n  const uniqueStrings = Array.from(new Set(array));\n  const sorted = Array.from(uniqueStrings).sort(\n    (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())\n  );\n\n  return sorted;\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = rxjs.operators;","const __WEBPACK_NAMESPACE_OBJECT__ = $;","\n      import API from \"!../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n       export default content && content.locals ? content.locals : undefined;\n","import * as ui from 'datagrok-api/ui';\n\nimport {STRAND, STRANDS} from '../../../model/const';\nimport {EventBus} from '../../../model/event-bus';\nimport {PatternConfiguration, PhosphorothioateLinkageFlags} from '../../../model/types';\nimport {BooleanInput} from '../../types';\nimport {SubscriptionManager} from '../../../model/subscription-manager';\n\nexport class HeaderControls {\n  constructor(\n    private eventBus: EventBus,\n    private initialPatternConfig: PatternConfiguration,\n    private subscriptions: SubscriptionManager\n  ) { }\n\n  create(): HTMLDivElement {\n    const container = ui.divV([\n      ui.h1('PTO'),\n      ui.divH([\n        this.createAllPtoActivationInput().root,\n        ...this.createFirstPtoInputs().map((input) => input.root),\n      ], {style: {gap: '12px'}})\n    ]);\n\n    return container;\n  }\n\n  private areAllPtoLinkagesSet(flags: PhosphorothioateLinkageFlags): boolean {\n    const totalNumberOfPTOFlags = STRANDS.map(\n      (strand) => flags[strand].filter((flag) => flag).length\n    )\n      .reduce((a, b) => a + b, 0);\n\n    const totalNumberOfNucleotides = STRANDS.map(\n      (strand) => this.initialPatternConfig.nucleotideSequences[strand].length\n    ).reduce((a, b) => a + b, 0);\n\n    // There are +1 more PTO flags in each strand than there are nucleotides\n    const addendum = STRANDS.filter((strand) => flags[strand].length).length;\n    return totalNumberOfPTOFlags === totalNumberOfNucleotides + addendum;\n  }\n\n  private createAllPtoActivationInput(): BooleanInput {\n    const flags = this.initialPatternConfig.phosphorothioateLinkageFlags;\n    const initialValue = this.areAllPtoLinkagesSet(flags);\n    const allPtoActivationInput = ui.boolInput('All PTO', initialValue);\n\n    allPtoActivationInput.onInput(() => {\n      const value = allPtoActivationInput.value!;\n      this.eventBus.setAllPTOLinkages(value);\n    });\n\n    const subscription = this.eventBus.phosphorothioateLingeFlagsChanged$.subscribe(() => {\n      const flags = this.eventBus.getPatternConfig().phosphorothioateLinkageFlags;\n      const newValue = this.areAllPtoLinkagesSet(flags);\n      allPtoActivationInput.value = newValue;\n    });\n    this.subscriptions.add(subscription);\n\n    this.addStyleToPtoInput(allPtoActivationInput);\n    ui.tooltip.bind(allPtoActivationInput.captionLabel, 'Activate all phosphothioates');\n\n    return allPtoActivationInput;\n  }\n\n  private addStyleToPtoInput(allPtoActivationInput: BooleanInput): void {\n    const label = allPtoActivationInput.captionLabel;\n    label.classList.add('ui-label-right');\n    Object.assign(label.style, {\n      textAlign: 'left',\n      maxWidth: '100px',\n      minWidth: '40px',\n      width: 'auto'\n    });\n  }\n\n  private createFirstPtoInputs(): BooleanInput [] {\n    return STRANDS.map((strand) => {\n      if (!this.eventBus.isAntisenseStrandActive() && strand === STRAND.ANTISENSE)\n        return;\n      const initialValue = this.isFirstPtoActive(strand);\n      const firstPtoInput = ui.boolInput(`First ${strand} PTO`, initialValue);\n\n      firstPtoInput.onInput(() => {\n        const value = firstPtoInput.value!;\n        this.eventBus.setPhosphorothioateLinkageFlag(strand, 0, value);\n      });\n\n      const subscription = this.eventBus.phosphorothioateLingeFlagsChanged$.subscribe((flags) => {\n        const newValue = flags[strand][0];\n        firstPtoInput.value = newValue;\n      });\n      this.subscriptions.add(subscription);\n\n      this.addStyleToPtoInput(firstPtoInput);\n      ui.tooltip.bind(firstPtoInput.captionLabel, `Activate first phosphothioate in ${strand}`);\n      return firstPtoInput;\n    }).filter((input) => input !== undefined) as BooleanInput[];\n  }\n\n  private isFirstPtoActive(strand: STRAND): boolean {\n    return this.initialPatternConfig.phosphorothioateLinkageFlags[strand][0];\n  }\n}\n\n","import * as ui from 'datagrok-api/ui';\n\nimport $ from 'cash-dom';\n\nimport {PATTERN_APP_DATA} from '../../../../common/model/data-loader/json-loader';\nimport {STRAND, STRANDS, STRAND_LABEL} from '../../../model/const';\nimport {EventBus} from '../../../model/event-bus';\nimport {StrandType} from '../../../model/types';\nimport {isOverhangNucleotide} from '../../../model/utils';\nimport {BooleanInput, StringInput} from '../../types';\nimport {SubscriptionManager} from '../../../model/subscription-manager';\nimport {DataManager} from '../../../model/data-manager';\n\nexport class StrandControls {\n  private displayedInputLabels: Map<StrandType, string[]>;\n\n  constructor(\n    private eventBus: EventBus,\n    private dataManager: DataManager,\n    private subscriptions: SubscriptionManager\n  ) {\n    const subscription = this.eventBus.nucleotideSequencesChanged$.subscribe(() => {\n      this.displayedInputLabels = this.computeDisplayedInputLabels();\n    });\n    this.subscriptions.add(subscription);\n  }\n\n  create(): HTMLDivElement {\n    const inputPanels = STRANDS.map((strand) => this.constructControlsPanel(strand));\n\n    const container = ui.divH(inputPanels, {style: {gap: '24px'}});\n    return container;\n  }\n\n  private constructControlsPanel(strand: StrandType): HTMLDivElement {\n    if (!this.eventBus.isAntisenseStrandActive() && strand === STRAND.ANTISENSE)\n      return ui.div([]);\n\n\n    const header = this.constructHeader();\n    const modificationControls = this.createControls(strand);\n\n    const container = ui.block([\n      ui.h1(`${STRAND_LABEL[strand]}`),\n      header,\n      modificationControls,\n    ], {style: {paddingTop: '12px'}});\n\n    return container;\n  }\n\n  private constructHeader() {\n    return ui.divH([\n      ui.div([ui.divText('#')], {style: {width: '20px'}}),\n      ui.block75([ui.divText('Modification')]),\n      ui.div([ui.divText('PTO')]),\n    ]);\n  }\n\n  private createControls(strand: StrandType): HTMLDivElement {\n    const nucleobaseInputs = this.createNucleobaseInputs(strand);\n    const labels = this.createLabelDivs(strand);\n    const ptoLinkageInputs = this.createPTOFlagInputs(strand);\n    const container = ui.div(nucleobaseInputs.map(\n      (nucleobaseInput, idx) => {\n        return ui.divH([\n          labels[idx],\n          ui.block75([nucleobaseInput.root]),\n          ptoLinkageInputs[idx].root,\n        ], {style: {alignItems: 'center'}});\n      }));\n    return container;\n  }\n\n  private createNucleobaseInputs(strand: StrandType): StringInput[] {\n    const nucleotideBaseChoices: string[] = this.dataManager.fetchAvailableNucleotideBases()\n      .sort(\n        (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())\n      );\n    const nucleotides = this.eventBus.getNucleotideSequences()[strand];\n    const choiceInputs = nucleotides.map((nucleotide, index) => {\n      const input = ui.choiceInput<string>('', nucleotide, nucleotideBaseChoices);\n      input.onInput(() => {\n        const newValue = input.value!;\n        this.eventBus.setNucleotide(strand, index, newValue);\n      });\n      return input;\n    });\n\n    return choiceInputs;\n  }\n\n  private createPTOFlagInputs(strand: StrandType): BooleanInput[] {\n    const ptoLinkageFlags = this.eventBus.getPhosphorothioateLinkageFlags()[strand].slice(1);\n    const ptoLinkageInputs = ptoLinkageFlags.map((flag, index) => {\n      const input = ui.boolInput('', flag);\n      input.onInput(() => {\n        const newValue = input.value!;\n        this.eventBus.setPhosphorothioateLinkageFlag(strand, index + 1, newValue);\n      });\n\n      const subscription = this.eventBus.phosphorothioateLingeFlagsChanged$.subscribe((flags) => {\n        const newValue = flags[strand][index + 1];\n        input.value = newValue;\n      });\n      this.subscriptions.add(subscription);\n\n      return input;\n    });\n\n    return ptoLinkageInputs;\n  }\n\n  private computeDisplayedInputLabels(): Map<StrandType, string[]> {\n    const nucleotides = this.eventBus.getNucleotideSequences();\n    const labels = new Map<StrandType, string[]>();\n    STRANDS.forEach((strand) => {\n      let counter = 1;\n      const strandNucleotides = nucleotides[strand];\n      const strandLabels = strandNucleotides.map((nucleotide) => {\n        if (isOverhangNucleotide(nucleotide))\n          return '';\n\n        const label = String(counter);\n        counter++;\n        return label;\n      });\n      labels.set(strand, strandLabels);\n    });\n\n    return labels;\n  }\n\n  private createLabelDivs(strand: StrandType): HTMLElement[] {\n    const labels = this.createLabels(strand);\n    const labelDivs = labels.map((label) => ui.div([label], {style: {width: '20px'}}));\n\n    const subscription = this.eventBus.nucleotideSequencesChanged$.subscribe(() => {\n      const newLabels = this.createLabels(strand);\n      newLabels.forEach((newLabel, index) => {\n        $(labelDivs[index]).empty();\n        $(labelDivs[index]).append(newLabel);\n      });\n    });\n    this.subscriptions.add(subscription);\n\n    return labelDivs;\n  }\n\n  private createLabels(strand: StrandType): HTMLLabelElement[] {\n    const nucleotides = this.eventBus.getNucleotideSequences()[strand];\n    const labels = nucleotides.map((_, index) => {\n      const labelText = this.displayedInputLabels.get(strand)![index];\n      return ui.label(labelText);\n    });\n\n    return labels;\n  }\n}\n","import * as DG from 'datagrok-api/dg';\nimport {Subscription} from 'rxjs';\n\nexport class SubscriptionManager {\n  private rxjsSubscriptions = [] as Subscription[];\n  private dgSubscriptions = [] as DG.StreamSubscription[];\n\n  add(subscription: Subscription | DG.StreamSubscription) {\n    if (subscription instanceof Subscription)\n      this.rxjsSubscriptions.push(subscription);\n    else\n      this.dgSubscriptions.push(subscription);\n  }\n\n  unsubscribeAll() {\n    for (const subs of [this.rxjsSubscriptions, this.dgSubscriptions]) {\n      subs.forEach((sub) => sub.unsubscribe());\n      subs.length = 0;\n    }\n  }\n}\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as DG from 'datagrok-api/dg';\nimport * as ui from 'datagrok-api/ui';\n\nimport $ from 'cash-dom';\nimport _ from 'lodash';\n\nimport {EventBus} from '../../../model/event-bus';\nimport {PatternConfiguration} from '../../../model/types';\nimport {HeaderControls} from './header-controls';\nimport {StrandControls} from './strand-controls';\nimport {SubscriptionManager} from '../../../model/subscription-manager';\nimport {DataManager} from '../../../model/data-manager';\n\nexport class StrandEditorDialog {\n  private static isDialogOpen = false;\n  private static instance: StrandEditorDialog;\n\n  private initialPatternConfig: PatternConfiguration;\n  private subscriptions = new SubscriptionManager();\n\n  private constructor(\n    private eventBus: EventBus,\n    private dataManager: DataManager\n  ) { }\n\n  static open(eventBus: EventBus, dataManager: DataManager): void {\n    if (StrandEditorDialog.isDialogOpen)\n      return;\n\n    if (!StrandEditorDialog.instance)\n      StrandEditorDialog.instance = new StrandEditorDialog(eventBus, dataManager);\n\n    StrandEditorDialog.instance.openDialog();\n  }\n\n  private openDialog(): void {\n    this.initialPatternConfig = _.cloneDeep(this.eventBus.getPatternConfig());\n    StrandEditorDialog.isDialogOpen = true;\n    this.createDialog().show();\n  }\n\n  private createDialog(): DG.Dialog {\n    const editorBody = ui.divV([]);\n    this.subscriptions.add(\n      this.eventBus.strandsUpdated$.subscribe(() => this.onStrandsUpdated(editorBody))\n    );\n\n    const dialog = ui.dialog('Edit strands')\n      .add(editorBody)\n      .onOK(() => {})\n      .onCancel(() => this.resetToInitialState());\n\n    this.subscriptions.add(\n      dialog.onClose.subscribe(() => {\n        StrandEditorDialog.isDialogOpen = false;\n        this.subscriptions.unsubscribeAll();\n      })\n    );\n\n    return dialog;\n  }\n\n  private onStrandsUpdated(editorBody: HTMLDivElement) {\n    const headerControls = new HeaderControls(\n      this.eventBus, this.initialPatternConfig, this.subscriptions\n    ).create();\n    const strandControls = new StrandControls(this.eventBus, this.dataManager, this.subscriptions).create();\n\n    $(editorBody).empty();\n    $(editorBody).append(headerControls, strandControls);\n  }\n\n  private resetToInitialState(): void {\n    // this.eventBus.setLastLoadedPatternConfig(this.initialPatternConfig);\n    this.eventBus.setPatternConfig(this.initialPatternConfig);\n  }\n}\n\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as DG from 'datagrok-api/dg';\nimport * as ui from 'datagrok-api/ui';\n\nimport $ from 'cash-dom';\nimport _ from 'lodash';\n\nimport {EventBus} from '../../model/event-bus';\nimport {PatternConfiguration, StrandType} from '../../model/types';\nimport {SubscriptionManager} from '../../model/subscription-manager';\nimport {STRAND, STRANDS, STRAND_LABEL, TERMINI, TERMINUS} from '../../model/const';\nimport {StringInput} from '../types';\n\nexport class TerminalModificationEditorDialog {\n  private static isDialogOpen = false;\n  private static instance: TerminalModificationEditorDialog;\n\n  private initialPatternConfig: PatternConfiguration;\n  private subscriptions = new SubscriptionManager();\n\n  private constructor(\n    private eventBus: EventBus\n  ) { }\n\n  static open(eventBus: EventBus): void {\n    if (TerminalModificationEditorDialog.isDialogOpen)\n      return;\n\n    if (!TerminalModificationEditorDialog.instance)\n      TerminalModificationEditorDialog.instance = new TerminalModificationEditorDialog(eventBus);\n\n    TerminalModificationEditorDialog.instance.openDialog();\n  }\n\n  private openDialog(): void {\n    this.initialPatternConfig = _.cloneDeep(this.eventBus.getPatternConfig());\n    TerminalModificationEditorDialog.isDialogOpen = true;\n    this.createDialog().show();\n  }\n\n  private createDialog(): DG.Dialog {\n    const editorBody = ui.divV([]);\n    this.subscriptions.add(\n      this.eventBus.strandsUpdated$.subscribe(() => this.onStrandsUpdated(editorBody))\n    );\n\n    const dialog = ui.dialog('Edit terminal modifications')\n      .add(editorBody)\n      .onOK(() => {})\n      .onCancel(() => this.resetToInitialState());\n\n    this.subscriptions.add(\n      dialog.onClose.subscribe(() => {\n        TerminalModificationEditorDialog.isDialogOpen = false;\n        this.subscriptions.unsubscribeAll();\n      })\n    );\n\n    return dialog;\n  }\n\n  private onStrandsUpdated(editorBody: HTMLDivElement) {\n    const controls = new StrandTerminalModificationControls(this.eventBus).create();\n\n    $(editorBody).empty();\n    $(editorBody).append(controls);\n  }\n\n  private resetToInitialState(): void {\n    // this.eventBus.setLastLoadedPatternConfig(this.initialPatternConfig);\n    this.eventBus.setPatternConfig(this.initialPatternConfig);\n  }\n}\n\nclass StrandTerminalModificationControls {\n  constructor(\n    private eventBus: EventBus\n  ) { }\n\n  create(): HTMLDivElement {\n    const inputPanels = STRANDS.map((strand) => this.constructControlsPanel(strand));\n\n    const container = ui.divH(inputPanels, {style: {gap: '24px'}});\n    return container;\n  }\n\n  private constructControlsPanel(strand: StrandType): HTMLDivElement {\n    if (!this.eventBus.isAntisenseStrandActive() && strand === STRAND.ANTISENSE)\n      return ui.div([]);\n\n    const modificationControls = this.createInputs(strand);\n\n    const container = ui.block([\n      ui.h1(`${STRAND_LABEL[strand]}`),\n      modificationControls,\n    ], {style: {paddingTop: '12px'}});\n\n    return container;\n  }\n\n  private createInputs(strand: StrandType): HTMLElement {\n    const termini = strand === STRAND.SENSE ? [...TERMINI].reverse() : TERMINI;\n    const inputs = termini.map((terminus) => this.createInputForTerminus(strand, terminus)) as DG.InputBase[];\n    return ui.form(inputs);\n  }\n\n  private createInputForTerminus(strand: StrandType, terminus: TERMINUS): StringInput {\n    const initialValue = this.eventBus.getTerminalModifications()[strand][terminus];\n    const input = ui.textInput(terminus, initialValue);\n    this.applyStylingToInput(input);\n\n    input.onInput(() => {\n      const newValue = input.value;\n      if (newValue === null)\n        return;\n\n      this.eventBus.updateTerminusModification(strand, terminus, newValue);\n    });\n\n    return input;\n  }\n\n  private applyStylingToInput(input: StringInput): void {\n    const textarea = input.root.getElementsByTagName('textarea')[0];\n    $(textarea).css('resize', 'none');\n  }\n}\n","\n      import API from \"!../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n       export default content && content.locals ? content.locals : undefined;\n","export const R_GROUP_ELEMENT_SYMBOL = 'R#';\nexport const HYDROGEN_SYMBOL = 'H';\nexport var V2K_CONST;\n(function (V2K_CONST) {\n    V2K_CONST[\"TYPE\"] = \"V2000\";\n    V2K_CONST[V2K_CONST[\"NUM_OF_HEADER_LINES\"] = 3] = \"NUM_OF_HEADER_LINES\";\n    V2K_CONST[V2K_CONST[\"NUM_OF_COUNTS_DIGITS\"] = 3] = \"NUM_OF_COUNTS_DIGITS\";\n    V2K_CONST[V2K_CONST[\"ATOM_TYPE_COL\"] = 4] = \"ATOM_TYPE_COL\";\n    V2K_CONST[V2K_CONST[\"FIRST_BONDED_ATOM_COL\"] = 1] = \"FIRST_BONDED_ATOM_COL\";\n    V2K_CONST[V2K_CONST[\"BOND_TYPE_COL\"] = 3] = \"BOND_TYPE_COL\";\n    V2K_CONST[V2K_CONST[\"RGP_SHIFT\"] = 8] = \"RGP_SHIFT\";\n    V2K_CONST[V2K_CONST[\"MAX_ATOM_COUNT\"] = 999] = \"MAX_ATOM_COUNT\";\n    V2K_CONST[\"RGP_LINE_START\"] = \"M  RGP\";\n    V2K_CONST[\"ATOM_ALIAS_LINE_START\"] = \"A  \";\n    V2K_CONST[\"END\"] = \"M  END\";\n})(V2K_CONST || (V2K_CONST = {}));\nexport const MALFORMED_MOL_V2000 = `\nMalformed\n\n  0  0  0  0  0  0  0  0  0  0999 V2000\nM  END`;\nexport const EMPTY_MOL_V3000 = `\nEmpty input\n\n  0  0  0  0  0  0            999 V3000\nM  END`;\n//# sourceMappingURL=data:application/json;base64,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","\n      import API from \"!../../../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n       export default content && content.locals ? content.locals : undefined;\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';\nimport {errorToConsole} from '@datagrok-libraries/utils/src/to-console';\n\nimport $ from 'cash-dom';\n\nconst InvalidMolfileError = class extends Error {\n  constructor(message: string) { super(message); }\n};\n\nexport class MoleculeImage {\n  constructor(molblok: string) {\n    this.molblock = molblok;\n  }\n\n  private _validMolBlock: string;\n  get molblock(): string { return this._validMolBlock; }\n\n  set molblock(value: string) {\n    if (value === '') {\n      this._validMolBlock = value;\n      return;\n    }\n\n    try {\n      this.validateMolBlock(value);\n    } catch (error) {\n      if (error instanceof InvalidMolfileError)\n        value = '';\n      const errorMessage = errorToConsole(error);\n      console.error(errorMessage);\n    }\n    this._validMolBlock = value;\n  }\n\n  private validateMolBlock(molblock: string): void {\n    // todo: add a sound criterion\n    if (molblock === '')\n      throw new InvalidMolfileError('MoleculeImage: invalid molblock');\n  }\n\n  private async drawMolBlockOnCanvas(canvas: HTMLCanvasElement): Promise<void> {\n    try {\n      await grok.functions.call('Chem:canvasMol', {\n        x: 0, y: 0, w: canvas.width, h: canvas.height, canvas: canvas,\n        molString: this.molblock, scaffoldMolString: '',\n        options: {normalizeDepiction: false, straightenDepiction: false}\n      });\n    } catch (err) {\n      const errStr = errorToConsole(err);\n      console.error(errStr);\n    }\n  };\n\n  private getMoleculeDimensions(): {height: number, width: number} {\n    const molData = MolfileHandler.getInstance(this.molblock);\n    const width: number = Math.max(...molData.x) - Math.min(...molData.x);\n    const height: number = Math.max(...molData.y) - Math.min(...molData.y);\n    return {height: height, width: width};\n  }\n\n  private async zoomIn(): Promise<void> {\n    const dialog = ui.dialog({title: 'Molecule', showFooter: false});\n    const dialogDivStyle = {\n      overflowX: 'scroll',\n    };\n\n    const height = $(window).height() * 0.7;\n    const molDimensions = this.getMoleculeDimensions();\n\n    const zoomRatio = height / molDimensions.height;\n\n    const dialogCanvasHeight = height;\n    const dialogCanvasWidth = molDimensions.width * zoomRatio;\n\n    const dialogCanvas = ui.canvas(dialogCanvasWidth, dialogCanvasHeight);\n    await this.drawMolBlockOnCanvas(dialogCanvas);\n\n    const dialogDiv = ui.block([dialogCanvas], {style: dialogDivStyle});\n    dialog.add(dialogDiv).showModal(true);\n\n    $(dialog.root).find('.d4-dialog-contents').removeClass('ui-form');\n    $(dialog.root).find('.d4-dialog-contents').removeClass('ui-panel');\n    $(dialog.root).find('.d4-dialog-contents').addClass('ui-box');\n    $(dialog.root).find('.d4-dialog-contents').css('padding', '0');\n  }\n\n  public async drawMolecule(\n    moleculeImgDiv: HTMLDivElement,\n    canvasWidth: number, canvasHeight: number\n  ): Promise<void> {\n    moleculeImgDiv.innerHTML = '';\n\n    const canvas = ui.canvas(canvasWidth * window.devicePixelRatio, canvasHeight * window.devicePixelRatio);\n\n    // Draw zoomed-out molecule\n    canvas.style.width = `${canvasWidth}px`;\n    canvas.style.height = `${canvasHeight}px`;\n    canvas.style.cursor = 'zoom-in';\n    /*\n    canvas.style.borderStyle = 'solid';\n    canvas.style.borderRadius = '1px';\n    canvas.style.borderColor = 'var(--grey-2)';\n    canvas.style.borderWidth = 'thin';\n    */\n    this.drawMolBlockOnCanvas(canvas);\n\n    // Dialog with zoomed-in molecule\n    canvas.addEventListener('click', async () => {\n      await this.zoomIn();\n    });\n    //$(canvas).on('click', async () => { await this.zoomIn(); });\n    //$(canvas).on('mouseover', () => $(canvas).css('cursor', 'grab')); // for some reason 'zoom-in' value wouldn't work\n    //$(canvas).on('mouseout', () => $(canvas).css('cursor', 'default'));\n\n    moleculeImgDiv.append(ui.tooltip.bind(canvas, 'Click to zoom'));\n  }\n}\n","\n      import API from \"!../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../../node_modules/css-loader/dist/cjs.js!./style.css\";\n       export default content && content.locals ? content.locals : undefined;\n","import DG from 'datagrok-api/dg';\nimport * as grok from 'datagrok-api/grok';\n\nimport {loadJsonData} from './apps/common/model/data-loader/json-loader';\nimport {MonomerLibWrapper} from './apps/common/model/monomer-lib/lib-wrapper';\nimport {OligoToolkitPackage} from './apps/common/model/oligo-toolkit-package';\nimport {FormatDetector} from './apps/common/model/parsing-validation/format-detector';\nimport {SequenceValidator} from './apps/common/model/parsing-validation/sequence-validator';\nimport {APP_NAME} from './apps/common/view/const';\nimport {getSpecifiedAppUI} from './apps/common/view/utils';\nimport {CombinedAppUI} from './apps/common/view/combined-app-ui';\nimport {linkStrandsV3000} from './apps/structure/model/mol-transformations';\nimport {SequenceToMolfileConverter} from './apps/structure/model/sequence-to-molfile';\nimport {FormatConverter} from './apps/translator/model/format-converter';\nimport {demoOligoPatternUI, demoOligoStructureUI, demoOligoTranslatorUI} from './demo/demo-st-ui';\nimport {getExternalAppViewFactories} from './plugins/mermade';\n\n//polytool specific\nimport {getPolyToolConversionDialog, getPolyToolEnumerationDialog} from './polytool/pt-dialog';\nimport {_setPeptideColumn} from './polytool/utils';\nimport {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';\n\n\nexport const _package: OligoToolkitPackage = new OligoToolkitPackage();\n\n//name: Oligo Toolkit\n//meta.icon: img/icons/toolkit.png\n//meta.browsePath: Oligo\n//tags: app\n//output: view v\nexport async function oligoToolkitApp(): Promise<DG.ViewBase> {\n  await initSequenceTranslatorLibData();\n  const externalViewFactories = await getExternalAppViewFactories();\n  if (!externalViewFactories)\n    throw new Error('External app view factories not loaded');\n  const appUI = new CombinedAppUI(externalViewFactories!);\n  const view = await appUI.getAppView();\n  return view;\n}\n\n//name: Oligo Translator\n//meta.icon: img/icons/translator.png\n//meta.browsePath: Oligo\n//tags: app\n//output: view v\nexport async function oligoTranslatorApp(): Promise<DG.ViewBase> {\n  const view = await getSpecifiedAppView(APP_NAME.TRANSLATOR);\n  return view;\n}\n\n//name: Oligo Pattern\n//meta.icon: img/icons/pattern.png\n//meta.browsePath: Oligo\n//tags: app\n//output: view v\nexport async function oligoPatternApp(): Promise<DG.ViewBase> {\n  const view = await getSpecifiedAppView(APP_NAME.PATTERN);\n  return view;\n}\n\n//name: Oligo Structure\n//meta.icon: img/icons/structure.png\n//meta.browsePath: Oligo\n//tags: app\n//output: view v\nexport async function oligoStructureApp(): Promise<DG.ViewBase> {\n  const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);\n  return view;\n}\n\n//name: initSequenceTranslatorLibData\nexport async function initSequenceTranslatorLibData(): Promise<void> {\n  await loadJsonData();\n  await _package.initMonomerLib();\n}\n\n//name: getCodeToWeightsMap\n//output: object result\nexport function getCodeToWeightsMap(): {[key: string]: number} {\n  const map = MonomerLibWrapper.getInstance().getCodesToWeightsMap();\n  return Object.fromEntries(map);\n}\n\n//name: validateSequence\n//input: string sequence\n//output: bool result\nexport function validateSequence(sequence: string): boolean {\n  const validator = new SequenceValidator(sequence);\n  const format = (new FormatDetector(sequence).getFormat());\n  return (format === null) ? false : validator.isValidSequence(format!);\n}\n\n//name: validateSequence\n//input: string sequence\n//input: bool invert\n//output: string result\nexport function getMolfileFromGcrsSequence(sequence: string, invert: boolean): string {\n  return (new SequenceToMolfileConverter(sequence, invert, 'GCRS')).convert();\n}\n\n//name: linkStrands\n//input: object strands\n//output: string result\nexport function linkStrands(strands: { senseStrands: string[], antiStrands: string[] }): string {\n  return linkStrandsV3000(strands, true);\n}\n\n//name: demoOligoTranslator\n//meta.demoPath: Bioinformatics | Oligo Toolkit | Translator\n//description: Translate oligonucleotide sequences across various formats accepted by different synthesizers\n//meta.path: /apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Translate\nexport async function demoTranslateSequence(): Promise<void> {\n  await demoOligoTranslatorUI();\n}\n\n//name: demoOligoPattern\n//meta.demoPath: Bioinformatics | Oligo Toolkit | Pattern\n//description: Design a modification pattern for an oligonucleotide sequence\n//meta.path:%20/apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Visualize%20duplex\nexport async function demoOligoPattern(): Promise<void> {\n  await demoOligoPatternUI();\n}\n\n//name: demoOligoStructure\n//meta.demoPath: Bioinformatics | Oligo Toolkit | Structure\n//description: Visualize duplex and save SDF\n//meta.path:%20/apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Visualize%20duplex\nexport async function demoOligoStructure(): Promise<void> {\n  await demoOligoStructureUI();\n}\n\n//name: translateOligonucleotideSequence\n//input: string sequence\n//input: string sourceFormat\n//input: string targetFormat\n//output: string result\nexport async function translateOligonucleotideSequence(\n  sequence: string, sourceFormat: string, targetFormat: string\n): Promise<string> {\n  await initSequenceTranslatorLibData();\n  return (new FormatConverter(sequence, sourceFormat)).convertTo(targetFormat);\n}\n\nasync function getSpecifiedAppView(appName: string): Promise<DG.ViewBase> {\n  await initSequenceTranslatorLibData();\n  const appUI = getSpecifiedAppUI(appName);\n  const view = await appUI.getAppView();\n  return view;\n}\n\n//top-menu: Bio | Convert | PolyTool-Convert\n//name: polyToolConvert\n//description: Perform cyclization of polymers\nexport async function polyToolConvert(): Promise<void> {\n  let dialog: DG.Dialog;\n  try {\n    dialog = await getPolyToolConversionDialog();\n    dialog.show();\n  } catch (err: any) {\n    grok.shell.warning('To run PolyTool Conversion, open a dataframe with macromolecules');\n  }\n}\n\n//top-menu: Bio | Convert | PolyTool-Enumerate\n//name: polyToolEnumerate\n//description: Perform cyclization of polymers\nexport async function polyToolEnumerate(): Promise<void> {\n  let dialog: DG.Dialog;\n  try {\n    dialog = await getPolyToolEnumerationDialog();\n    dialog.show();\n  } catch (err: any) {\n    grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');\n  }\n}\n\n//name: polyToolColumnChoice\n//input: dataframe df [Input data table]\n//input: column macroMolecule\nexport async function polyToolColumnChoice(df: DG.DataFrame, macroMolecule: DG.Column): Promise<void> {\n  _setPeptideColumn(macroMolecule);\n  await grok.data.detectSemanticTypes(df);\n}\n\n//name: createMonomerLibraryForPolyTool\n//input: file file\nexport async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {\n  const fileContent = await file.readAsString();\n  const libHandler = new PolyToolCsvLibHandler(file.fileName, fileContent);\n  const libObject = await libHandler.getJson();\n  const jsonFileName = file.fileName.replace(/\\.csv$/, '.json');\n  const jsonFileContent = JSON.stringify(libObject, null, 2);\n  DG.Utils.download(jsonFileName, jsonFileContent);\n}\n","module.exports = DG;","module.exports = grok;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.nc = undefined;","type Dict = {[key: string]: string};\n\nexport const formatsToHelm: {[key: string]: Dict} = {\n  'Axolabs': {\n    'UfAfsCfsGfuacg': 'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'\n  },\n  'BioSpring': {\n    'A*GC*123456789': 'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$'\n  },\n  'Mermade12': {\n    'hefglijkLIJKHEFG': 'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'\n  }\n};\n\nexport const helmToNucleotides: Dict = {\n  'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACG',\n\n  'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$': 'AGCUACGUACGC',\n\n  'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACGUACGUACG'\n};\n\nexport const helmToMolfile: Dict = {\n};\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {DEFAULT_FORMATS} from '../apps/common/model/const';\nimport {FormatConverter} from '../apps/translator/model/format-converter';\nimport {loadJsonData} from '../apps/common/model/data-loader/json-loader';\nimport {formatsToHelm} from './const';\nimport {_package} from '../package';\n\nfunction getHelm(strand: string, format: string): string {\n  return (new FormatConverter(strand, format).convertTo(DEFAULT_FORMATS.HELM));\n}\n\nfunction getFromat(helm: string, format: string): string {\n  return (new FormatConverter(helm, DEFAULT_FORMATS.HELM).convertTo(format));\n}\n\ncategory('Formats to HELM', () => {\n  before(async () => {\n    await loadJsonData();\n    await _package.initMonomerLib();\n  });\n\n  for (const format of Object.keys(formatsToHelm)) {\n    for (const [strand, helm] of Object.entries(formatsToHelm[format])) {\n      test(`${format} to HELM`, async () => {\n        const expected = helm;\n        const result = getHelm(strand, format);\n        expect(result, expected);\n      });\n    }\n  }\n});\n\ncategory('HELM to Formats', () => {\n  before(async () => {\n    await loadJsonData();\n    await _package.initMonomerLib();\n  });\n\n  for (const format of Object.keys(formatsToHelm)) {\n    for (const [strand, helm] of Object.entries(formatsToHelm[format])) {\n      test(`${format} to HELM`, async () => {\n        const expected = strand;\n        const result = getFromat(helm, format);\n        expect(result, expected);\n      });\n    }\n  }\n});\n","import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {getNucleotidesSequence} from '../apps/translator/model/conversion-utils';\nimport {loadJsonData} from '../apps/common/model/data-loader/json-loader';\nimport {helmToNucleotides} from './const';\nimport {_package} from '../package';\nimport {MonomerLibWrapper} from '../apps/common/model/monomer-lib/lib-wrapper';\n\ncategory('HELM to Nucleotides', () => {\n  before(async () => {\n    await loadJsonData();\n    await _package.initMonomerLib();\n  });\n\n  Object.entries(helmToNucleotides).forEach(([helm, nucleotide], idx) => {\n    test(`Sequence ${idx + 1} to nucleotides`, async () => {\n      const expected = nucleotide;\n      const result = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());\n      expect(result, expected);\n    });\n  });\n});\n","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {DEFAULT_FORMATS} from '../apps/common/model/const';\nimport {loadJsonData} from '../apps/common/model/data-loader/json-loader';\nimport {formatsToHelm} from './const';\nimport {SequenceValidator} from '../apps/common/model/parsing-validation/sequence-validator';\nimport {getTranslatedSequences} from '../apps/translator/model/conversion-utils';\nimport {_package} from '../package';\n\nfunction getTranslationObject(sequence: string, format: string): {[format: string]: string} {\n  const indexOfInvalidChar = (new SequenceValidator(sequence)).getInvalidCodeIndex(format);\n  return getTranslatedSequences(sequence, indexOfInvalidChar, format);\n}\n\nconst inputs = {\n  [DEFAULT_FORMATS.AXOLABS]: 'Afcgacsu',\n  [DEFAULT_FORMATS.HELM]: 'RNA1{[fR](A)p.[25r](C)p.[25r](G)p.[25r](A)p.[25r](C)[sp].[25r](U)}$$$$'\n};\n\ncategory('Formats support', () => {\n  before(async () => {\n    await loadJsonData();\n    await _package.initMonomerLib();\n  });\n\n  Object.entries(inputs).forEach(([format, sequence]) => {\n    test(`All formats for ${format}`, async () => {\n      const output = getTranslationObject(sequence, format);\n      const result = Object.keys(output).length;\n      // +1 due to nucleotides\n      const expected = Object.keys(formatsToHelm).length + 1;\n      expect(true, expected <= result);\n    });\n  });\n});\n","import * as DG from 'datagrok-api/dg';\nimport {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';\nimport './tests/formats-to-helm';\nimport './tests/helm-to-nucleotides';\nimport './tests/formats-support';\n\nexport const _package = new DG.Package();\nexport {tests};\n\n//name: test\n//input: string category {optional: true}\n//input: string test {optional: true}\n//input: object testContext {optional: true}\n//output: dataframe result\nexport async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {\n  const data = await runTests({category, test, testContext});\n  return DG.DataFrame.fromObjects(data)!;\n}\n"],"names":["testData","fromCsv","columns","add","fromList","BYTE_ARRAY","Array","from","Uint8Array","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","apply","STANDART_TIMEOUT","BENCHMARK_TIMEOUT","stdLog","console","log","bind","stdInfo","info","stdWarn","warn","stdError","error","tests","autoTestsCatName","demoCatName","detectorsCatName","coreCatName","wasRegistered","currentCategory","assure","notNull","name","Error","TestContext","constructor","catchUnhandled","report","this","undefined","Test","category","test","options","_a","timeout","push","expect","actual","expected","tests_","clear","before","addNamespace","s","f","replace","RegExp","nqName","runTests","_b","_c","_d","_e","_f","_g","package_","getCurrentCall","func","package","module","packageId","id","moduleTests","Object","keys","find","c","startsWith","testFunctions","tags","arr","split","pop","cat","length","join","isAggregated","outputs","moduleAutoTests","moduleDemo","moduleDetectors","packFunctions","functions","filter","list","reg","demo","isArray","i","res","matchAll","map","forEach","parseInt","eval","wait","delay","skipReason","skip","friendlyName","lastError","hasTag","col","clone","semType","initAutoTests","results","testContext","categories","logs","args","redefineConsole","key","entries","toLowerCase","exclude","some","skipped","every","t","x","beforeStatus","getResult","execTest","verbose","closeAll","data","d","after","afterStatus","success","ms","successful","r","failed","packageName","failed_","params","passed","type","usage","logger","description","assign","toString","stack","translateStackTrace","predicate","categoryTimeout","start","Date","now","timeout_","isInBenchmark","stats","sum","df","remove","rows","removeWhere","get","toCsv","reduce","acc","k","setTimeout","testTimeout","timeoutPromise","_","race","clearTimeout","fromColumns","fromStrings","___CSS_LOADER_EXPORT___","exports","cssWithMappingToString","item","content","needLayer","concat","modules","media","dedupe","supports","layer","alreadyImportedModules","_k","cssMapping","btoa","base64","unescape","encodeURIComponent","JSON","stringify","sourceMapping","__esModule","digestLength","blockSize","K","Uint32Array","hashBlocks","w","v","p","pos","len","a","b","g","h","u","j","t1","t2","Hash","state","Int32Array","temp","buffer","bufferLength","bytesHashed","finished","reset","prototype","clean","update","dataLength","dataPos","finish","out","left","bitLenHi","bitLenLo","padLength","digest","_saveState","_restoreState","HMAC","inner","outer","pad","istate","ostate","hash","hmac","fillBuffer","counter","num","hkdfSalt","hkdf","salt","okm","hmac_","bufpos","fill","pbkdf2","password","iterations","dkLen","prf","ctr","dk","factory","sha256","FUNC_ERROR_TEXT","HASH_UNDEFINED","PLACEHOLDER","WRAP_PARTIAL_FLAG","WRAP_ARY_FLAG","INFINITY","MAX_SAFE_INTEGER","NAN","MAX_ARRAY_LENGTH","wrapFlags","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","source","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","rePropName","reRegExpChar","reHasRegExpChar","reTrimStart","reWhitespace","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reForbiddenIdentifierChars","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsAstralRange","rsComboRange","rsComboMarksRange","rsDingbatRange","rsLowerRange","rsUpperRange","rsVarRange","rsBreakRange","rsMathOpRange","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsModifier","rsOptVar","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","parseFloat","freeParseInt","freeGlobal","freeSelf","self","root","Function","freeExports","nodeType","freeModule","moduleExports","freeProcess","process","nodeUtil","require","types","binding","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","call","arrayAggregator","array","setter","iteratee","accumulator","index","arrayEach","arrayEachRight","arrayEvery","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","arrayPush","values","offset","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","collection","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","object","basePropertyOf","baseReduce","current","baseTimes","n","baseTrim","string","slice","trimmedEndIndex","baseUnary","baseValues","props","cacheHas","cache","has","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","mapToArray","size","overArg","transform","arg","replaceHolders","placeholder","setToArray","set","setToPairs","stringSize","lastIndex","unicodeSize","stringToArray","match","unicodeToArray","asciiToArray","charAt","unescapeHtmlChar","runInContext","context","uid","defaults","pick","Math","String","TypeError","arrayProto","funcProto","objectProto","coreJsData","funcToString","hasOwnProperty","idCounter","maskSrcKey","exec","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","Buffer","Symbol","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","create","propertyIsEnumerable","splice","spreadableSymbol","isConcatSpreadable","symIterator","iterator","symToStringTag","toStringTag","defineProperty","getNative","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeCeil","ceil","nativeFloor","floor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeIsFinite","isFinite","nativeJoin","nativeKeys","nativeMax","max","nativeMin","min","nativeNow","nativeParseInt","nativeRandom","random","nativeReverse","reverse","DataView","Map","Set","WeakMap","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","symbolToString","lodash","isObjectLike","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","proto","isObject","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","entry","ListCache","MapCache","SetCache","__data__","Stack","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","copyObject","baseAt","paths","number","lower","upper","baseClone","bitmask","customizer","isDeep","isFlat","isFull","input","initCloneArray","tag","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","symbol","Ctor","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","cloneTypedArray","regexp","cloneRegExp","initCloneByTag","stacked","subValue","getAllKeysIn","getAllKeys","baseConformsTo","baseDelay","baseDifference","includes","isCommon","valuesLength","computed","valuesIndex","templateSettings","getMapData","pairs","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFilter","baseFlatten","depth","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","isFunction","baseGet","path","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","isOwn","unmasked","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInvoke","parent","last","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","message","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","property","baseKeys","isPrototype","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","safeGet","newValue","isTyped","isArrayLikeObject","isPlainObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","criteria","comparer","sort","objCriteria","othCriteria","ordersLength","compareAscending","compareMultiple","baseSortBy","basePickBy","baseSet","basePullAll","indexOf","basePullAt","indexes","previous","baseUnset","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","nested","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","end","baseSome","baseSortedIndex","retHighest","low","high","mid","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","copy","arrayBuffer","typedArray","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","iterable","createCaseFirst","methodName","trailing","createCompounder","callback","words","deburr","createCtor","arguments","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","wrapper","getFuncName","funcName","getData","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","countHolders","newHolders","createRecurry","fn","arrLength","oldArray","reorder","createInverter","toIteratee","baseInverter","createMathOperation","operator","defaultValue","createOver","arrayFunc","createPadding","chars","charsLength","createRange","toFinite","baseRange","createRelationalOperation","toNumber","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","precision","toInteger","pair","noop","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrStacked","arrValue","flatten","otherFunc","getValue","stubArray","hasPath","hasFunc","isLength","ArrayBuffer","ctorString","isMaskable","stubFalse","otherArgs","shortOut","reference","details","insertWrapDetails","updateWrapDetails","getWrapDetails","count","lastCalled","stamp","remaining","rand","memoize","charCodeAt","quote","subString","difference","differenceBy","differenceWith","findIndex","findLastIndex","head","intersection","mapped","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","group","unzipWith","without","xor","xorBy","xorWith","zip","zipWith","chain","interceptor","wrapperAt","countBy","findLast","forEachRight","groupBy","invokeMap","keyBy","partition","sortBy","bindKey","WRAP_BIND_FLAG","debounce","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","time","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","cancel","flush","defer","resolver","memoized","Cache","negate","overArgs","transforms","funcsLength","partial","partialRight","rearg","gt","gte","isError","isInteger","isNumber","isString","lt","lte","toArray","iteratorToArray","remainder","toLength","isBinary","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invert","invertBy","invoke","nativeKeysIn","isProto","baseKeysIn","merge","omit","CLONE_DEEP_FLAG","basePick","pickBy","prop","toPairs","toPairsIn","camelCase","word","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","toUpperCase","pattern","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","method","methodOf","mixin","over","overEvery","overSome","basePropertyDeep","range","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplier","multiplicand","round","subtract","minuend","subtrahend","castArray","chunk","compact","cond","conforms","baseConforms","properties","curry","curryRight","drop","dropRight","dropRightWhile","dropWhile","baseFill","flatMap","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","flip","fromPairs","functionsIn","initial","mapKeys","mapValues","matches","matchesProperty","nthArg","omitBy","once","orderBy","propertyOf","pullAllBy","pullAllWith","rest","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","separator","limit","spread","tail","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","unset","updateWith","valuesIn","wrap","zipObject","zipObjectDeep","entriesIn","extend","extendWith","clamp","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","target","position","escape","escapeRegExp","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isMatch","isMatchWith","isNaN","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","lastIndexOf","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","noConflict","strLength","padEnd","padStart","radix","floating","reduceRight","repeat","sample","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","sumBy","template","settings","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trim","trimEnd","trimStart","truncate","omission","search","substring","global","newEnd","uniqueId","prefix","each","eachRight","first","VERSION","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","dir","isRight","view","getView","iterLength","takeCount","iterIndex","commit","wrapped","toJSON","o","m","y","algorithm","createHash","l","write","dispatch","encoding","read","sha1","excludeValues","MD5","keysMD5","getHashes","ignoreUnknown","respectType","respectFunctionNames","respectFunctionProperties","unorderedArrays","unorderedSets","unorderedObjects","replacer","excludeKeys","_object","_array","_date","_symbol","_error","_boolean","_string","_function","_number","_xml","_null","_undefined","_regexp","_uint8array","_uint8clampedarray","_int8array","_uint16array","_int16array","_uint32array","_int32array","_float32array","_float64array","_arraybuffer","_url","_map","_set","_file","lastModfied","_blob","_domwindow","_bigint","_process","_timer","_pipe","_tcp","_udp","_tty","_statwatcher","_securecontext","_connection","_zlib","_context","_nodescript","_httpparser","_dataview","_signal","_fsevent","_tlswrap","buf","writeToStream","window","crypto","lYpoI2","toByteArray","fromByteArray","base64js","O","H","_useTypedArrays","_augment","_isBuffer","C","readUInt8","E","I","A","Y","B","F","L","U","D","SlowBuffer","INSPECT_MAX_BYTES","poolSize","foo","subarray","isEncoding","T","M","Number","substr","_charsWritten","N","fromCharCode","_arr","S","writeUInt8","readUInt16LE","readUInt16BE","readUInt32LE","readUInt32BE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","inspect","toArrayBuffer","decodeURIComponent","_get","toLocaleString","ieee754","md5","createHmac","randomBytes","NaN","pow","abs","LN2","nextTick","setImmediate","postMessage","addEventListener","stopPropagation","shift","title","browser","env","argv","on","addListener","off","removeListener","removeAllListeners","emit","cwd","chdir","out$","default","xmlNs","svgNs","urlRegex","fontFormats","woff2","woff","otf","ttf","eot","sfnt","svg","obj","HTMLElement","SVGElement","requireDomNode","el","requireDomNodePromise","getDimension","dim","viewBox","baseVal","getAttribute","getBoundingClientRect","style","getComputedStyle","getPropertyValue","uriToBlob","uri","byteString","atob","mimeString","intArray","Blob","cachedFonts","cachedRules","inlineCss","_ref","selectorRemap","modifyStyle","modifyCss","fonts","excludeUnusedCss","generateCss","selector","css","detectFonts","fontList","document","styleSheets","sheet","rules","cssRules","href","_ref2","rule","querySelector","parentNode","err","query","selectorText","cssText","font","url","fontUrl","formats","fullUrl","text","format","extension","detectCssFont","all","req","XMLHttpRequest","fontInBase64","binary","bytes","arrayBufferToBase64","response","fontUri","open","responseType","send","fontCss","inlineFonts","downloadOptions","navigator","msSaveOrOpenBlob","createElement","popup","prepareSvg","_ref3","_ref3$left","_ref3$top","top","width","height","_ref3$scale","scale","_ref3$responsive","responsive","_ref3$excludeCss","excludeCss","querySelectorAll","image","getAttributeNS","location","host","canvas","img","Image","crossOrigin","src","onerror","onload","getContext","drawImage","setAttributeNS","toDataURL","inlineImages","cloneNode","backgroundColor","_getDimensions","tagName","getBBox","_el$getBBox","getDimensions","setAttribute","createElementNS","appendChild","removeAttribute","foreignObject","innerHTML","defs","insertBefore","firstChild","svgAsDataUri","_ref4","svgXml","p1","svgAsPngUri","_ref5","_ref5$encoderType","encoderType","_ref5$encoderOptions","encoderOptions","canvg","convertToPng","_ref6","pixelRatio","devicePixelRatio","setTransform","png","SecurityError","download","saveLink","display","body","blob","URL","createObjectURL","onclick","requestAnimationFrame","revokeObjectURL","click","removeChild","saveSvg","downloadOpts","saveSvgAsPng","stylesInDOM","getIndexByIdentifier","identifier","modulesToDom","idCountMap","identifiers","base","indexByIdentifier","sourceMap","references","addElementStyle","byIndex","api","domAPI","newObj","lastIdentifiers","newList","newLastIdentifiers","_i","_index","memo","insert","styleTarget","HTMLIFrameElement","contentDocument","getTarget","element","setAttributes","attributes","styleElement","nonce","insertStyleElement","styleTagTransform","removeStyleElement","styleSheet","createTextNode","NUCLEOTIDES","DEFAULT_FORMATS","LIB_PATH","DEFAULT_LIB_FILENAME","APP_PATH","PATTERN_APP_DATA_FILENAME","CODES_TO_HELM_DICT_FILENAME","CODES_TO_SYMBOLS_FILENAME","MONOMERS_WITH_PHOSPHATE_FILENAME","fileSource","PATTERN_APP_DATA","CODES_TO_HELM_DICT","CODES_TO_SYMBOLS_DICT","MONOMERS_WITH_PHOSPHATE","async","loadJsonData","jsonFileNames","fileName","filePath","readAsText","parse","loadAndParseJson","sortByReverseLength","tryCatch","finallyFunc","callbackName","errMsg","MonomerLibWrapper","lib","_package","monomerLib","allMonomers","getAllMonomers","formatMonomerForViewer","sourceObj","formattedObject","getAllFormats","HELM","codes","code","polymerTypes","getPolymerTypes","polymerType","monomersByType","getMonomerSymbolsByType","monomerSymbol","getMonomer","monomer","getInstance","instance","getMolfileBySymbol","molfile","getNaturalAnalogBySymbol","naturalAnalog","isModification","getCodeToSymbolMap","getCodesByFormat","getTableForViewer","formattedObjects","fromObjects","getCodesToWeightsMap","codesToWeightsMap","dict","weight","SequenceValidator","sequence","libWrapper","getInvalidCodeIndex","firstUniqueCharacters","indexOfFirstInvalidChar","matchedCode","isValidSequence","linkStrandsV3000","strands","useChirality","macroMolBlock","atomBlock","bondBlock","collectionBlock","natom","nbond","xShift","antiStrands","invertNucleotidesV3000","inverted","molBlocks","senseStrands","ssYShift","replaceAll","numbers","extractAtomsBondsNumbersV3000","coordinates","extractAtomDataV3000","xShiftRight","yShift","indexAtoms","indexEnd","atomNumber","coordinate","indexAtomsEnd","indexBonds","bondNumber","indexBondEnd","indexCollection","collectionEnd","collNumber","entriesCurrent","molBlock","atomIndex","xCenter","yCenter","angle","PI","cos","sin","xAdd","atomsNumber","atomType","GROUP_TYPE","NUCLEOSIDE","LINKAGE","PHOSPHATE_SYMBOL","UNKNOWN_SYMBOL","getTranslatedSequences","sourceFormat","supportedFormats","outputFormats","localeCompare","converter","fromEntries","translation","convertTo","nucleotides","getNucleotidesSequence","helmString","re","branches","branch","stripped","targetFormat","getSupportedTargetFormats","inverseLengthComparator","FormatHandler","getFormats","getFormatNames","validateFormat","isHelm","getFormatCodes","getHelmToFormatDict","infoObj","helm","sorted","getHelmToCodeDict","getFormatToHelmDict","codesInfoObject","getTargetFormatHelmCodes","getTargetFormatHelmCodesRegExp","helmCodes","getRegExpPattern","getFormatRegExp","getNonHelmFormatRegExp","getPhosphateHelmCodesRegExp","phosphateHELMPattern","isValidFormat","formatCodes","HELM_WRAPPER","LEFT","RIGHT","FormatConverter","helmToFormat","formatToHelm","helmSequence","wrapperRegExp","helmRegExp","formatRegExp","phosphateRegExp","SEQUENCE_COPIED_MSG","SEQ_TOOLTIP_MSG","NUCLEOTIDES_FORMAT","StringMetricsNames","VectorMetricsNames","BitArrayMetricsNames","IntArrayMetricsNames","DistanceMetricsSubjects","NumberMetricsNames","NumberArrayMetricsNames","_length","_version","_updateLevel","_selectedCount","_selectedCountVersion","_selectedIndexesVersion","_versionedName","_versionedNameVersion","SHRINK_THRESHOLD","buff","_createBuffer","_data","getRawData","assureGoez","argName","assureInRange","dst","copyFrom","lengthInInts","version","incrementVersion","notify","versionedName","setLength","nIntsNeeded","fromAnd","set1","set2","fromValues","fromSeq","flag","setBit","fromString","fromUint32Array","fromBytes","num1","num2","countBits","equals","getBit","bitArray","init","setAll","flags","setIndexes","setFast","everyIndex","anyIndex","setWhere","check","allowClear","getRange","to","getRangeAsList","setRange","setTrue","setFalse","setRandom","and","andNot","notAnd","not","or","insertAt","oldlength","removeAt","contains","removeByMask","mask","dstIdx","srcIdx","findNext","bit","trueCount","falseCount","_onBitCount","remainingBits","countWhere","andWithCountBits","second","allTrue","allFalse","anyTrue","anyFalse","unusedBits","numInts","_firstOnBit","findPrev","_lastOnBit","Int8Array","MmDistanceFunctionsNames","HAMMING","LEVENSHTEIN","NEEDLEMANN_WUNSCH","MONOMER_CHEMICAL_DISTANCE","Tanimoto","Dice","Asymmetric","BraunBlanquet","Cosine","Kulczynski","McConnaughey","RogotGoldberg","Russel","Sokal","Hamming","Euclidean","CandidateType","alphabet","cutoff","TAGS","ALPHABET","NOTATION","wu","fasta","peptide","dna","rna","PT","DNA","RNA","Float32Array","makePalette","dt","simplified","PaletteType","palette","cp","objList","colour","ind","colourPalette","_palette","undefinedColor","Lesk","lesk","GrokGroups","grokGroups","RasMol","rasMol","resM","aaSynonyms","super","Aminoacids","getPalette","scheme","getInnerOuter","isInner","char","getColorAAPivot","chemPaletteInstance","outerMonomer","innerMonomer","amino","AAFullNames","SemType","SemTypeMultipleAlignment","Names","AASmiles","AASmilesTruncated","Nucleotides","StringUtils","hashCode","UnknownSeqPalette","UnknownColorPalette","buildPalette","pI","color","dgColor","fromHtml","distToBlack","sqrt","toRgb","correctColor","seqHandler","notationProvider","FASTA","SEPARATOR","OligoToolkitPackage","_monomerLib","initMonomerLib","pi","libHelper","funcList","prepare","getOutputParamValue","getMonomerLibHelper","readLibrary","close","ui","STRANDS","STRAND_LABEL","TERMINI","GRAPH_SETTINGS_KEYS","LEGEND_SETTINGS_KEYS","PATTERN_RECORD_KEYS","IS_ANTISENSE_STRAND_INCLUDED","NUCLEOTIDE_SEQUENCES","PHOSPHOROTHIOATE_LINKAGE_FLAGS","STRAND_TERMINUS_MODIFICATIONS","PATTERN_NAME","PATTERN_COMMENT","NUCLEOTIDES_WITH_NUMERIC_LABELS","PATTERN_CONFIG","AUTHOR_ID","rxjs","StrandEditingUtils","operators","getTruncatedStrandData","originalNucleotides","originalPTOFlags","newStrandLength","ptoFlags","getExtendedStrandData","sequenceBase","appendedNucleotidesLength","appendedFlagsLength","$","locals","HeaderControls","eventBus","initialPatternConfig","subscriptions","createAllPtoActivationInput","createFirstPtoInputs","gap","areAllPtoLinkagesSet","strand","nucleotideSequences","phosphorothioateLinkageFlags","initialValue","allPtoActivationInput","onInput","setAllPTOLinkages","subscription","phosphorothioateLingeFlagsChanged$","subscribe","getPatternConfig","addStyleToPtoInput","captionLabel","label","classList","textAlign","maxWidth","minWidth","isAntisenseStrandActive","isFirstPtoActive","firstPtoInput","setPhosphorothioateLinkageFlag","StrandControls","dataManager","nucleotideSequencesChanged$","displayedInputLabels","computeDisplayedInputLabels","inputPanels","constructControlsPanel","header","constructHeader","modificationControls","createControls","paddingTop","nucleobaseInputs","createNucleobaseInputs","labels","createLabelDivs","ptoLinkageInputs","createPTOFlagInputs","nucleobaseInput","idx","alignItems","nucleotideBaseChoices","fetchAvailableNucleotideBases","getNucleotideSequences","nucleotide","setNucleotide","getPhosphorothioateLinkageFlags","strandLabels","isOverhangNucleotide","labelDivs","createLabels","newLabel","empty","append","labelText","SubscriptionManager","rxjsSubscriptions","dgSubscriptions","Subscription","unsubscribeAll","subs","sub","unsubscribe","StrandEditorDialog","isDialogOpen","openDialog","createDialog","show","editorBody","strandsUpdated$","onStrandsUpdated","dialog","onOK","onCancel","resetToInitialState","onClose","headerControls","strandControls","setPatternConfig","TerminalModificationEditorDialog","controls","StrandTerminalModificationControls","createInputs","inputs","terminus","createInputForTerminus","getTerminalModifications","applyStylingToInput","updateTerminusModification","textarea","getElementsByTagName","V2K_CONST","DG","grok","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","getter","definition","enumerable","globalThis","nmd","children","nc","formatsToHelm","helmToNucleotides","getHelm","getFromat","AXOLABS","output","indexOfInvalidChar","getTranslationObject"],"sourceRoot":""}
+{"version":3,"file":"package-test.js","mappings":"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","sources":["webpack://sequencetranslator/./node_modules/fast-sha256/sha256.js","webpack://sequencetranslator/webpack/bootstrap","webpack://sequencetranslator/webpack/runtime/define property getters","webpack://sequencetranslator/webpack/runtime/hasOwnProperty shorthand","webpack://sequencetranslator/webpack/runtime/make namespace object","webpack://sequencetranslator/external var \"DG\"","webpack://sequencetranslator/external var \"grok\"","webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/dataframe-utils.js","webpack://sequencetranslator/./node_modules/@datagrok-libraries/utils/src/test.js","webpack://sequencetranslator/./src/apps/common/model/const.ts","webpack://sequencetranslator/./src/tests/utils.ts","webpack://sequencetranslator/./src/tests/const.ts","webpack://sequencetranslator/./src/tests/formats-to-helm.ts","webpack://sequencetranslator/./src/apps/translator/model/const.ts","webpack://sequencetranslator/./src/apps/translator/model/conversion-utils.ts","webpack://sequencetranslator/./src/tests/helm-to-nucleotides.ts","webpack://sequencetranslator/./src/tests/formats-support.ts","webpack://sequencetranslator/./node_modules/@datagrok-libraries/bio/src/utils/err-info.js","webpack://sequencetranslator/./src/tests/files-tests.ts","webpack://sequencetranslator/./src/package-test.ts"],"sourcesContent":["(function (root, factory) {\n    // Hack to make all exports of this module sha256 function object properties.\n    var exports = {};\n    factory(exports);\n    var sha256 = exports[\"default\"];\n    for (var k in exports) {\n        sha256[k] = exports[k];\n    }\n        \n    if (typeof module === 'object' && typeof module.exports === 'object') {\n        module.exports = sha256;\n    } else if (typeof define === 'function' && define.amd) {\n        define(function() { return sha256; }); \n    } else {\n        root.sha256 = sha256;\n    }\n})(this, function(exports) {\n\"use strict\";\nexports.__esModule = true;\n// SHA-256 (+ HMAC and PBKDF2) for JavaScript.\n//\n// Written in 2014-2016 by Dmitry Chestnykh.\n// Public domain, no warranty.\n//\n// Functions (accept and return Uint8Arrays):\n//\n//   sha256(message) -> hash\n//   sha256.hmac(key, message) -> mac\n//   sha256.pbkdf2(password, salt, rounds, dkLen) -> dk\n//\n//  Classes:\n//\n//   new sha256.Hash()\n//   new sha256.HMAC(key)\n//\nexports.digestLength = 32;\nexports.blockSize = 64;\n// SHA-256 constants\nvar K = new Uint32Array([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n    0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n    0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n    0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n    0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n    0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n    0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\nfunction hashBlocks(w, v, p, pos, len) {\n    var a, b, c, d, e, f, g, h, u, i, j, t1, t2;\n    while (len >= 64) {\n        a = v[0];\n        b = v[1];\n        c = v[2];\n        d = v[3];\n        e = v[4];\n        f = v[5];\n        g = v[6];\n        h = v[7];\n        for (i = 0; i < 16; i++) {\n            j = pos + i * 4;\n            w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16) |\n                ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));\n        }\n        for (i = 16; i < 64; i++) {\n            u = w[i - 2];\n            t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);\n            u = w[i - 15];\n            t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);\n            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);\n        }\n        for (i = 0; i < 64; i++) {\n            t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11)) ^\n                (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0) +\n                ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n            t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13)) ^\n                (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n            h = g;\n            g = f;\n            f = e;\n            e = (d + t1) | 0;\n            d = c;\n            c = b;\n            b = a;\n            a = (t1 + t2) | 0;\n        }\n        v[0] += a;\n        v[1] += b;\n        v[2] += c;\n        v[3] += d;\n        v[4] += e;\n        v[5] += f;\n        v[6] += g;\n        v[7] += h;\n        pos += 64;\n        len -= 64;\n    }\n    return pos;\n}\n// Hash implements SHA256 hash algorithm.\nvar Hash = /** @class */ (function () {\n    function Hash() {\n        this.digestLength = exports.digestLength;\n        this.blockSize = exports.blockSize;\n        // Note: Int32Array is used instead of Uint32Array for performance reasons.\n        this.state = new Int32Array(8); // hash state\n        this.temp = new Int32Array(64); // temporary state\n        this.buffer = new Uint8Array(128); // buffer for data to hash\n        this.bufferLength = 0; // number of bytes in buffer\n        this.bytesHashed = 0; // number of total bytes hashed\n        this.finished = false; // indicates whether the hash was finalized\n        this.reset();\n    }\n    // Resets hash state making it possible\n    // to re-use this instance to hash other data.\n    Hash.prototype.reset = function () {\n        this.state[0] = 0x6a09e667;\n        this.state[1] = 0xbb67ae85;\n        this.state[2] = 0x3c6ef372;\n        this.state[3] = 0xa54ff53a;\n        this.state[4] = 0x510e527f;\n        this.state[5] = 0x9b05688c;\n        this.state[6] = 0x1f83d9ab;\n        this.state[7] = 0x5be0cd19;\n        this.bufferLength = 0;\n        this.bytesHashed = 0;\n        this.finished = false;\n        return this;\n    };\n    // Cleans internal buffers and re-initializes hash state.\n    Hash.prototype.clean = function () {\n        for (var i = 0; i < this.buffer.length; i++) {\n            this.buffer[i] = 0;\n        }\n        for (var i = 0; i < this.temp.length; i++) {\n            this.temp[i] = 0;\n        }\n        this.reset();\n    };\n    // Updates hash state with the given data.\n    //\n    // Optionally, length of the data can be specified to hash\n    // fewer bytes than data.length.\n    //\n    // Throws error when trying to update already finalized hash:\n    // instance must be reset to use it again.\n    Hash.prototype.update = function (data, dataLength) {\n        if (dataLength === void 0) { dataLength = data.length; }\n        if (this.finished) {\n            throw new Error(\"SHA256: can't update because hash was finished.\");\n        }\n        var dataPos = 0;\n        this.bytesHashed += dataLength;\n        if (this.bufferLength > 0) {\n            while (this.bufferLength < 64 && dataLength > 0) {\n                this.buffer[this.bufferLength++] = data[dataPos++];\n                dataLength--;\n            }\n            if (this.bufferLength === 64) {\n                hashBlocks(this.temp, this.state, this.buffer, 0, 64);\n                this.bufferLength = 0;\n            }\n        }\n        if (dataLength >= 64) {\n            dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);\n            dataLength %= 64;\n        }\n        while (dataLength > 0) {\n            this.buffer[this.bufferLength++] = data[dataPos++];\n            dataLength--;\n        }\n        return this;\n    };\n    // Finalizes hash state and puts hash into out.\n    //\n    // If hash was already finalized, puts the same value.\n    Hash.prototype.finish = function (out) {\n        if (!this.finished) {\n            var bytesHashed = this.bytesHashed;\n            var left = this.bufferLength;\n            var bitLenHi = (bytesHashed / 0x20000000) | 0;\n            var bitLenLo = bytesHashed << 3;\n            var padLength = (bytesHashed % 64 < 56) ? 64 : 128;\n            this.buffer[left] = 0x80;\n            for (var i = left + 1; i < padLength - 8; i++) {\n                this.buffer[i] = 0;\n            }\n            this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;\n            this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;\n            this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;\n            this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;\n            this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;\n            this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;\n            this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;\n            this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;\n            hashBlocks(this.temp, this.state, this.buffer, 0, padLength);\n            this.finished = true;\n        }\n        for (var i = 0; i < 8; i++) {\n            out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;\n            out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;\n            out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;\n            out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;\n        }\n        return this;\n    };\n    // Returns the final hash digest.\n    Hash.prototype.digest = function () {\n        var out = new Uint8Array(this.digestLength);\n        this.finish(out);\n        return out;\n    };\n    // Internal function for use in HMAC for optimization.\n    Hash.prototype._saveState = function (out) {\n        for (var i = 0; i < this.state.length; i++) {\n            out[i] = this.state[i];\n        }\n    };\n    // Internal function for use in HMAC for optimization.\n    Hash.prototype._restoreState = function (from, bytesHashed) {\n        for (var i = 0; i < this.state.length; i++) {\n            this.state[i] = from[i];\n        }\n        this.bytesHashed = bytesHashed;\n        this.finished = false;\n        this.bufferLength = 0;\n    };\n    return Hash;\n}());\nexports.Hash = Hash;\n// HMAC implements HMAC-SHA256 message authentication algorithm.\nvar HMAC = /** @class */ (function () {\n    function HMAC(key) {\n        this.inner = new Hash();\n        this.outer = new Hash();\n        this.blockSize = this.inner.blockSize;\n        this.digestLength = this.inner.digestLength;\n        var pad = new Uint8Array(this.blockSize);\n        if (key.length > this.blockSize) {\n            (new Hash()).update(key).finish(pad).clean();\n        }\n        else {\n            for (var i = 0; i < key.length; i++) {\n                pad[i] = key[i];\n            }\n        }\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] ^= 0x36;\n        }\n        this.inner.update(pad);\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] ^= 0x36 ^ 0x5c;\n        }\n        this.outer.update(pad);\n        this.istate = new Uint32Array(8);\n        this.ostate = new Uint32Array(8);\n        this.inner._saveState(this.istate);\n        this.outer._saveState(this.ostate);\n        for (var i = 0; i < pad.length; i++) {\n            pad[i] = 0;\n        }\n    }\n    // Returns HMAC state to the state initialized with key\n    // to make it possible to run HMAC over the other data with the same\n    // key without creating a new instance.\n    HMAC.prototype.reset = function () {\n        this.inner._restoreState(this.istate, this.inner.blockSize);\n        this.outer._restoreState(this.ostate, this.outer.blockSize);\n        return this;\n    };\n    // Cleans HMAC state.\n    HMAC.prototype.clean = function () {\n        for (var i = 0; i < this.istate.length; i++) {\n            this.ostate[i] = this.istate[i] = 0;\n        }\n        this.inner.clean();\n        this.outer.clean();\n    };\n    // Updates state with provided data.\n    HMAC.prototype.update = function (data) {\n        this.inner.update(data);\n        return this;\n    };\n    // Finalizes HMAC and puts the result in out.\n    HMAC.prototype.finish = function (out) {\n        if (this.outer.finished) {\n            this.outer.finish(out);\n        }\n        else {\n            this.inner.finish(out);\n            this.outer.update(out, this.digestLength).finish(out);\n        }\n        return this;\n    };\n    // Returns message authentication code.\n    HMAC.prototype.digest = function () {\n        var out = new Uint8Array(this.digestLength);\n        this.finish(out);\n        return out;\n    };\n    return HMAC;\n}());\nexports.HMAC = HMAC;\n// Returns SHA256 hash of data.\nfunction hash(data) {\n    var h = (new Hash()).update(data);\n    var digest = h.digest();\n    h.clean();\n    return digest;\n}\nexports.hash = hash;\n// Function hash is both available as module.hash and as default export.\nexports[\"default\"] = hash;\n// Returns HMAC-SHA256 of data under the key.\nfunction hmac(key, data) {\n    var h = (new HMAC(key)).update(data);\n    var digest = h.digest();\n    h.clean();\n    return digest;\n}\nexports.hmac = hmac;\n// Fills hkdf buffer like this:\n// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)\nfunction fillBuffer(buffer, hmac, info, counter) {\n    // Counter is a byte value: check if it overflowed.\n    var num = counter[0];\n    if (num === 0) {\n        throw new Error(\"hkdf: cannot expand more\");\n    }\n    // Prepare HMAC instance for new data with old key.\n    hmac.reset();\n    // Hash in previous output if it was generated\n    // (i.e. counter is greater than 1).\n    if (num > 1) {\n        hmac.update(buffer);\n    }\n    // Hash in info if it exists.\n    if (info) {\n        hmac.update(info);\n    }\n    // Hash in the counter.\n    hmac.update(counter);\n    // Output result to buffer and clean HMAC instance.\n    hmac.finish(buffer);\n    // Increment counter inside typed array, this works properly.\n    counter[0]++;\n}\nvar hkdfSalt = new Uint8Array(exports.digestLength); // Filled with zeroes.\nfunction hkdf(key, salt, info, length) {\n    if (salt === void 0) { salt = hkdfSalt; }\n    if (length === void 0) { length = 32; }\n    var counter = new Uint8Array([1]);\n    // HKDF-Extract uses salt as HMAC key, and key as data.\n    var okm = hmac(salt, key);\n    // Initialize HMAC for expanding with extracted key.\n    // Ensure no collisions with `hmac` function.\n    var hmac_ = new HMAC(okm);\n    // Allocate buffer.\n    var buffer = new Uint8Array(hmac_.digestLength);\n    var bufpos = buffer.length;\n    var out = new Uint8Array(length);\n    for (var i = 0; i < length; i++) {\n        if (bufpos === buffer.length) {\n            fillBuffer(buffer, hmac_, info, counter);\n            bufpos = 0;\n        }\n        out[i] = buffer[bufpos++];\n    }\n    hmac_.clean();\n    buffer.fill(0);\n    counter.fill(0);\n    return out;\n}\nexports.hkdf = hkdf;\n// Derives a key from password and salt using PBKDF2-HMAC-SHA256\n// with the given number of iterations.\n//\n// The number of bytes returned is equal to dkLen.\n//\n// (For better security, avoid dkLen greater than hash length - 32 bytes).\nfunction pbkdf2(password, salt, iterations, dkLen) {\n    var prf = new HMAC(password);\n    var len = prf.digestLength;\n    var ctr = new Uint8Array(4);\n    var t = new Uint8Array(len);\n    var u = new Uint8Array(len);\n    var dk = new Uint8Array(dkLen);\n    for (var i = 0; i * len < dkLen; i++) {\n        var c = i + 1;\n        ctr[0] = (c >>> 24) & 0xff;\n        ctr[1] = (c >>> 16) & 0xff;\n        ctr[2] = (c >>> 8) & 0xff;\n        ctr[3] = (c >>> 0) & 0xff;\n        prf.reset();\n        prf.update(salt);\n        prf.update(ctr);\n        prf.finish(u);\n        for (var j = 0; j < len; j++) {\n            t[j] = u[j];\n        }\n        for (var j = 2; j <= iterations; j++) {\n            prf.reset();\n            prf.update(u).finish(u);\n            for (var k = 0; k < len; k++) {\n                t[k] ^= u[k];\n            }\n        }\n        for (var j = 0; j < len && i * len + j < dkLen; j++) {\n            dk[i * len + j] = t[j];\n        }\n    }\n    for (var i = 0; i < len; i++) {\n        t[i] = u[i] = 0;\n    }\n    for (var i = 0; i < 4; i++) {\n        ctr[i] = 0;\n    }\n    prf.clean();\n    return dk;\n}\nexports.pbkdf2 = pbkdf2;\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","const __WEBPACK_NAMESPACE_OBJECT__ = DG;","const __WEBPACK_NAMESPACE_OBJECT__ = grok;","/* eslint-disable max-len */\nimport * as DG from 'datagrok-api/dg';\nimport * as sha256 from 'fast-sha256';\n/**\n * For columns of string type. Checks whether column contains empty values and removes corresponding rows in case user selects to remove.\n *\n */\nexport function removeEmptyStringRows(table, col) {\n    const cats = col.categories;\n    const emptyRawInd = cats.map((val, ind) => !val ? ind : null).filter((it) => it !== null);\n    const rawData = [...col.getRawData()];\n    const emptyRawsIndexes = [];\n    let removedRowsCounter = 0;\n    for (let i = 0; i < table.rowCount; i++) {\n        if (emptyRawInd.includes(rawData[i])) {\n            table.rows.removeAt(i - removedRowsCounter);\n            emptyRawsIndexes.push(i);\n            removedRowsCounter += 1;\n        }\n    }\n    return emptyRawsIndexes;\n}\nexport function hashDataFrame(table, names) {\n    names !== null && names !== void 0 ? names : (names = table.columns.names());\n    const hasher = new sha256.Hash();\n    const order = table.getSortedOrder(names);\n    const encoder = new TextEncoder();\n    for (const name of names) {\n        const column = table.columns.byName(name);\n        const dataArray = column.getRawData();\n        const isString = column.type == DG.TYPE.STRING;\n        const cats = column.categories;\n        for (let i = 0; i < dataArray.length; i++) {\n            if (isString) {\n                const data = cats[dataArray[order[i]]];\n                hasher.update(encoder.encode(data));\n            }\n            else {\n                const data = dataArray[order[i]];\n                hasher.update(Uint8Array.from([data]));\n            }\n        }\n    }\n    return hasher.digest();\n}\nexport const testData = DG.DataFrame.fromCsv(`countries,fasta,smiles,molregno,LON,Zip Code,Street Address Line 1,ImageUrl,user_id,error_message,xray,flag,magnitude,CS-id,pdb_id,accel_a,time_offset,chart,fit,Questions,empty_number,empty_string\nBelgium,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C(=O)OCCCc1cccnc1)c2cccc(c2)C(=O)c3ccccc3,1480014,36.276729583740234,995042300,14016 ROUTE 31W,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,1,1,1QBS,1,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.497360340644872, 1.7058694986686864, 5.278052678195135, 0.16000320889028383],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.374499797821045},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.6242473125457764},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.367267608642578},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.6723148822784424},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.6537344455718994},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.3651671409606934},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.5654284954071045},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.4160959720611572},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.286726713180542},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.5100042819976807},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6676985025405884},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.680136501789093},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3391543924808502},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.09038983285427094},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.19802775979042053}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[7.525235855508179, 1.3186911876809984, 5.335672608564294, 0.7860743343958098],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":7.988070487976074},{\"\"x\"\":0.6000000238418579,\"\"y\"\":7.018453121185303},{\"\"x\"\":1.100000023841858,\"\"y\"\":8.115279197692871},{\"\"x\"\":1.600000023841858,\"\"y\"\":7.486658096313477},{\"\"x\"\":2.0999999046325684,\"\"y\"\":7.396438121795654},{\"\"x\"\":2.5999999046325684,\"\"y\"\":7.477052211761475},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.913095474243164},{\"\"x\"\":3.5999999046325684,\"\"y\"\":8.01385498046875},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.985900402069092},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.970335960388184},{\"\"x\"\":5.099999904632568,\"\"y\"\":5.448817253112793},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.5534818172454834},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.893947958946228},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6340042352676392},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8403874039649963}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,100,abc\nBurundi,MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW,COc1ccc2cc(ccc2c1)C(C)C(=O)Oc3ccc(C)cc3OC,1480015,36.276729583740234,995073444,80 STATE HIGHWAY 310,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,2,2,1ZP8,2,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.431460753103398, 2.1691498799246745, 5.266445597102774, 0.7825762827017926],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.751083850860596},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.203000068664551},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.415858745574951},{\"\"x\"\":1.600000023841858,\"\"y\"\":4.68414306640625},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.198400974273682},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.179222106933594},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.638473987579346},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.708553314208984},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.291589260101318},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.038082599639893},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4349939823150635},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.2194708585739136},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.1920831203460693},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.5352635979652405},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.3346920311450958}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.339458017970126, -1.0734184310171178, 4.746332950550934, 0.2482416857595658],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.2139337658882141},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.4269562065601349},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.2441573292016983},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.146635964512825},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.08818462491035461},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.2560656666755676},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.42434045672416687},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.37111231684684753},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.5581737160682678},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.183590054512024},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.5629843473434448},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3211288452148438},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.229961633682251},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.2560226917266846},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.2142398357391357}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCameroon,MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL,COc1ccc2cc(ccc2c1)C(C)C(=O)OCCCc3cccnc3,1480016,36.26095962524414,995153596,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,3,3,2BDJ,3,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.6760652578642325, 0.9046956320756703, 5.651408971856738, 0.07738846012184185],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.32425594329834},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.668442249298096},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.379785060882568},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.0345139503479},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.878653526306152},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.3451313972473145},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.336992263793945},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.037430286407471},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.0092692375183105},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.151902675628662},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4066951274871826},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3732759952545166},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.673728108406067},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48574790358543396},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.2783052325248718}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.938395863010111, -1.4658480661392117, 5.462702751996584, 0.3473139023615039],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.4941710829734802},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.15323974192142487},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.46373432874679565},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.3370431363582611},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.5179030299186707},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.27899765968322754},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.22075064480304718},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.5789918899536133},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.21169911324977875},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.27857646346092224},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0906332731246948},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8520300388336182},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.7177059650421143},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.8680918216705322},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.2413077354431152}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCanada,MMELVLKTIIGPIVVGVVLRIVDKWLNKDK,CC(C(=O)NCCS)c1cccc(c1)C(=O)c2ccccc2,1480017,36.26095962524414,99515,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,4,4,1IAN,4,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[0.8597390975430008, 1.0957625732481946, 5.260537067987958, 0.07974187998177736],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.8190152645111084},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.8421689867973328},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.8740922212600708},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.8924275040626526},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.8249067664146423},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.9327669143676758},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.8522974252700806},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.8174492716789246},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.8394647240638733},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.7139387726783752},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.5561167597770691},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3276226818561554},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.12479474395513535},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.13006797432899475},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.059702079743146896}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.760930219582546, 1.6591793293833013, 4.667155929720851, 0.7858109544121652],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.156993389129639},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.236701965332031},{\"\"x\"\":1.100000023841858,\"\"y\"\":6.010560512542725},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.495512962341309},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.087770462036133},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.79986572265625},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.597546577453613},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.520902156829834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.360654354095459},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.5539746284484863},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.577236294746399},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.0001264810562134},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.9305797815322876},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6033638715744019},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.4203685522079468}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nColombia,MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN,FC(F)(F)c1ccc(OC2CCNCC2)cc1,1480029,36.3309440612793,995152050,1 COURT HOUSE SQUARE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,5,5,4UJ1,5,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[6.4995088314153655, 2.4270351004539914, 5.178659535348579, 0.625653346241577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.496231555938721},{\"\"x\"\":0.6000000238418579,\"\"y\"\":6.42543363571167},{\"\"x\"\":1.100000023841858,\"\"y\"\":7.040063858032227},{\"\"x\"\":1.600000023841858,\"\"y\"\":6.1115403175354},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.680728435516357},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.406774520874023},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.611269474029541},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.889094352722168},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.75344705581665},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.361435890197754},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.1666975021362305},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.172118902206421},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.801048994064331},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.4640021026134491},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.0010357667924836278}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.4734381347446401, 1.1649805188074196, 4.82958608866421, 0.09500545496710007],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.5279096364974976},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.3559974431991577},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.5246378183364868},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.5567657947540283},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.4114240407943726},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.4045010805130005},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.4769829511642456},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.4875500202178955},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.2991987466812134},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.922961413860321},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.6520044803619385},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.15350978076457977},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1078903079032898},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.17276449501514435},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.14066608250141144}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCosta Rica,MKSTKEEIQTIKTLLKDSRTAKYHKRLQIVL,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCCc3ccccc3,1480018,36.3309440612793,995084218,4041 SOUTHWESTERN BLVD,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,6,6,2BPW,6,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.4833641843311227, -1.8945978742090062, 4.671127708092568, 0.24159861311815153],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.0969524160027504},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.028483040630817413},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.22087176144123077},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.0068915546871721745},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.4305879771709442},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.44774115085601807},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.45346319675445557},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.2370593100786209},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.4657953977584839},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.155200719833374},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.2294070720672607},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.4311530590057373},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.33846116065979},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.608201026916504},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.8136143684387207}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.224573521642033, 1.4454033924198528, 5.6014197746076535, 0.2823216054197577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.95027494430542},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.1754679679870605},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.276752948760986},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.589294910430908},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.616994857788086},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.120813846588135},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.340766906738281},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.876471042633057},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.94999361038208},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.162564754486084},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.399557590484619},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.7977969646453857},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.0229872465133667},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48275601863861084},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.10408931970596313}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCuba,MHAILRYFIRRLFYHIFYKIYSLISKKHQSLPSDVRQF,COc1ccc2c(c1)c(CC(=O)N3CCCC3C(=O)Oc4ccc(C)cc4OC)c(C)n2C(=O)c5ccc(Cl)cc5,1480019,36.33115768432617,995081928,1227 US HIGHWAY 11,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,7,7,1QBS,7,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.320838679713925, -1.2421619987316728, 4.831325425225256, 0.3236011098403072],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.3727470338344574},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.12365014106035233},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.48422467708587646},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.2264465093612671},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.16821794211864471},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.3879014551639557},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.5470244884490967},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.3419053554534912},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.7655120491981506},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.2346516847610474},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.453336715698242},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.9565491676330566},{\"\"x\"\":6.099999904632568,\"\"y\"\":3.335299491882324},{\"\"x\"\":6.599999904632568,\"\"y\"\":3.240290880203247},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.1107218265533447}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.6401853521511094, 1.26211588875013, 5.399028074402744, 0.5089580830068091],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.8585598468780518},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.6077206134796143},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.855252265930176},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.619039297103882},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.839388370513916},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.335283041000366},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.571141481399536},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.4155046939849854},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7316646575927734},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.0680155754089355},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.891066551208496},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.6022753715515137},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.7652576565742493},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6875326037406921},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5828871726989746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nItaly,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO[N+](=O)[O-],1480020,36.33115768432617,99502,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,8,8,1ZP8,8,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.293592105923809, 1.3781586549141835, 5.1025898038676605, 0.03493851245291291],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.1287283897399902},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.267972230911255},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.398442506790161},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.5130622386932373},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.3255116939544678},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.127340793609619},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.47259783744812},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.131181478500366},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.090421438217163},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.02299165725708},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.1105059385299683},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.4494485855102539},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1375635862350464},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.036351121962070465},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.1619771122932434}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.953125499439879, 1.2528620255306528, 5.187637440149802, 0.3110348753260886],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.6585283279418945},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.911152362823486},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.924920082092285},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.8469438552856445},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.929472923278809},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.190037727355957},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.236179828643799},{\"\"x\"\":3.5999999046325684,\"\"y\"\":6.141019344329834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.295210838317871},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.265801906585693},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.3722851276397705},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8299226760864258},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.32690900564193726},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6274543404579163},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8441857099533081}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nRwanda,MPNSEPASLLELFNSIATQGELVRSLKAGNASK,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO,1480021,36.33137130737305,995037247,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,9,2BDJ,9,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.8209972202654474, 1.3779216716448506, 5.299882228439686, 0.06040645519069608],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.7821109294891357},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.542433023452759},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.7008674144744873},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.717301607131958},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.024452209472656},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.013899326324463},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.945094347000122},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.866621971130371},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7461626529693604},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.3454740047454834},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.61944317817688},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.999405026435852},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.46259793639183044},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.054134611040353775},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.05711187422275543}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.6318079657726035, 1.8495493770000595, 5.391793312471116, 0.17060707587348442],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.458079814910889},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.554427146911621},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.799983024597168},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.364140033721924},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.864485740661621},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.4509806632995605},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.702574729919434},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.7314534187316895},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.5123443603515625},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.724395751953125},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.354506969451904},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.7307666540145874},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.6305936574935913},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.035183437168598175},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.7575169205665588}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nSwitzerland,IRVVGRYLIEVWKAAGMDMDKVLFLWSSDEI,CN1CCC(CC1)Oc2ccc(cc2)C(F)(F)F,1480028,36.33137130737305,99504,92-11 179TH PLACE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,10,1IAN,10,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.1190255865097471, 2.3163895161544437, 5.4968866182279195, 0.2035204047289052],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.1057683229446411},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.1019697189331055},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.0818607807159424},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.062997817993164},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.046447515487671},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.1217249631881714},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.2166996002197266},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.215477705001831},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.0581893920898438},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.1747995615005493},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0181127786636353},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.5344523191452026},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.2569526433944702},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.1912207305431366},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.15060538053512573}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.1038581025805785, 2.0032224204185245, 5.087602825989163, 0.13277988512492753],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.0498509407043457},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.805217742919922},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.3415253162384033},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.0549843311309814},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.250074863433838},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.0432586669921875},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.265852451324463},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.9475724697113037},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.1929898262023926},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.7460060119628906},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6175861358642578},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3006608486175537},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3444803059101105},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.015537971630692482},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5527358055114746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\n,,,,,,,,,,,,,,,,,,,,,`);\ntestData.columns.add(DG.Column.fromList(DG.TYPE.BYTE_ARRAY, 'BinaryImage', Array.from(new Uint8Array(11))));\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dataframe-utils.js","sourceRoot":"","sources":["dataframe-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport * as DG from 'datagrok-api/dg';\nimport * as sha256 from 'fast-sha256';\n/**\n * For columns of string type. Checks whether column contains empty values and removes corresponding rows in case user selects to remove.\n *\n */\nexport function removeEmptyStringRows(table: DG.DataFrame, col: DG.Column): number[] {\n  const cats = col.categories;\n  const emptyRawInd = cats.map((val, ind) => !val ? ind : null).filter((it) => it !== null);\n  const rawData = [...col.getRawData()];\n  const emptyRawsIndexes = [];\n  let removedRowsCounter = 0;\n  for (let i = 0; i < table.rowCount; i++) {\n    if (emptyRawInd.includes(rawData[i])) {\n      table.rows.removeAt(i - removedRowsCounter);\n      emptyRawsIndexes.push(i);\n      removedRowsCounter += 1;\n    }\n  }\n  return emptyRawsIndexes;\n}\n\nexport function hashDataFrame(table: DG.DataFrame, names?: string[]): Uint8Array {\n  names ??= table.columns.names();\n  const hasher = new sha256.Hash();\n  const order = table.getSortedOrder(names);\n  const encoder = new TextEncoder();\n  for (const name of names) {\n    const column = table.columns.byName(name);\n    const dataArray = column.getRawData();\n    const isString = column.type == DG.TYPE.STRING;\n    const cats = column.categories;\n    for (let i = 0; i < dataArray.length; i++) {\n      if (isString) {\n        const data = cats[dataArray[order[i]]];\n        hasher.update(encoder.encode(data));\n      } else {\n        const data = dataArray[order[i]];\n        hasher.update(Uint8Array.from([data]));\n      }\n    }\n  }\n  return hasher.digest();\n}\n\nexport const testData = DG.DataFrame.fromCsv(`countries,fasta,smiles,molregno,LON,Zip Code,Street Address Line 1,ImageUrl,user_id,error_message,xray,flag,magnitude,CS-id,pdb_id,accel_a,time_offset,chart,fit,Questions,empty_number,empty_string\nBelgium,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C(=O)OCCCc1cccnc1)c2cccc(c2)C(=O)c3ccccc3,1480014,36.276729583740234,995042300,14016 ROUTE 31W,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,1,1,1QBS,1,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.497360340644872, 1.7058694986686864, 5.278052678195135, 0.16000320889028383],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.374499797821045},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.6242473125457764},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.367267608642578},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.6723148822784424},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.6537344455718994},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.3651671409606934},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.5654284954071045},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.4160959720611572},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.286726713180542},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.5100042819976807},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6676985025405884},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.680136501789093},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3391543924808502},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.09038983285427094},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.19802775979042053}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[7.525235855508179, 1.3186911876809984, 5.335672608564294, 0.7860743343958098],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":7.988070487976074},{\"\"x\"\":0.6000000238418579,\"\"y\"\":7.018453121185303},{\"\"x\"\":1.100000023841858,\"\"y\"\":8.115279197692871},{\"\"x\"\":1.600000023841858,\"\"y\"\":7.486658096313477},{\"\"x\"\":2.0999999046325684,\"\"y\"\":7.396438121795654},{\"\"x\"\":2.5999999046325684,\"\"y\"\":7.477052211761475},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.913095474243164},{\"\"x\"\":3.5999999046325684,\"\"y\"\":8.01385498046875},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.985900402069092},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.970335960388184},{\"\"x\"\":5.099999904632568,\"\"y\"\":5.448817253112793},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.5534818172454834},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.893947958946228},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6340042352676392},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8403874039649963}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,100,abc\nBurundi,MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW,COc1ccc2cc(ccc2c1)C(C)C(=O)Oc3ccc(C)cc3OC,1480015,36.276729583740234,995073444,80 STATE HIGHWAY 310,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,2,2,1ZP8,2,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.431460753103398, 2.1691498799246745, 5.266445597102774, 0.7825762827017926],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.751083850860596},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.203000068664551},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.415858745574951},{\"\"x\"\":1.600000023841858,\"\"y\"\":4.68414306640625},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.198400974273682},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.179222106933594},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.638473987579346},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.708553314208984},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.291589260101318},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.038082599639893},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4349939823150635},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.2194708585739136},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.1920831203460693},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.5352635979652405},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.3346920311450958}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.339458017970126, -1.0734184310171178, 4.746332950550934, 0.2482416857595658],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.2139337658882141},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.4269562065601349},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.2441573292016983},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.146635964512825},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.08818462491035461},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.2560656666755676},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.42434045672416687},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.37111231684684753},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.5581737160682678},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.183590054512024},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.5629843473434448},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3211288452148438},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.229961633682251},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.2560226917266846},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.2142398357391357}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCameroon,MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL,COc1ccc2cc(ccc2c1)C(C)C(=O)OCCCc3cccnc3,1480016,36.26095962524414,995153596,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,3,3,2BDJ,3,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[4.6760652578642325, 0.9046956320756703, 5.651408971856738, 0.07738846012184185],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.32425594329834},{\"\"x\"\":0.6000000238418579,\"\"y\"\":4.668442249298096},{\"\"x\"\":1.100000023841858,\"\"y\"\":4.379785060882568},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.0345139503479},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.878653526306152},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.3451313972473145},{\"\"x\"\":3.0999999046325684,\"\"y\"\":4.336992263793945},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.037430286407471},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.0092692375183105},{\"\"x\"\":4.599999904632568,\"\"y\"\":4.151902675628662},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.4066951274871826},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.3732759952545166},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.673728108406067},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48574790358543396},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.2783052325248718}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.938395863010111, -1.4658480661392117, 5.462702751996584, 0.3473139023615039],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.4941710829734802},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.15323974192142487},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.46373432874679565},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.3370431363582611},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.5179030299186707},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.27899765968322754},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.22075064480304718},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.5789918899536133},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.21169911324977875},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.27857646346092224},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0906332731246948},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8520300388336182},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.7177059650421143},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.8680918216705322},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.2413077354431152}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCanada,MMELVLKTIIGPIVVGVVLRIVDKWLNKDK,CC(C(=O)NCCS)c1cccc(c1)C(=O)c2ccccc2,1480017,36.26095962524414,99515,30-56 WHITESTONE EXPY,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,4,4,1IAN,4,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[0.8597390975430008, 1.0957625732481946, 5.260537067987958, 0.07974187998177736],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.8190152645111084},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.8421689867973328},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.8740922212600708},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.8924275040626526},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.8249067664146423},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.9327669143676758},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.8522974252700806},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.8174492716789246},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.8394647240638733},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.7139387726783752},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.5561167597770691},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3276226818561554},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.12479474395513535},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.13006797432899475},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.059702079743146896}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.760930219582546, 1.6591793293833013, 4.667155929720851, 0.7858109544121652],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.156993389129639},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.236701965332031},{\"\"x\"\":1.100000023841858,\"\"y\"\":6.010560512542725},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.495512962341309},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.087770462036133},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.79986572265625},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.597546577453613},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.520902156829834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.360654354095459},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.5539746284484863},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.577236294746399},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.0001264810562134},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.9305797815322876},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6033638715744019},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.4203685522079468}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nColombia,MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN,FC(F)(F)c1ccc(OC2CCNCC2)cc1,1480029,36.3309440612793,995152050,1 COURT HOUSE SQUARE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,5,5,4UJ1,5,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[6.4995088314153655, 2.4270351004539914, 5.178659535348579, 0.625653346241577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":6.496231555938721},{\"\"x\"\":0.6000000238418579,\"\"y\"\":6.42543363571167},{\"\"x\"\":1.100000023841858,\"\"y\"\":7.040063858032227},{\"\"x\"\":1.600000023841858,\"\"y\"\":6.1115403175354},{\"\"x\"\":2.0999999046325684,\"\"y\"\":6.680728435516357},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.406774520874023},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.611269474029541},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.889094352722168},{\"\"x\"\":4.099999904632568,\"\"y\"\":6.75344705581665},{\"\"x\"\":4.599999904632568,\"\"y\"\":6.361435890197754},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.1666975021362305},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.172118902206421},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.801048994064331},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.4640021026134491},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.0010357667924836278}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.4734381347446401, 1.1649805188074196, 4.82958608866421, 0.09500545496710007],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.5279096364974976},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.3559974431991577},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.5246378183364868},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.5567657947540283},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.4114240407943726},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.4045010805130005},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.4769829511642456},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.4875500202178955},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.2991987466812134},{\"\"x\"\":4.599999904632568,\"\"y\"\":0.922961413860321},{\"\"x\"\":5.099999904632568,\"\"y\"\":0.6520044803619385},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.15350978076457977},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1078903079032898},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.17276449501514435},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.14066608250141144}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCosta Rica,MKSTKEEIQTIKTLLKDSRTAKYHKRLQIVL,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCCc3ccccc3,1480018,36.3309440612793,995084218,4041 SOUTHWESTERN BLVD,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,6,6,2BPW,6,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.4833641843311227, -1.8945978742090062, 4.671127708092568, 0.24159861311815153],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.0969524160027504},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.028483040630817413},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.22087176144123077},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.0068915546871721745},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.4305879771709442},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.44774115085601807},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.45346319675445557},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.2370593100786209},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.4657953977584839},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.155200719833374},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.2294070720672607},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.4311530590057373},{\"\"x\"\":6.099999904632568,\"\"y\"\":2.33846116065979},{\"\"x\"\":6.599999904632568,\"\"y\"\":2.608201026916504},{\"\"x\"\":7.099999904632568,\"\"y\"\":2.8136143684387207}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.224573521642033, 1.4454033924198528, 5.6014197746076535, 0.2823216054197577],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":4.95027494430542},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.1754679679870605},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.276752948760986},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.589294910430908},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.616994857788086},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.120813846588135},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.340766906738281},{\"\"x\"\":3.5999999046325684,\"\"y\"\":4.876471042633057},{\"\"x\"\":4.099999904632568,\"\"y\"\":4.94999361038208},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.162564754486084},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.399557590484619},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.7977969646453857},{\"\"x\"\":6.099999904632568,\"\"y\"\":1.0229872465133667},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.48275601863861084},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.10408931970596313}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nCuba,MHAILRYFIRRLFYHIFYKIYSLISKKHQSLPSDVRQF,COc1ccc2c(c1)c(CC(=O)N3CCCC3C(=O)Oc4ccc(C)cc4OC)c(C)n2C(=O)c5ccc(Cl)cc5,1480019,36.33115768432617,995081928,1227 US HIGHWAY 11,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,7,7,1QBS,7,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.320838679713925, -1.2421619987316728, 4.831325425225256, 0.3236011098403072],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":0.3727470338344574},{\"\"x\"\":0.6000000238418579,\"\"y\"\":0.12365014106035233},{\"\"x\"\":1.100000023841858,\"\"y\"\":0.48422467708587646},{\"\"x\"\":1.600000023841858,\"\"y\"\":0.2264465093612671},{\"\"x\"\":2.0999999046325684,\"\"y\"\":0.16821794211864471},{\"\"x\"\":2.5999999046325684,\"\"y\"\":0.3879014551639557},{\"\"x\"\":3.0999999046325684,\"\"y\"\":0.5470244884490967},{\"\"x\"\":3.5999999046325684,\"\"y\"\":0.3419053554534912},{\"\"x\"\":4.099999904632568,\"\"y\"\":0.7655120491981506},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.2346516847610474},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.453336715698242},{\"\"x\"\":5.599999904632568,\"\"y\"\":2.9565491676330566},{\"\"x\"\":6.099999904632568,\"\"y\"\":3.335299491882324},{\"\"x\"\":6.599999904632568,\"\"y\"\":3.240290880203247},{\"\"x\"\":7.099999904632568,\"\"y\"\":3.1107218265533447}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.6401853521511094, 1.26211588875013, 5.399028074402744, 0.5089580830068091],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.8585598468780518},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.6077206134796143},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.855252265930176},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.619039297103882},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.839388370513916},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.335283041000366},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.571141481399536},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.4155046939849854},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7316646575927734},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.0680155754089355},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.891066551208496},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.6022753715515137},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.7652576565742493},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6875326037406921},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5828871726989746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nItaly,MSNFHNEHVMQFYRNNLKTKGVFGRQ,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO[N+](=O)[O-],1480020,36.33115768432617,99502,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,8,8,1ZP8,8,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[2.293592105923809, 1.3781586549141835, 5.1025898038676605, 0.03493851245291291],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":2.1287283897399902},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.267972230911255},{\"\"x\"\":1.100000023841858,\"\"y\"\":2.398442506790161},{\"\"x\"\":1.600000023841858,\"\"y\"\":2.5130622386932373},{\"\"x\"\":2.0999999046325684,\"\"y\"\":2.3255116939544678},{\"\"x\"\":2.5999999046325684,\"\"y\"\":2.127340793609619},{\"\"x\"\":3.0999999046325684,\"\"y\"\":2.47259783744812},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.131181478500366},{\"\"x\"\":4.099999904632568,\"\"y\"\":2.090421438217163},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.02299165725708},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.1105059385299683},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.4494485855102539},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.1375635862350464},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.036351121962070465},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.1619771122932434}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.953125499439879, 1.2528620255306528, 5.187637440149802, 0.3110348753260886],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.6585283279418945},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.911152362823486},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.924920082092285},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.8469438552856445},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.929472923278809},{\"\"x\"\":2.5999999046325684,\"\"y\"\":6.190037727355957},{\"\"x\"\":3.0999999046325684,\"\"y\"\":6.236179828643799},{\"\"x\"\":3.5999999046325684,\"\"y\"\":6.141019344329834},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.295210838317871},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.265801906585693},{\"\"x\"\":5.099999904632568,\"\"y\"\":3.3722851276397705},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.8299226760864258},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.32690900564193726},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.6274543404579163},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.8441857099533081}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nRwanda,MPNSEPASLLELFNSIATQGELVRSLKAGNASK,CC(C)Cc1ccc(cc1)C(C)C(=O)N2CCCC2C(=O)OCCO,1480021,36.33137130737305,995037247,\"168-46 91ST AVE., 2ND FLR\",https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,9,2BDJ,9,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.8209972202654474, 1.3779216716448506, 5.299882228439686, 0.06040645519069608],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.7821109294891357},{\"\"x\"\":0.6000000238418579,\"\"y\"\":3.542433023452759},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.7008674144744873},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.717301607131958},{\"\"x\"\":2.0999999046325684,\"\"y\"\":4.024452209472656},{\"\"x\"\":2.5999999046325684,\"\"y\"\":4.013899326324463},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.945094347000122},{\"\"x\"\":3.5999999046325684,\"\"y\"\":3.866621971130371},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.7461626529693604},{\"\"x\"\":4.599999904632568,\"\"y\"\":3.3454740047454834},{\"\"x\"\":5.099999904632568,\"\"y\"\":2.61944317817688},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.999405026435852},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.46259793639183044},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.054134611040353775},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.05711187422275543}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[5.6318079657726035, 1.8495493770000595, 5.391793312471116, 0.17060707587348442],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":5.458079814910889},{\"\"x\"\":0.6000000238418579,\"\"y\"\":5.554427146911621},{\"\"x\"\":1.100000023841858,\"\"y\"\":5.799983024597168},{\"\"x\"\":1.600000023841858,\"\"y\"\":5.364140033721924},{\"\"x\"\":2.0999999046325684,\"\"y\"\":5.864485740661621},{\"\"x\"\":2.5999999046325684,\"\"y\"\":5.4509806632995605},{\"\"x\"\":3.0999999046325684,\"\"y\"\":5.702574729919434},{\"\"x\"\":3.5999999046325684,\"\"y\"\":5.7314534187316895},{\"\"x\"\":4.099999904632568,\"\"y\"\":5.5123443603515625},{\"\"x\"\":4.599999904632568,\"\"y\"\":5.724395751953125},{\"\"x\"\":5.099999904632568,\"\"y\"\":4.354506969451904},{\"\"x\"\":5.599999904632568,\"\"y\"\":1.7307666540145874},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.6305936574935913},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.035183437168598175},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.7575169205665588}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\nSwitzerland,IRVVGRYLIEVWKAAGMDMDKVLFLWSSDEI,CN1CCC(CC1)Oc2ccc(cc2)C(F)(F)F,1480028,36.33137130737305,99504,92-11 179TH PLACE,https://datagrok.ai/img/slides/access-db-connect.png,id,ErrorMessage,\"COMPND \nATOM \nEND\",flag,9,10,1IAN,10,1.23,<chart></chart>,\"{\"\"series\"\":[{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitFunction\"\":\"\"sigmoid\"\",\"\"fitLineColor\"\":\"\"#1f77b4\"\",\"\"pointColor\"\":\"\"#1f77b4\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[1.1190255865097471, 2.3163895161544437, 5.4968866182279195, 0.2035204047289052],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":1.1057683229446411},{\"\"x\"\":0.6000000238418579,\"\"y\"\":1.1019697189331055},{\"\"x\"\":1.100000023841858,\"\"y\"\":1.0818607807159424},{\"\"x\"\":1.600000023841858,\"\"y\"\":1.062997817993164},{\"\"x\"\":2.0999999046325684,\"\"y\"\":1.046447515487671},{\"\"x\"\":2.5999999046325684,\"\"y\"\":1.1217249631881714},{\"\"x\"\":3.0999999046325684,\"\"y\"\":1.2166996002197266},{\"\"x\"\":3.5999999046325684,\"\"y\"\":1.215477705001831},{\"\"x\"\":4.099999904632568,\"\"y\"\":1.0581893920898438},{\"\"x\"\":4.599999904632568,\"\"y\"\":1.1747995615005493},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.0181127786636353},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.5344523191452026},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.2569526433944702},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.1912207305431366},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.15060538053512573}]},{\"\"name\"\":\"\"Run:2023-08-08\"\",\"\"fitLineColor\"\":\"\"#ffbb78\"\",\"\"pointColor\"\":\"\"#ffbb78\"\",\"\"showPoints\"\":\"\"points\"\",\"\"parameters\"\":[3.1038581025805785, 2.0032224204185245, 5.087602825989163, 0.13277988512492753],\"\"points\"\":[{\"\"x\"\":0.10000000149011612,\"\"y\"\":3.0498509407043457},{\"\"x\"\":0.6000000238418579,\"\"y\"\":2.805217742919922},{\"\"x\"\":1.100000023841858,\"\"y\"\":3.3415253162384033},{\"\"x\"\":1.600000023841858,\"\"y\"\":3.0549843311309814},{\"\"x\"\":2.0999999046325684,\"\"y\"\":3.250074863433838},{\"\"x\"\":2.5999999046325684,\"\"y\"\":3.0432586669921875},{\"\"x\"\":3.0999999046325684,\"\"y\"\":3.265852451324463},{\"\"x\"\":3.5999999046325684,\"\"y\"\":2.9475724697113037},{\"\"x\"\":4.099999904632568,\"\"y\"\":3.1929898262023926},{\"\"x\"\":4.599999904632568,\"\"y\"\":2.7460060119628906},{\"\"x\"\":5.099999904632568,\"\"y\"\":1.6175861358642578},{\"\"x\"\":5.599999904632568,\"\"y\"\":0.3006608486175537},{\"\"x\"\":6.099999904632568,\"\"y\"\":0.3444803059101105},{\"\"x\"\":6.599999904632568,\"\"y\"\":0.015537971630692482},{\"\"x\"\":7.099999904632568,\"\"y\"\":0.5527358055114746}]}],\"\"chartOptions\"\":{\"\"xAxisName\"\":\"\"Conc.\"\",\"\"yAxisName\"\":\"\"Activity\"\",\"\"title\"\":\"\"Dose-Response curves\"\"}}\",text,,\n,,,,,,,,,,,,,,,,,,,,,`);\ntestData.columns.add(DG.Column.fromList(DG.TYPE.BYTE_ARRAY, 'BinaryImage', Array.from(new Uint8Array(11))));\n"]}","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\nimport { testData } from './dataframe-utils';\nimport { changeOptionsSaveLayout, filterAsync, loadLayout, selectFilterChangeCurrent, testViewerInternal } from './test-viewer-utils';\nconst STANDART_TIMEOUT = 30000;\nconst BENCHMARK_TIMEOUT = 10800000;\nconst stdLog = console.log.bind(console);\nconst stdInfo = console.info.bind(console);\nconst stdWarn = console.warn.bind(console);\nconst stdError = console.error.bind(console);\nexport const tests = {};\nconst autoTestsCatName = 'Auto Tests';\nconst demoCatName = 'Demo';\nconst detectorsCatName = 'Detectors';\nconst coreCatName = 'Core';\nconst wasRegistered = {};\nexport let currentCategory;\nexport var assure;\n(function (assure) {\n    function notNull(value, name) {\n        if (value == null)\n            throw new Error(`${name == null ? 'Value' : name} not defined`);\n    }\n    assure.notNull = notNull;\n})(assure || (assure = {}));\nexport class TestContext {\n    constructor(catchUnhandled, report) {\n        this.catchUnhandled = true;\n        this.report = false;\n        if (catchUnhandled !== undefined)\n            this.catchUnhandled = catchUnhandled;\n        if (report !== undefined)\n            this.report = report;\n    }\n    ;\n}\nexport class Test {\n    constructor(category, name, test, options) {\n        var _a;\n        this.category = category;\n        this.name = name;\n        options !== null && options !== void 0 ? options : (options = {});\n        (_a = options.timeout) !== null && _a !== void 0 ? _a : (options.timeout = STANDART_TIMEOUT);\n        this.options = options;\n        this.test = () => __awaiter(this, void 0, void 0, function* () {\n            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {\n                let result = '';\n                try {\n                    result = yield test();\n                }\n                catch (e) {\n                    reject(e);\n                }\n                resolve(result);\n            }));\n        });\n    }\n}\nexport function testEvent(event, handler, trigger, ms = 0, reason = `timeout`) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return new Promise((resolve, reject) => {\n            const sub = event.subscribe((args) => {\n                try {\n                    handler(args);\n                    resolve('OK');\n                }\n                catch (e) {\n                    reject(e);\n                }\n                finally {\n                    sub.unsubscribe();\n                    clearTimeout(timeout);\n                }\n            });\n            const timeout = setTimeout(() => {\n                sub.unsubscribe();\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject(reason);\n            }, ms);\n            trigger();\n        });\n    });\n}\nexport function testEventAsync(event, handler, trigger, ms = 0, reason = `timeout`) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return new Promise((resolve, reject) => {\n            const sub = event.subscribe((args) => {\n                handler(args).then(() => {\n                    resolve('OK');\n                }).catch((e) => {\n                    reject(e);\n                }).finally(() => {\n                    sub.unsubscribe();\n                    clearTimeout(timeout);\n                });\n            });\n            const timeout = setTimeout(() => {\n                sub.unsubscribe();\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject(reason);\n            }, ms);\n            trigger();\n        });\n    });\n}\nexport function test(name, test, options) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    if (tests[currentCategory].tests == undefined)\n        tests[currentCategory].tests = [];\n    tests[currentCategory].tests.push(new Test(currentCategory, name, test, options));\n}\n/* Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual, expected = true, error) {\n    if (error)\n        error = `${error}, `;\n    else\n        error = '';\n    if (actual !== expected)\n        throw new Error(`${error}Expected \"${expected}\", got \"${actual}\"`);\n}\nexport function expectFloat(actual, expected, tolerance = 0.001, error) {\n    if ((actual === Number.POSITIVE_INFINITY && expected === Number.POSITIVE_INFINITY) ||\n        (actual === Number.NEGATIVE_INFINITY && expected === Number.NEGATIVE_INFINITY) ||\n        (actual === Number.NaN && expected === Number.NaN) || (isNaN(actual) && isNaN(expected)))\n        return;\n    const areEqual = Math.abs(actual - expected) < tolerance;\n    expect(areEqual, true, `${error !== null && error !== void 0 ? error : ''} (tolerance = ${tolerance})`);\n    if (!areEqual)\n        throw new Error(`Expected ${expected}, got ${actual} (tolerance = ${tolerance})`);\n}\nexport function expectTable(actual, expected, error) {\n    const expectedRowCount = expected.rowCount;\n    const actualRowCount = actual.rowCount;\n    expect(actualRowCount, expectedRowCount, `${error !== null && error !== void 0 ? error : ''}, row count`);\n    for (const column of expected.columns) {\n        const actualColumn = actual.columns.byName(column.name);\n        if (actualColumn == null)\n            throw new Error(`Column ${column.name} not found`);\n        if (actualColumn.type != column.type)\n            throw new Error(`Column ${column.name} type expected ${column.type} got ${actualColumn.type}`);\n        for (let i = 0; i < expectedRowCount; i++) {\n            const value = column.get(i);\n            const actualValue = actualColumn.get(i);\n            if (column.type == DG.TYPE.FLOAT)\n                expectFloat(actualValue, value, 0.0001, error);\n            else if (column.type == DG.TYPE.DATE_TIME)\n                expect(actualValue.isSame(value), true, error);\n            else\n                expect(actualValue, value, error);\n        }\n    }\n}\nexport function expectObject(actual, expected) {\n    for (const [expectedKey, expectedValue] of Object.entries(expected)) {\n        if (!actual.hasOwnProperty(expectedKey))\n            throw new Error(`Expected property \"${expectedKey}\" not found`);\n        const actualValue = actual[expectedKey];\n        if (actualValue instanceof Array && expectedValue instanceof Array)\n            expectArray(actualValue, expectedValue);\n        else if (actualValue instanceof Object && expectedValue instanceof Object)\n            expectObject(actualValue, expectedValue);\n        else if (Number.isFinite(actualValue) && Number.isFinite(expectedValue))\n            expectFloat(actualValue, expectedValue);\n        else if (actualValue != expectedValue)\n            throw new Error(`Expected (${expectedValue}) for key '${expectedKey}', got (${actualValue})`);\n    }\n}\nexport function expectArray(actual, expected) {\n    const actualLength = actual.length;\n    const expectedLength = expected.length;\n    if (actualLength != expectedLength) {\n        throw new Error(`Arrays are of different length: actual array length is ${actualLength} ` +\n            `and expected array length is ${expectedLength}`);\n    }\n    for (let i = 0; i < actualLength; i++) {\n        if (actual[i] instanceof Array && expected[i] instanceof Array)\n            expectArray(actual[i], expected[i]);\n        else if (actual[i] instanceof Object && expected[i] instanceof Object)\n            expectObject(actual[i], expected[i]);\n        else if (actual[i] != expected[i])\n            throw new Error(`Expected ${expected[i]} at position ${i}, got ${actual[i]}`);\n    }\n}\n/* Defines a test suite. */\nexport function category(category, tests_, options) {\n    var _a;\n    currentCategory = category;\n    tests_();\n    if (tests[currentCategory]) {\n        tests[currentCategory].clear = (_a = options === null || options === void 0 ? void 0 : options.clear) !== null && _a !== void 0 ? _a : true;\n        tests[currentCategory].timeout = options === null || options === void 0 ? void 0 : options.timeout;\n    }\n}\n/* Defines a function to be executed before the tests in this category are executed. */\nexport function before(before) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    tests[currentCategory].before = before;\n}\n/* Defines a function to be executed after the tests in this category are executed. */\nexport function after(after) {\n    if (tests[currentCategory] == undefined)\n        tests[currentCategory] = {};\n    tests[currentCategory].after = after;\n}\nfunction addNamespace(s, f) {\n    return s.replace(new RegExp(f.name, 'gi'), f.nqName);\n}\nexport function initAutoTests(package_, module) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function* () {\n        const packageId = package_.id;\n        if (wasRegistered[packageId])\n            return;\n        const moduleTests = module ? module.tests : tests;\n        if (moduleTests[autoTestsCatName] !== undefined ||\n            moduleTests[demoCatName] !== undefined ||\n            Object.keys(moduleTests).find((c) => c.startsWith(autoTestsCatName) || c.startsWith(coreCatName))) {\n            wasRegistered[packageId] = true;\n            return;\n        }\n        if (package_.name === 'DevTools' || (!!module && module._package.name === 'DevTools')) {\n            const testFunctions = DG.Func.find({ tags: ['dartTest'] });\n            for (const f of testFunctions) {\n                const arr = f.name.split(/\\s*\\|\\s*/g);\n                const name = (_a = arr.pop()) !== null && _a !== void 0 ? _a : f.name;\n                const cat = arr.length ? coreCatName + ': ' + arr.join(': ') : coreCatName;\n                if (moduleTests[cat] === undefined)\n                    moduleTests[cat] = { tests: [], clear: true };\n                moduleTests[cat].tests.push(new Test(cat, name, () => __awaiter(this, void 0, void 0, function* () { return yield f.apply(); }), { isAggregated: f.outputs.length > 0, timeout: 300000 }));\n            }\n        }\n        const moduleAutoTests = [];\n        const moduleDemo = [];\n        const moduleDetectors = [];\n        const packFunctions = yield grok.dapi.functions.filter(`package.id = \"${packageId}\"`).list();\n        const reg = new RegExp(/skip:\\s*([^,\\s]+)|wait:\\s*(\\d+)|cat:\\s*([^,\\s]+)|timeout:\\s*(\\d+)/g);\n        for (const f of packFunctions) {\n            const tests = f.options['test'];\n            const demo = f.options['demoPath'];\n            if ((tests && Array.isArray(tests) && tests.length)) {\n                for (let i = 0; i < tests.length; i++) {\n                    const res = tests[i].matchAll(reg);\n                    const map = {};\n                    Array.from(res).forEach((arr) => {\n                        if (arr[0].startsWith('skip'))\n                            map['skip'] = arr[1];\n                        else if (arr[0].startsWith('wait'))\n                            map['wait'] = parseInt(arr[2]);\n                        else if (arr[0].startsWith('cat'))\n                            map['cat'] = arr[3];\n                        else if (arr[0].startsWith('timeout'))\n                            map['timeout'] = parseInt(arr[4]);\n                    });\n                    const test = new Test(autoTestsCatName, tests.length === 1 ? f.name : `${f.name} ${i + 1}`, () => __awaiter(this, void 0, void 0, function* () {\n                        const res = yield grok.functions.eval(addNamespace(tests[i], f));\n                        if (map.wait)\n                            yield delay(map.wait);\n                        // eslint-disable-next-line no-throw-literal\n                        if (typeof res === 'boolean' && !res)\n                            throw `Failed: ${tests[i]}, expected true, got ${res}`;\n                    }), { skipReason: map.skip, timeout: map.timeout });\n                    if (map.cat) {\n                        const cat = autoTestsCatName + ': ' + map.cat;\n                        test.category = cat;\n                        if (moduleTests[cat] === undefined)\n                            moduleTests[cat] = { tests: [], clear: true };\n                        moduleTests[cat].tests.push(test);\n                    }\n                    else\n                        moduleAutoTests.push(test);\n                }\n            }\n            if (demo) {\n                const wait = f.options['demoWait'] ? parseInt(f.options['demoWait']) : undefined;\n                const test = new Test(demoCatName, f.friendlyName, () => __awaiter(this, void 0, void 0, function* () {\n                    grok.shell.lastError = '';\n                    yield f.apply();\n                    yield delay(wait ? wait : 2000);\n                    if (grok.shell.lastError)\n                        throw new Error(grok.shell.lastError);\n                }), { skipReason: f.options['demoSkip'] });\n                moduleDemo.push(test);\n            }\n            if (f.hasTag('semTypeDetector')) {\n                const test = new Test(detectorsCatName, f.friendlyName, () => __awaiter(this, void 0, void 0, function* () {\n                    const arr = [];\n                    for (const col of testData.clone().columns) {\n                        const res = yield f.apply([col]);\n                        arr.push(res || col.semType);\n                    }\n                    expect(arr.filter((i) => i).length, 1);\n                }), { skipReason: f.options['skipTest'] });\n                moduleDetectors.push(test);\n            }\n        }\n        wasRegistered[packageId] = true;\n        if (moduleAutoTests.length)\n            moduleTests[autoTestsCatName] = { tests: moduleAutoTests, clear: true };\n        if (moduleDemo.length)\n            moduleTests[demoCatName] = { tests: moduleDemo, clear: true };\n        if (moduleDetectors.length)\n            moduleTests[detectorsCatName] = { tests: moduleDetectors, clear: false };\n    });\n}\nfunction redefineConsole() {\n    const logs = [];\n    console.log = (...args) => {\n        logs.push(...args);\n        stdLog(...args);\n    };\n    console.info = (...args) => {\n        logs.push(...args);\n        stdInfo(...args);\n    };\n    console.warn = (...args) => {\n        logs.push(...args);\n        stdWarn(...args);\n    };\n    console.error = (...args) => {\n        logs.push(...args);\n        stdError(...args);\n    };\n    return logs;\n}\nfunction resetConsole() {\n    console.log = stdLog;\n    console.info = stdInfo;\n    console.warn = stdWarn;\n    console.error = stdError;\n}\nexport function runTests(options) {\n    var _a, _b, _c, _d, _e, _f;\n    var _g;\n    return __awaiter(this, void 0, void 0, function* () {\n        const package_ = (_b = (_a = grok.functions.getCurrentCall()) === null || _a === void 0 ? void 0 : _a.func) === null || _b === void 0 ? void 0 : _b.package;\n        yield initAutoTests(package_);\n        const results = [];\n        console.log(`Running tests`);\n        options !== null && options !== void 0 ? options : (options = {});\n        (_c = (_g = options).testContext) !== null && _c !== void 0 ? _c : (_g.testContext = new TestContext());\n        grok.shell.lastError = '';\n        const categories = [];\n        const logs = redefineConsole();\n        try {\n            for (const [key, value] of Object.entries(tests)) {\n                if ((!!(options === null || options === void 0 ? void 0 : options.category) && !key.toLowerCase().startsWith(options === null || options === void 0 ? void 0 : options.category.toLowerCase())) ||\n                    ((_d = options.exclude) === null || _d === void 0 ? void 0 : _d.some((c) => key.startsWith(c))))\n                    continue;\n                stdLog(`Started ${key} category`);\n                categories.push(key);\n                const skipped = (_e = value.tests) === null || _e === void 0 ? void 0 : _e.every((t) => { var _a; return (_a = t.options) === null || _a === void 0 ? void 0 : _a.skipReason; });\n                try {\n                    if (value.before && !skipped) {\n                        yield timeout(() => __awaiter(this, void 0, void 0, function* () {\n                            yield value.before();\n                        }), 100000, `before ${options.category}: timeout error`);\n                    }\n                }\n                catch (x) {\n                    value.beforeStatus = yield getResult(x);\n                }\n                const t = (_f = value.tests) !== null && _f !== void 0 ? _f : [];\n                const res = [];\n                if (value.clear) {\n                    for (let i = 0; i < t.length; i++) {\n                        res.push(yield execTest(t[i], options === null || options === void 0 ? void 0 : options.test, logs, value.timeout, package_.name, options.verbose));\n                        grok.shell.closeAll();\n                        DG.Balloon.closeAll();\n                    }\n                }\n                else {\n                    for (let i = 0; i < t.length; i++)\n                        res.push(yield execTest(t[i], options === null || options === void 0 ? void 0 : options.test, logs, value.timeout, package_.name, options.verbose));\n                }\n                const data = res.filter((d) => d.result != 'skipped');\n                try {\n                    if (value.after && !skipped) {\n                        yield timeout(() => __awaiter(this, void 0, void 0, function* () {\n                            yield value.after();\n                        }), 100000, `After ${options.category}: timeout error`);\n                    }\n                }\n                catch (x) {\n                    value.afterStatus = yield getResult(x);\n                }\n                // Clear after category\n                // grok.shell.closeAll();\n                // DG.Balloon.closeAll();\n                if (value.afterStatus)\n                    data.push({ category: key, name: 'after', result: value.afterStatus, success: false, ms: 0, skipped: false });\n                if (value.beforeStatus)\n                    data.push({ category: key, name: 'before', result: value.beforeStatus, success: false, ms: 0, skipped: false });\n                results.push(...data);\n            }\n        }\n        finally {\n            resetConsole();\n        }\n        if (options.testContext.catchUnhandled) {\n            yield delay(1000);\n            if (grok.shell.lastError.length > 0) {\n                results.push({\n                    category: 'Unhandled exceptions',\n                    name: 'exceptions',\n                    result: grok.shell.lastError, success: false, ms: 0, skipped: false\n                });\n            }\n        }\n        if (!options.test && results.length) {\n            const successful = results.filter((r) => r.success).length;\n            const skipped = results.filter((r) => r.skipped).length;\n            const failed = results.filter((r) => !r.success);\n            const packageName = package_.name;\n            for (const cat of categories) {\n                const res = results.filter((r) => r.category === cat);\n                const failed_ = res.filter((r) => !r.success).length;\n                const params = {\n                    success: failed_ === 0,\n                    passed: res.filter((r) => r.success).length,\n                    skipped: res.filter((r) => r.skipped).length,\n                    failed: failed_,\n                    type: 'package', packageName, category: cat\n                };\n                grok.log.usage(`${packageName}: ${cat}`, params, `category-package ${packageName}: ${cat}`);\n            }\n            if (!options.category) {\n                const params = {\n                    success: failed.length === 0, passed: successful, skipped, failed: failed.length,\n                    type: 'package', packageName\n                };\n                grok.log.usage(packageName, params, `package-package ${packageName}`);\n            }\n            if (options.testContext.report) {\n                const logger = new DG.Logger();\n                const description = 'Package @package tested: @successful successful, @skipped skipped, @failed failed tests';\n                const params = {\n                    successful: successful,\n                    skipped: skipped,\n                    failed: failed.length,\n                    package: package_\n                };\n                for (const r of failed)\n                    Object.assign(params, { [`${r.category} | ${r.name}`]: r.result });\n                logger.log(description, params, 'package-tested');\n            }\n        }\n        return results;\n    });\n}\nfunction getResult(x) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return `${x.toString()}\\n${x.stack ? (yield DG.Logger.translateStackTrace(x.stack)) : ''}`;\n    });\n}\nfunction execTest(t, predicate, logs, categoryTimeout, packageName, verbose) {\n    var _a, _b, _c, _d, _e, _f;\n    return __awaiter(this, void 0, void 0, function* () {\n        logs.length = 0;\n        let r;\n        let type = 'package';\n        const filter = predicate != undefined && (t.name.toLowerCase() !== predicate.toLowerCase());\n        const skip = ((_a = t.options) === null || _a === void 0 ? void 0 : _a.skipReason) || filter;\n        const skipReason = filter ? 'skipped' : (_b = t.options) === null || _b === void 0 ? void 0 : _b.skipReason;\n        if (!skip)\n            stdLog(`Started ${t.category} ${t.name}`);\n        const start = Date.now();\n        try {\n            if (skip)\n                r = { success: true, result: skipReason, ms: 0, skipped: true };\n            else {\n                let timeout_ = ((_c = t.options) === null || _c === void 0 ? void 0 : _c.timeout) === STANDART_TIMEOUT &&\n                    categoryTimeout ? categoryTimeout : (_d = t.options) === null || _d === void 0 ? void 0 : _d.timeout;\n                timeout_ = DG.Test.isInBenchmark && timeout_ === STANDART_TIMEOUT ? BENCHMARK_TIMEOUT : timeout_;\n                r = { success: true, result: (_e = yield timeout(t.test, timeout_)) !== null && _e !== void 0 ? _e : 'OK', ms: 0, skipped: false };\n            }\n        }\n        catch (x) {\n            stdError(x);\n            r = { success: false, result: yield getResult(x), ms: 0, skipped: false };\n        }\n        if (((_f = t.options) === null || _f === void 0 ? void 0 : _f.isAggregated) && r.result.constructor === DG.DataFrame) {\n            const col = r.result.col('success');\n            type = 'core';\n            if (col)\n                r.success = col.stats.sum === col.length;\n            if (!verbose) {\n                const df = r.result;\n                df.columns.remove('stack');\n                df.rows.removeWhere((r) => r.get('success'));\n                r.result = df;\n            }\n            r.result = r.result.toCsv();\n        }\n        r.logs = logs.join('\\n');\n        r.ms = Date.now() - start;\n        if (!skip)\n            stdLog(`Finished ${t.category} ${t.name} for ${r.ms} ms`);\n        r.category = t.category;\n        r.name = t.name;\n        if (!filter) {\n            let params = {\n                'success': r.success, 'result': r.result, 'ms': r.ms, 'skipped': r.skipped,\n                'type': type, packageName, 'category': t.category, 'test': t.name, 'logs': r.logs\n            };\n            if (r.result.constructor == Object) {\n                const res = Object.keys(r.result).reduce((acc, k) => (Object.assign(Object.assign({}, acc), { ['result.' + k]: r.result[k] })), {});\n                params = Object.assign(Object.assign({}, params), res);\n            }\n            grok.log.usage(`${packageName}: ${t.category}: ${t.name}`, params, `test-${type} ${packageName}: ${t.category}: ${t.name}`);\n        }\n        return r;\n    });\n}\n/* Waits [ms] milliseconds */\nexport function delay(ms) {\n    return __awaiter(this, void 0, void 0, function* () {\n        yield new Promise((r) => setTimeout(r, ms));\n    });\n}\nexport function awaitCheck(checkHandler, error = 'Timeout exceeded', wait = 500, interval = 50) {\n    return __awaiter(this, void 0, void 0, function* () {\n        return new Promise((resolve, reject) => {\n            setTimeout(() => {\n                clearInterval(intervalId);\n                reject(new Error(error));\n            }, wait);\n            // @ts-ignore\n            const intervalId = setInterval(() => {\n                if (checkHandler()) {\n                    clearInterval(intervalId);\n                    resolve();\n                }\n            }, interval);\n        });\n    });\n}\n// Returns test execution result or an error in case of timeout\nexport function timeout(func, testTimeout, timeoutReason = 'EXECUTION TIMEOUT') {\n    return __awaiter(this, void 0, void 0, function* () {\n        let timeout = null;\n        const timeoutPromise = new Promise((_, reject) => {\n            timeout = setTimeout(() => {\n                // eslint-disable-next-line prefer-promise-reject-errors\n                reject(timeoutReason);\n            }, testTimeout);\n        });\n        try {\n            return yield Promise.race([func(), timeoutPromise]);\n        }\n        finally {\n            if (timeout)\n                clearTimeout(timeout);\n        }\n    });\n}\nexport function isDialogPresent(dialogTitle) {\n    const dialogs = DG.Dialog.getOpenDialogs();\n    for (let i = 0; i < dialogs.length; i++) {\n        if (dialogs[i].title == dialogTitle)\n            return true;\n    }\n    return false;\n}\n/** Expects an asynchronous {@link action} to throw an exception. Use {@link check} to perform\n * deeper inspection of the exception if necessary.\n * @param  {function(): Promise<void>} action\n * @param  {function(any): boolean} check\n * @return {Promise<void>}\n */\nexport function expectExceptionAsync(action, check) {\n    return __awaiter(this, void 0, void 0, function* () {\n        let caught = false;\n        let checked = false;\n        try {\n            yield action();\n        }\n        catch (e) {\n            caught = true;\n            checked = !check || check(e);\n        }\n        finally {\n            if (!caught)\n                throw new Error('An exception is expected but not thrown');\n            if (!checked)\n                throw new Error('An expected exception is thrown, but it does not satisfy the condition');\n        }\n    });\n}\nconst catDF = DG.DataFrame.fromColumns([DG.Column.fromStrings('col', ['val1', 'val2', 'val3'])]);\n/**\n * Universal test for viewers. It search viewers in DOM by tags: canvas, svg, img, input, h1, a\n * @param  {string} v Viewer name\n * @param  {DG.DataFrame} df Dataframe to use. Should have at least 3 rows\n * @param  {boolean} options.detectSemanticTypes Specify whether to detect semantic types or not\n * @param  {boolean} options.readOnly If set to true, the dataframe will not be modified during the test\n * @param  {boolean} options.arbitraryDfTest If set to false, test on arbitrary dataframe\n * (one categorical column) will not be performed\n * @param  {object} options List of options (optional)\n * @return {Promise<void>} The test is considered successful if it completes without errors\n */\nexport function testViewer(v, df, options) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function* () {\n        const packageName = (_a = options === null || options === void 0 ? void 0 : options.packageName) !== null && _a !== void 0 ? _a : '';\n        if (options === null || options === void 0 ? void 0 : options.detectSemanticTypes)\n            yield grok.data.detectSemanticTypes(df);\n        const tv = grok.shell.addTableView(df);\n        try {\n            //1. Open, do nothing and close\n            yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded);\n            //in case viewer with async rendering - wait for render to complete\n            if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, undefined, options.awaitViewer);\n            //2. Open viewer, run selection, filter, etc. and close\n            if (!(options === null || options === void 0 ? void 0 : options.readOnly)) {\n                yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, selectFilterChangeCurrent);\n                if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                    yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, selectFilterChangeCurrent, options.awaitViewer);\n            }\n            //2. Open viewer, change options, save layout and close\n            let propsAndLayout = null;\n            propsAndLayout = yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, changeOptionsSaveLayout);\n            if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                propsAndLayout = yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, changeOptionsSaveLayout, options.awaitViewer);\n            //3. Load layout\n            yield testViewerInternal(tv, v, packageName, grok.events.onViewLayoutApplied, loadLayout, undefined, propsAndLayout === null || propsAndLayout === void 0 ? void 0 : propsAndLayout.layout, { savedProps: propsAndLayout === null || propsAndLayout === void 0 ? void 0 : propsAndLayout.savedProps });\n            if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                yield testViewerInternal(tv, v, packageName, grok.events.onViewLayoutApplied, loadLayout, options.awaitViewer, propsAndLayout === null || propsAndLayout === void 0 ? void 0 : propsAndLayout.layout, { savedProps: propsAndLayout === null || propsAndLayout === void 0 ? void 0 : propsAndLayout.savedProps });\n            //4. Open viewer on arbitary dataset\n            if ((options === null || options === void 0 ? void 0 : options.arbitraryDfTest) !== false) {\n                tv.dataFrame = catDF;\n                yield delay(50);\n                yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded);\n                if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                    yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, undefined, options.awaitViewer);\n            }\n            //5. Call postponed filtering\n            yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, filterAsync);\n            if (options === null || options === void 0 ? void 0 : options.awaitViewer)\n                yield testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, filterAsync, options.awaitViewer);\n        }\n        finally {\n            // closeAll() is handling by common test workflow\n            // grok.shell.closeAll();\n            // DG.Balloon.closeAll();\n        }\n    });\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,UAAU,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEtI,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAC/B,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACzC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAE7C,MAAM,CAAC,MAAM,KAAK,GAKd,EAAE,CAAC;AAEP,MAAM,gBAAgB,GAAG,YAAY,CAAC;AACtC,MAAM,WAAW,GAAG,MAAM,CAAC;AAC3B,MAAM,gBAAgB,GAAG,WAAW,CAAC;AACrC,MAAM,WAAW,GAAG,MAAM,CAAC;AAC3B,MAAM,aAAa,GAA+B,EAAE,CAAC;AACrD,MAAM,CAAC,IAAI,eAAuB,CAAC;AAEnC,MAAM,KAAW,MAAM,CAKtB;AALD,WAAiB,MAAM;IACrB,SAAgB,OAAO,CAAC,KAAU,EAAE,IAAa;QAC/C,IAAI,KAAK,IAAI,IAAI;YACf,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC;IACpE,CAAC;IAHe,cAAO,UAGtB,CAAA;AACH,CAAC,EALgB,MAAM,KAAN,MAAM,QAKtB;AAcD,MAAM,OAAO,WAAW;IAItB,YAAY,cAAwB,EAAE,MAAgB;QAHtD,mBAAc,GAAG,IAAI,CAAC;QACtB,WAAM,GAAG,KAAK,CAAC;QAGb,IAAI,cAAc,KAAK,SAAS;YAAE,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACvE,IAAI,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACjD,CAAC;IAAA,CAAC;CACH;AAED,MAAM,OAAO,IAAI;IAMf,YAAY,QAAgB,EAAE,IAAY,EAAE,IAAwB,EAAE,OAAqB;;QACzF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,OAAO,aAAP,OAAO,cAAP,OAAO,IAAP,OAAO,GAAK,EAAE,EAAC;QACf,MAAA,OAAO,CAAC,OAAO,oCAAf,OAAO,CAAC,OAAO,GAAK,gBAAgB,EAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,GAAuB,EAAE;YACnC,OAAO,IAAI,OAAO,CAAC,CAAO,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC3C,IAAI,MAAM,GAAG,EAAE,CAAC;gBAChB,IAAI;oBACF,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;iBACvB;gBAAC,OAAO,CAAM,EAAE;oBACf,MAAM,CAAC,CAAC,CAAC,CAAC;iBACX;gBACD,OAAO,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC,CAAA,CAAC,CAAC;QACL,CAAC,CAAA,CAAC;IACJ,CAAC;CACF;AAED,MAAM,UAAgB,SAAS,CAAI,KAAoB,EACrD,OAA0B,EAAE,OAAmB,EAAE,KAAa,CAAC,EAAE,SAAiB,SAAS;;QAE3F,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAO,EAAE,EAAE;gBACtC,IAAI;oBACF,OAAO,CAAC,IAAI,CAAC,CAAC;oBACd,OAAO,CAAC,IAAI,CAAC,CAAC;iBACf;gBAAC,OAAO,CAAC,EAAE;oBACV,MAAM,CAAC,CAAC,CAAC,CAAC;iBACX;wBAAS;oBACR,GAAG,CAAC,WAAW,EAAE,CAAC;oBAClB,YAAY,CAAC,OAAO,CAAC,CAAC;iBACvB;YACH,CAAC,CAAC,CAAC;YACH,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,GAAG,CAAC,WAAW,EAAE,CAAC;gBAClB,wDAAwD;gBACxD,MAAM,CAAC,MAAM,CAAC,CAAC;YACjB,CAAC,EAAE,EAAE,CAAC,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CAAA;AAED,MAAM,UAAgB,cAAc,CAAI,KAAoB,EAC1D,OAAmC,EAAE,OAAmB,EAAE,KAAa,CAAC,EAAE,SAAiB,SAAS;;QAEpG,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAO,EAAE,EAAE;gBACtC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;oBACtB,OAAO,CAAC,IAAI,CAAC,CAAC;gBAChB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;oBACb,MAAM,CAAC,CAAC,CAAC,CAAC;gBACZ,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;oBACd,GAAG,CAAC,WAAW,EAAE,CAAC;oBAClB,YAAY,CAAC,OAAO,CAAC,CAAC;gBACxB,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YACH,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,GAAG,CAAC,WAAW,EAAE,CAAC;gBAClB,wDAAwD;gBACxD,MAAM,CAAC,MAAM,CAAC,CAAC;YACjB,CAAC,EAAE,EAAE,CAAC,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CAAA;AAED,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,IAAwB,EAAE,OAAqB;IAChF,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,IAAI,SAAS;QAC3C,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;IACpC,KAAK,CAAC,eAAe,CAAC,CAAC,KAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACrF,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,MAAM,CAAC,MAAW,EAAE,WAAgB,IAAI,EAAE,KAAc;IACtE,IAAI,KAAK;QACP,KAAK,GAAG,GAAG,KAAK,IAAI,CAAC;;QAClB,KAAK,GAAG,EAAE,CAAC;IAChB,IAAI,MAAM,KAAK,QAAQ;QACrB,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,aAAa,QAAQ,WAAW,MAAM,GAAG,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,QAAgB,EAAE,SAAS,GAAG,KAAK,EAAE,KAAc;IAC7F,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,iBAAiB,IAAI,QAAQ,KAAK,MAAM,CAAC,iBAAiB,CAAC;QAChF,CAAC,MAAM,KAAK,MAAM,CAAC,iBAAiB,IAAI,QAAQ,KAAK,MAAM,CAAC,iBAAiB,CAAC;QAC9E,CAAC,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,QAAQ,KAAK,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;QACxF,OAAO;IACT,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,SAAS,CAAC;IACzD,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,iBAAiB,SAAS,GAAG,CAAC,CAAC;IACpE,IAAI,CAAC,QAAQ;QACX,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,SAAS,MAAM,iBAAiB,SAAS,GAAG,CAAC,CAAC;AACtF,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAoB,EAAE,QAAsB,EAAE,KAAc;IACtF,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC3C,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC;IACvC,MAAM,CAAC,cAAc,EAAE,gBAAgB,EAAE,GAAG,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,aAAa,CAAC,CAAC;IAEtE,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE;QACrC,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,YAAY,IAAI,IAAI;YACtB,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,CAAC,IAAI,YAAY,CAAC,CAAC;QACrD,IAAI,YAAY,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI;YAClC,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,CAAC,IAAI,kBAAkB,MAAM,CAAC,IAAI,QAAQ,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;QACjG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxC,IAAI,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK;gBAC9B,WAAW,CAAC,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;iBAC5C,IAAI,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,SAAS;gBACvC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;;gBAE/C,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;SACrC;KACF;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,MAA8B,EAAE,QAAgC;IAC3F,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QACnE,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,WAAW,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,sBAAsB,WAAW,aAAa,CAAC,CAAC;QAElE,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,WAAW,YAAY,KAAK,IAAI,aAAa,YAAY,KAAK;YAChE,WAAW,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACrC,IAAI,WAAW,YAAY,MAAM,IAAI,aAAa,YAAY,MAAM;YACvE,YAAY,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACtC,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;YACrE,WAAW,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aACrC,IAAI,WAAW,IAAI,aAAa;YACnC,MAAM,IAAI,KAAK,CAAC,aAAa,aAAa,cAAc,WAAW,WAAW,WAAW,GAAG,CAAC,CAAC;KACjG;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAsB,EAAE,QAAwB;IAC1E,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC;IAEvC,IAAI,YAAY,IAAI,cAAc,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,0DAA0D,YAAY,GAAG;YACvF,gCAAgC,cAAc,EAAE,CAAC,CAAC;KACrD;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;QACrC,IAAI,MAAM,CAAC,CAAC,CAAC,YAAY,KAAK,IAAI,QAAQ,CAAC,CAAC,CAAC,YAAY,KAAK;YAC5D,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aACjC,IAAI,MAAM,CAAC,CAAC,CAAC,YAAY,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,YAAY,MAAM;YACnE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aAClC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KACjF;AACH,CAAC;AAED,2BAA2B;AAC3B,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,MAAkB,EAAE,OAAyB;;IACtF,eAAe,GAAG,QAAQ,CAAC;IAC3B,MAAM,EAAE,CAAC;IACT,IAAI,KAAK,CAAC,eAAe,CAAC,EAAE;QAC1B,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,mCAAI,IAAI,CAAC;QACtD,KAAK,CAAC,eAAe,CAAC,CAAC,OAAO,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,CAAC;KACnD;AACH,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,MAAM,CAAC,MAA2B;IAChD,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;AACzC,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,KAAK,CAAC,KAA0B;IAC9C,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;AACvC,CAAC;AAED,SAAS,YAAY,CAAC,CAAS,EAAE,CAAU;IACzC,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAgB,aAAa,CAAC,QAAoB,EAAE,MAAY;;;QACpE,MAAM,SAAS,GAAG,QAAQ,CAAC,EAAE,CAAC;QAC9B,IAAI,aAAa,CAAC,SAAS,CAAC;YAAE,OAAO;QACrC,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QAClD,IAAI,WAAW,CAAC,gBAAgB,CAAC,KAAK,SAAS;YAC7C,WAAW,CAAC,WAAW,CAAC,KAAK,SAAS;YACtC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE;YACnG,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;YAChC,OAAO;SACR;QACD,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,UAAU,CAAC,EAAE;YACrF,MAAM,aAAa,GAAc,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YACtE,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE;gBAC7B,MAAM,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBACtC,MAAM,IAAI,GAAG,MAAA,GAAG,CAAC,GAAG,EAAE,mCAAI,CAAC,CAAC,IAAI,CAAC;gBACjC,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,GAAG,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;gBAC3E,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,SAAS;oBAChC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;gBAChD,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,EAC5C,GAAS,EAAE,gDAAC,OAAA,MAAM,CAAC,CAAC,KAAK,EAAE,CAAA,GAAA,EAAE,EAAE,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;aAC1F;SACF;QACD,MAAM,eAAe,GAAG,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,MAAM,eAAe,GAAG,EAAE,CAAC;QAC3B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAC7F,MAAM,GAAG,GAAG,IAAI,MAAM,CAAC,oEAAoE,CAAC,CAAC;QAC7F,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE;YAC7B,MAAM,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAChC,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACnC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;gBACnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACrC,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,CAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;oBAC/C,MAAM,GAAG,GAAqE,EAAE,CAAC;oBACjF,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;wBAC9B,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;4BAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;6BAC/C,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;4BAAE,GAAG,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;6BAC9D,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;4BAAE,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;6BAClD,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC;4BAAE,GAAG,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC3E,CAAC,CAAC,CAAC;oBACH,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,GAAS,EAAE;wBACrG,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;wBACjE,IAAI,GAAG,CAAC,IAAI;4BAAE,MAAM,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpC,4CAA4C;wBAC5C,IAAI,OAAO,GAAG,KAAK,SAAS,IAAI,CAAC,GAAG;4BAAE,MAAM,WAAW,KAAK,CAAC,CAAC,CAAC,wBAAwB,GAAG,EAAE,CAAC;oBAC/F,CAAC,CAAA,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;oBACnD,IAAI,GAAG,CAAC,GAAG,EAAE;wBACX,MAAM,GAAG,GAAW,gBAAgB,GAAG,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC;wBACtD,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;wBACpB,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,SAAS;4BAChC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;wBAChD,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBACnC;;wBACC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC9B;aACF;YACD,IAAI,IAAI,EAAE;gBACR,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;gBACjF,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,YAAY,EAAE,GAAS,EAAE;oBAC5D,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;oBAC1B,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC;oBAChB,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;oBAChC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS;wBACtB,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC1C,CAAC,CAAA,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAC1C,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACvB;YACD,IAAI,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE;gBAC/B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,YAAY,EAAE,GAAS,EAAE;oBACjE,MAAM,GAAG,GAAG,EAAE,CAAC;oBACf,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE;wBAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;wBACjC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;qBAC9B;oBACD,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;gBACzC,CAAC,CAAA,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAC1C,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC5B;SACF;QACD,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;QAChC,IAAI,eAAe,CAAC,MAAM;YACxB,WAAW,CAAC,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAC1E,IAAI,UAAU,CAAC,MAAM;YACnB,WAAW,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAChE,IAAI,eAAe,CAAC,MAAM;YACxB,WAAW,CAAC,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;;CAC5E;AAED,SAAS,eAAe;IACtB,MAAM,IAAI,GAAU,EAAE,CAAC;IACvB,OAAO,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACxB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAClB,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACnB,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IACpB,CAAC,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,YAAY;IACnB,OAAO,CAAC,GAAG,GAAG,MAAM,CAAC;IACrB,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;IACvB,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;IACvB,OAAO,CAAC,KAAK,GAAG,QAAQ,CAAC;AAC3B,CAAC;AAED,MAAM,UAAgB,QAAQ,CAAC,OACyE;;;;QACtG,MAAM,QAAQ,GAAG,MAAA,MAAA,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,0CAAE,IAAI,0CAAE,OAAO,CAAC;QAChE,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC9B,MAAM,OAAO,GAGP,EAAE,CAAC;QACT,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC7B,OAAO,aAAP,OAAO,cAAP,OAAO,IAAP,OAAO,GAAK,EAAE,EAAC;QACf,YAAA,OAAQ,EAAC,WAAW,uCAAX,WAAW,GAAK,IAAI,WAAW,EAAE,EAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;QAC1B,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,eAAe,EAAE,CAAC;QAC/B,IAAI;YACF,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAChD,IAAI,CAAC,CAAC,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAA,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;qBACzF,MAAA,OAAO,CAAC,OAAO,0CAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;oBAC/C,SAAS;gBACX,MAAM,CAAC,WAAW,GAAG,WAAW,CAAC,CAAC;gBAClC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACrB,MAAM,OAAO,GAAG,MAAA,KAAK,CAAC,KAAK,0CAAE,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,WAAC,OAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,CAAA,EAAA,CAAC,CAAC;gBACjE,IAAI;oBACF,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE;wBAC5B,MAAM,OAAO,CAAC,GAAS,EAAE;4BACvB,MAAM,KAAK,CAAC,MAAO,EAAE,CAAC;wBACxB,CAAC,CAAA,EAAE,MAAM,EAAE,UAAU,OAAO,CAAC,QAAQ,iBAAiB,CAAC,CAAC;qBACzD;iBACF;gBAAC,OAAO,CAAM,EAAE;oBACf,KAAK,CAAC,YAAY,GAAG,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;iBACzC;gBACD,MAAM,CAAC,GAAG,MAAA,KAAK,CAAC,KAAK,mCAAI,EAAE,CAAC;gBAC5B,MAAM,GAAG,GAAG,EAAE,CAAC;gBACf,IAAI,KAAK,CAAC,KAAK,EAAE;oBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;wBACjC,GAAG,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;wBACnG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;wBACtB,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;qBACvB;iBACF;qBAAM;oBACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE;wBAC/B,GAAG,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;iBACtG;gBACD,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;gBACtD,IAAI;oBACF,IAAI,KAAK,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE;wBAC3B,MAAM,OAAO,CAAC,GAAS,EAAE;4BACvB,MAAM,KAAK,CAAC,KAAM,EAAE,CAAC;wBACvB,CAAC,CAAA,EAAE,MAAM,EAAE,SAAS,OAAO,CAAC,QAAQ,iBAAiB,CAAC,CAAC;qBACxD;iBACF;gBAAC,OAAO,CAAM,EAAE;oBACf,KAAK,CAAC,WAAW,GAAG,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;iBACxC;gBACD,uBAAuB;gBACvB,yBAAyB;gBACzB,yBAAyB;gBACzB,IAAI,KAAK,CAAC,WAAW;oBACnB,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;gBAChH,IAAI,KAAK,CAAC,YAAY;oBACpB,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;gBAClH,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;aACvB;SACF;gBAAS;YACR,YAAY,EAAE,CAAC;SAChB;QACD,IAAI,OAAO,CAAC,WAAW,CAAC,cAAc,EAAE;YACtC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;YAClB,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;gBACnC,OAAO,CAAC,IAAI,CAAC;oBACX,QAAQ,EAAE,sBAAsB;oBAChC,IAAI,EAAE,YAAY;oBAClB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK;iBACpE,CAAC,CAAC;aACJ;SACF;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE;YACnC,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;YAC3D,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;YACxD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC;YAClC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE;gBAC5B,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,GAAG,CAAC,CAAC;gBACtD,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;gBACrD,MAAM,MAAM,GAAG;oBACb,OAAO,EAAE,OAAO,KAAK,CAAC;oBACtB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM;oBAC3C,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM;oBAC5C,MAAM,EAAE,OAAO;oBACf,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG;iBAC5C,CAAC;gBACF,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,WAAW,KAAK,GAAG,EAAE,EACrC,MAAM,EAAE,oBAAoB,WAAW,KAAK,GAAG,EAAE,CAAC,CAAC;aACtD;YACD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;gBACrB,MAAM,MAAM,GAAG;oBACb,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM;oBAChF,IAAI,EAAE,SAAS,EAAE,WAAW;iBAC7B,CAAC;gBACF,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,mBAAmB,WAAW,EAAE,CAAC,CAAC;aACvE;YACD,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE;gBAC9B,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBAC/B,MAAM,WAAW,GAAG,yFAAyF,CAAC;gBAC9G,MAAM,MAAM,GAAG;oBACb,UAAU,EAAE,UAAU;oBACtB,OAAO,EAAE,OAAO;oBAChB,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,OAAO,EAAE,QAAQ;iBAClB,CAAC;gBACF,KAAK,MAAM,CAAC,IAAI,MAAM;oBAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,QAAQ,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;gBAC3F,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC;aACnD;SACF;QACD,OAAO,OAAO,CAAC;;CAChB;AAED,SAAe,SAAS,CAAC,CAAM;;QAC7B,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAC7F,CAAC;CAAA;AAED,SAAe,QAAQ,CAAC,CAAO,EAAE,SAA6B,EAAE,IAAW,EACzE,eAAwB,EAAE,WAAoB,EAAE,OAAiB;;;QACjE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAmH,CAAC;QACxH,IAAI,IAAI,GAAW,SAAS,CAAC;QAC7B,MAAM,MAAM,GAAG,SAAS,IAAI,SAAS,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,KAAI,MAAM,CAAC;QAC7C,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAA,CAAC,CAAC,OAAO,0CAAE,UAAU,CAAC;QAC9D,IAAI,CAAC,IAAI;YACP,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,IAAI;YACF,IAAI,IAAI;gBACN,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAW,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;iBAC9D;gBACH,IAAI,QAAQ,GAAG,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,OAAO,MAAK,gBAAgB;oBACpD,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,MAAA,CAAC,CAAC,OAAO,0CAAE,OAAQ,CAAC;gBAC1D,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,QAAQ,KAAK,gBAAgB,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC;gBACjG,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAA,MAAM,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,mCAAI,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;aAC/F;SACF;QAAC,OAAO,CAAM,EAAE;YACf,QAAQ,CAAC,CAAC,CAAC,CAAC;YACZ,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;SAC3E;QACD,IAAI,CAAA,MAAA,CAAC,CAAC,OAAO,0CAAE,YAAY,KAAI,CAAC,CAAC,MAAM,CAAC,WAAW,KAAK,EAAE,CAAC,SAAS,EAAE;YACpE,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,GAAG,MAAM,CAAC;YACd,IAAI,GAAG;gBACL,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,MAAM,CAAC;YAC3C,IAAI,CAAC,OAAO,EAAE;gBACZ,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC;gBACpB,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAC3B,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC7C,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC;aACf;YACD,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;SAC7B;QACD,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,IAAI;YACP,MAAM,CAAC,YAAY,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;QACxB,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;QAChB,IAAI,CAAC,MAAM,EAAE;YACX,IAAI,MAAM,GAAG;gBACX,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,OAAO;gBAC1E,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI;aAClF,CAAC;YACF,IAAI,CAAC,CAAC,MAAM,CAAC,WAAW,IAAI,MAAM,EAAE;gBAClC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,iCAAM,GAAG,KAAE,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAG,EAAE,EAAE,CAAC,CAAC;gBACrG,MAAM,mCAAQ,MAAM,GAAK,GAAG,CAAE,CAAC;aAChC;YACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,IAAI,EAAE,EACvD,MAAM,EAAE,QAAQ,IAAI,IAAI,WAAW,KAAK,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;SACpE;QACD,OAAO,CAAC,CAAC;;CACV;AAED,6BAA6B;AAC7B,MAAM,UAAgB,KAAK,CAAC,EAAU;;QACpC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC9C,CAAC;CAAA;AAED,MAAM,UAAgB,UAAU,CAAC,YAA2B,EAC1D,QAAgB,kBAAkB,EAAE,OAAe,GAAG,EAAE,WAAmB,EAAE;;QAC7E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,UAAU,CAAC,GAAG,EAAE;gBACd,aAAa,CAAC,UAAU,CAAC,CAAC;gBAC1B,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAC3B,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,aAAa;YACb,MAAM,UAAU,GAAY,WAAW,CAAC,GAAG,EAAE;gBAC3C,IAAI,YAAY,EAAE,EAAE;oBAClB,aAAa,CAAC,UAAU,CAAC,CAAC;oBAC1B,OAAO,EAAE,CAAC;iBACX;YACH,CAAC,EAAE,QAAQ,CAAC,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC;CAAA;AAED,+DAA+D;AAC/D,MAAM,UAAgB,OAAO,CAAC,IAAwB,EAAE,WAAmB,EAAE,gBAAwB,mBAAmB;;QACtH,IAAI,OAAO,GAAQ,IAAI,CAAC;QACxB,MAAM,cAAc,GAAG,IAAI,OAAO,CAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YACpD,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBACxB,wDAAwD;gBACxD,MAAM,CAAC,aAAa,CAAC,CAAC;YACxB,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,IAAI;YACF,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC;SACrD;gBAAS;YACR,IAAI,OAAO;gBACT,YAAY,CAAC,OAAO,CAAC,CAAC;SACzB;IACH,CAAC;CAAA;AAED,MAAM,UAAU,eAAe,CAAC,WAAmB;IACjD,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACvC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,WAAW;YACjC,OAAO,IAAI,CAAC;KACf;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAgB,oBAAoB,CAAC,MAA2B,EACpE,KAAmC;;QACnC,IAAI,MAAM,GAAY,KAAK,CAAC;QAC5B,IAAI,OAAO,GAAY,KAAK,CAAC;QAC7B,IAAI;YACF,MAAM,MAAM,EAAE,CAAC;SAChB;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,GAAG,IAAI,CAAC;YACd,OAAO,GAAG,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;SAC9B;gBAAS;YACR,IAAI,CAAC,MAAM;gBACT,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC7D,IAAI,CAAC,OAAO;gBACV,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;SAC7F;IACH,CAAC;CAAA;AAED,MAAM,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjG;;;;;;;;;;GAUG;AACH,MAAM,UAAgB,UAAU,CAAC,CAAS,EAAE,EAAgB,EAAE,OAG7D;;;QAEC,MAAM,WAAW,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,mCAAI,EAAE,CAAC;QAC/C,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,mBAAmB;YAC9B,MAAM,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;QAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QAEvC,IAAI;YACF,+BAA+B;YAC/B,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YACxE,mEAAmE;YACnE,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;gBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,OAAQ,CAAC,WAAW,CAAC,CAAC;YAE3G,uDAAuD;YACvD,IAAI,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAA,EAAE;gBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC;gBACnG,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;oBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,yBAAyB,EAAE,OAAQ,CAAC,WAAW,CAAC,CAAC;aAC5H;YAED,uDAAuD;YACvD,IAAI,cAAc,GAA4C,IAAI,CAAC;YACnE,cAAc,GAAG,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,uBAAuB,CAAC,CAAC;YAClH,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;gBACtB,cAAc,GAAG,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EACrF,uBAAuB,EAAE,OAAQ,CAAC,WAAW,CAAC,CAAA;YAElD,gBAAgB;YAChB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,MAAM,EACzH,EAAE,UAAU,EAAE,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,UAAU,EAAE,CAAC,CAAC;YAC9C,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;gBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,UAAU,EAAE,OAAQ,CAAC,WAAW,EAC5G,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,MAAM,EAAE,EAAE,UAAU,EAAE,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,UAAU,EAAE,CAAC,CAAC;YAExE,oCAAoC;YACpC,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe,MAAK,KAAK,EAAE;gBACtC,EAAE,CAAC,SAAS,GAAG,KAAK,CAAC;gBACrB,MAAM,KAAK,CAAC,EAAE,CAAC,CAAC;gBAChB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBACxE,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;oBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,OAAQ,CAAC,WAAW,CAAC,CAAC;aAC5G;YAED,6BAA6B;YAC7B,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YACrF,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;gBACtB,MAAM,kBAAkB,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,EAAE,OAAQ,CAAC,WAAW,CAAC,CAAC;SAE9G;gBAAS;YACR,iDAAiD;YACjD,yBAAyB;YACzB,yBAAyB;SAC1B;;CACF","sourcesContent":["import * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\nimport { Observable } from 'rxjs';\nimport { testData } from './dataframe-utils';\nimport Timeout = NodeJS.Timeout;\nimport { changeOptionsSaveLayout, filterAsync, loadLayout, selectFilterChangeCurrent, testViewerInternal } from './test-viewer-utils';\n\nconst STANDART_TIMEOUT = 30000;\nconst BENCHMARK_TIMEOUT = 10800000;\n\nconst stdLog = console.log.bind(console);\nconst stdInfo = console.info.bind(console);\nconst stdWarn = console.warn.bind(console);\nconst stdError = console.error.bind(console);\n\nexport const tests: {\n  [key: string]: {\n    tests?: Test[], before?: () => Promise<void>, after?: () => Promise<void>,\n    beforeStatus?: string, afterStatus?: string, clear?: boolean, timeout?: number\n  }\n} = {};\n\nconst autoTestsCatName = 'Auto Tests';\nconst demoCatName = 'Demo';\nconst detectorsCatName = 'Detectors';\nconst coreCatName = 'Core';\nconst wasRegistered: { [key: string]: boolean } = {};\nexport let currentCategory: string;\n\nexport namespace assure {\n  export function notNull(value: any, name?: string) {\n    if (value == null)\n      throw new Error(`${name == null ? 'Value' : name} not defined`);\n  }\n}\n\nexport interface TestOptions {\n  timeout?: number;\n  unhandledExceptionTimeout?: number;\n  skipReason?: string;\n  isAggregated?: boolean;\n}\n\nexport interface CategoryOptions {\n  clear?: boolean;\n  timeout?: number;\n}\n\nexport class TestContext {\n  catchUnhandled = true;\n  report = false;\n\n  constructor(catchUnhandled?: boolean, report?: boolean) {\n    if (catchUnhandled !== undefined) this.catchUnhandled = catchUnhandled;\n    if (report !== undefined) this.report = report;\n  };\n}\n\nexport class Test {\n  test: () => Promise<any>;\n  name: string;\n  category: string;\n  options?: TestOptions;\n\n  constructor(category: string, name: string, test: () => Promise<any>, options?: TestOptions) {\n    this.category = category;\n    this.name = name;\n    options ??= {};\n    options.timeout ??= STANDART_TIMEOUT;\n    this.options = options;\n    this.test = async (): Promise<any> => {\n      return new Promise(async (resolve, reject) => {\n        let result = '';\n        try {\n          result = await test();\n        } catch (e: any) {\n          reject(e);\n        }\n        resolve(result);\n      });\n    };\n  }\n}\n\nexport async function testEvent<T>(event: Observable<T>,\n  handler: (args: T) => void, trigger: () => void, ms: number = 0, reason: string = `timeout`\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const sub = event.subscribe((args: T) => {\n      try {\n        handler(args);\n        resolve('OK');\n      } catch (e) {\n        reject(e);\n      } finally {\n        sub.unsubscribe();\n        clearTimeout(timeout);\n      }\n    });\n    const timeout = setTimeout(() => {\n      sub.unsubscribe();\n      // eslint-disable-next-line prefer-promise-reject-errors\n      reject(reason);\n    }, ms);\n    trigger();\n  });\n}\n\nexport async function testEventAsync<T>(event: Observable<T>,\n  handler: (args: T) => Promise<void>, trigger: () => void, ms: number = 0, reason: string = `timeout`\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const sub = event.subscribe((args: T) => {\n      handler(args).then(() => {\n        resolve('OK');\n      }).catch((e) => {\n        reject(e);\n      }).finally(() => {\n        sub.unsubscribe();\n        clearTimeout(timeout);\n      });\n    });\n    const timeout = setTimeout(() => {\n      sub.unsubscribe();\n      // eslint-disable-next-line prefer-promise-reject-errors\n      reject(reason);\n    }, ms);\n    trigger();\n  });\n}\n\nexport function test(name: string, test: () => Promise<any>, options?: TestOptions): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  if (tests[currentCategory].tests == undefined)\n    tests[currentCategory].tests = [];\n  tests[currentCategory].tests!.push(new Test(currentCategory, name, test, options));\n}\n\n/* Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual: any, expected: any = true, error?: string): void {\n  if (error)\n    error = `${error}, `;\n  else error = '';\n  if (actual !== expected)\n    throw new Error(`${error}Expected \"${expected}\", got \"${actual}\"`);\n}\n\nexport function expectFloat(actual: number, expected: number, tolerance = 0.001, error?: string): void {\n  if ((actual === Number.POSITIVE_INFINITY && expected === Number.POSITIVE_INFINITY) ||\n    (actual === Number.NEGATIVE_INFINITY && expected === Number.NEGATIVE_INFINITY) ||\n    (actual === Number.NaN && expected === Number.NaN) || (isNaN(actual) && isNaN(expected)))\n    return;\n  const areEqual = Math.abs(actual - expected) < tolerance;\n  expect(areEqual, true, `${error ?? ''} (tolerance = ${tolerance})`);\n  if (!areEqual)\n    throw new Error(`Expected ${expected}, got ${actual} (tolerance = ${tolerance})`);\n}\n\nexport function expectTable(actual: DG.DataFrame, expected: DG.DataFrame, error?: string): void {\n  const expectedRowCount = expected.rowCount;\n  const actualRowCount = actual.rowCount;\n  expect(actualRowCount, expectedRowCount, `${error ?? ''}, row count`);\n\n  for (const column of expected.columns) {\n    const actualColumn = actual.columns.byName(column.name);\n    if (actualColumn == null)\n      throw new Error(`Column ${column.name} not found`);\n    if (actualColumn.type != column.type)\n      throw new Error(`Column ${column.name} type expected ${column.type} got ${actualColumn.type}`);\n    for (let i = 0; i < expectedRowCount; i++) {\n      const value = column.get(i);\n      const actualValue = actualColumn.get(i);\n      if (column.type == DG.TYPE.FLOAT)\n        expectFloat(actualValue, value, 0.0001, error);\n      else if (column.type == DG.TYPE.DATE_TIME)\n        expect(actualValue.isSame(value), true, error);\n      else\n        expect(actualValue, value, error);\n    }\n  }\n}\n\nexport function expectObject(actual: { [key: string]: any }, expected: { [key: string]: any }) {\n  for (const [expectedKey, expectedValue] of Object.entries(expected)) {\n    if (!actual.hasOwnProperty(expectedKey))\n      throw new Error(`Expected property \"${expectedKey}\" not found`);\n\n    const actualValue = actual[expectedKey];\n    if (actualValue instanceof Array && expectedValue instanceof Array)\n      expectArray(actualValue, expectedValue);\n    else if (actualValue instanceof Object && expectedValue instanceof Object)\n      expectObject(actualValue, expectedValue);\n    else if (Number.isFinite(actualValue) && Number.isFinite(expectedValue))\n      expectFloat(actualValue, expectedValue);\n    else if (actualValue != expectedValue)\n      throw new Error(`Expected (${expectedValue}) for key '${expectedKey}', got (${actualValue})`);\n  }\n}\n\nexport function expectArray(actual: ArrayLike<any>, expected: ArrayLike<any>) {\n  const actualLength = actual.length;\n  const expectedLength = expected.length;\n\n  if (actualLength != expectedLength) {\n    throw new Error(`Arrays are of different length: actual array length is ${actualLength} ` +\n      `and expected array length is ${expectedLength}`);\n  }\n\n  for (let i = 0; i < actualLength; i++) {\n    if (actual[i] instanceof Array && expected[i] instanceof Array)\n      expectArray(actual[i], expected[i]);\n    else if (actual[i] instanceof Object && expected[i] instanceof Object)\n      expectObject(actual[i], expected[i]);\n    else if (actual[i] != expected[i])\n      throw new Error(`Expected ${expected[i]} at position ${i}, got ${actual[i]}`);\n  }\n}\n\n/* Defines a test suite. */\nexport function category(category: string, tests_: () => void, options?: CategoryOptions): void {\n  currentCategory = category;\n  tests_();\n  if (tests[currentCategory]) {\n    tests[currentCategory].clear = options?.clear ?? true;\n    tests[currentCategory].timeout = options?.timeout;\n  }\n}\n\n/* Defines a function to be executed before the tests in this category are executed. */\nexport function before(before: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].before = before;\n}\n\n/* Defines a function to be executed after the tests in this category are executed. */\nexport function after(after: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].after = after;\n}\n\nfunction addNamespace(s: string, f: DG.Func): string {\n  return s.replace(new RegExp(f.name, 'gi'), f.nqName);\n}\n\nexport async function initAutoTests(package_: DG.Package, module?: any) {\n  const packageId = package_.id;\n  if (wasRegistered[packageId]) return;\n  const moduleTests = module ? module.tests : tests;\n  if (moduleTests[autoTestsCatName] !== undefined ||\n    moduleTests[demoCatName] !== undefined ||\n    Object.keys(moduleTests).find((c) => c.startsWith(autoTestsCatName) || c.startsWith(coreCatName))) {\n    wasRegistered[packageId] = true;\n    return;\n  }\n  if (package_.name === 'DevTools' || (!!module && module._package.name === 'DevTools')) {\n    const testFunctions: DG.Func[] = DG.Func.find({ tags: ['dartTest'] });\n    for (const f of testFunctions) {\n      const arr = f.name.split(/\\s*\\|\\s*/g);\n      const name = arr.pop() ?? f.name;\n      const cat = arr.length ? coreCatName + ': ' + arr.join(': ') : coreCatName;\n      if (moduleTests[cat] === undefined)\n        moduleTests[cat] = { tests: [], clear: true };\n      moduleTests[cat].tests.push(new Test(cat, name,\n        async () => await f.apply(), { isAggregated: f.outputs.length > 0, timeout: 300000 }));\n    }\n  }\n  const moduleAutoTests = [];\n  const moduleDemo = [];\n  const moduleDetectors = [];\n  const packFunctions = await grok.dapi.functions.filter(`package.id = \"${packageId}\"`).list();\n  const reg = new RegExp(/skip:\\s*([^,\\s]+)|wait:\\s*(\\d+)|cat:\\s*([^,\\s]+)|timeout:\\s*(\\d+)/g);\n  for (const f of packFunctions) {\n    const tests = f.options['test'];\n    const demo = f.options['demoPath'];\n    if ((tests && Array.isArray(tests) && tests.length)) {\n      for (let i = 0; i < tests.length; i++) {\n        const res = (tests[i] as string).matchAll(reg);\n        const map: { skip?: string, wait?: number, cat?: string, timeout?: number } = {};\n        Array.from(res).forEach((arr) => {\n          if (arr[0].startsWith('skip')) map['skip'] = arr[1];\n          else if (arr[0].startsWith('wait')) map['wait'] = parseInt(arr[2]);\n          else if (arr[0].startsWith('cat')) map['cat'] = arr[3];\n          else if (arr[0].startsWith('timeout')) map['timeout'] = parseInt(arr[4]);\n        });\n        const test = new Test(autoTestsCatName, tests.length === 1 ? f.name : `${f.name} ${i + 1}`, async () => {\n          const res = await grok.functions.eval(addNamespace(tests[i], f));\n          if (map.wait) await delay(map.wait);\n          // eslint-disable-next-line no-throw-literal\n          if (typeof res === 'boolean' && !res) throw `Failed: ${tests[i]}, expected true, got ${res}`;\n        }, { skipReason: map.skip, timeout: map.timeout });\n        if (map.cat) {\n          const cat: string = autoTestsCatName + ': ' + map.cat;\n          test.category = cat;\n          if (moduleTests[cat] === undefined)\n            moduleTests[cat] = { tests: [], clear: true };\n          moduleTests[cat].tests.push(test);\n        } else\n          moduleAutoTests.push(test);\n      }\n    }\n    if (demo) {\n      const wait = f.options['demoWait'] ? parseInt(f.options['demoWait']) : undefined;\n      const test = new Test(demoCatName, f.friendlyName, async () => {\n        grok.shell.lastError = '';\n        await f.apply();\n        await delay(wait ? wait : 2000);\n        if (grok.shell.lastError)\n          throw new Error(grok.shell.lastError);\n      }, { skipReason: f.options['demoSkip'] });\n      moduleDemo.push(test);\n    }\n    if (f.hasTag('semTypeDetector')) {\n      const test = new Test(detectorsCatName, f.friendlyName, async () => {\n        const arr = [];\n        for (const col of testData.clone().columns) {\n          const res = await f.apply([col]);\n          arr.push(res || col.semType);\n        }\n        expect(arr.filter((i) => i).length, 1);\n      }, { skipReason: f.options['skipTest'] });\n      moduleDetectors.push(test);\n    }\n  }\n  wasRegistered[packageId] = true;\n  if (moduleAutoTests.length)\n    moduleTests[autoTestsCatName] = { tests: moduleAutoTests, clear: true };\n  if (moduleDemo.length)\n    moduleTests[demoCatName] = { tests: moduleDemo, clear: true };\n  if (moduleDetectors.length)\n    moduleTests[detectorsCatName] = { tests: moduleDetectors, clear: false };\n}\n\nfunction redefineConsole(): any[] {\n  const logs: any[] = [];\n  console.log = (...args) => {\n    logs.push(...args);\n    stdLog(...args);\n  };\n  console.info = (...args) => {\n    logs.push(...args);\n    stdInfo(...args);\n  };\n  console.warn = (...args) => {\n    logs.push(...args);\n    stdWarn(...args);\n  };\n  console.error = (...args) => {\n    logs.push(...args);\n    stdError(...args);\n  };\n  return logs;\n}\n\nfunction resetConsole(): void {\n  console.log = stdLog;\n  console.info = stdInfo;\n  console.warn = stdWarn;\n  console.error = stdError;\n}\n\nexport async function runTests(options?:\n  { category?: string, test?: string, testContext?: TestContext, exclude?: string[], verbose?: boolean }) {\n  const package_ = grok.functions.getCurrentCall()?.func?.package;\n  await initAutoTests(package_);\n  const results: {\n    category?: string, name?: string, success: boolean,\n    result: string, ms: number, skipped: boolean\n  }[] = [];\n  console.log(`Running tests`);\n  options ??= {};\n  options!.testContext ??= new TestContext();\n  grok.shell.lastError = '';\n  const categories = [];\n  const logs = redefineConsole();\n  try {\n    for (const [key, value] of Object.entries(tests)) {\n      if ((!!options?.category && !key.toLowerCase().startsWith(options?.category.toLowerCase())) ||\n        options.exclude?.some((c) => key.startsWith(c)))\n        continue;\n      stdLog(`Started ${key} category`);\n      categories.push(key);\n      const skipped = value.tests?.every((t) => t.options?.skipReason);\n      try {\n        if (value.before && !skipped) {\n          await timeout(async () => {\n            await value.before!();\n          }, 100000, `before ${options.category}: timeout error`);\n        }\n      } catch (x: any) {\n        value.beforeStatus = await getResult(x);\n      }\n      const t = value.tests ?? [];\n      const res = [];\n      if (value.clear) {\n        for (let i = 0; i < t.length; i++) {\n          res.push(await execTest(t[i], options?.test, logs, value.timeout, package_.name, options.verbose));\n          grok.shell.closeAll();\n          DG.Balloon.closeAll();\n        }\n      } else {\n        for (let i = 0; i < t.length; i++)\n          res.push(await execTest(t[i], options?.test, logs, value.timeout, package_.name, options.verbose));\n      }\n      const data = res.filter((d) => d.result != 'skipped');\n      try {\n        if (value.after && !skipped) { \n          await timeout(async () => {\n            await value.after!();\n          }, 100000, `After ${options.category}: timeout error`);\n        }\n      } catch (x: any) {\n        value.afterStatus = await getResult(x);\n      }\n      // Clear after category\n      // grok.shell.closeAll();\n      // DG.Balloon.closeAll();\n      if (value.afterStatus)\n        data.push({ category: key, name: 'after', result: value.afterStatus, success: false, ms: 0, skipped: false });\n      if (value.beforeStatus)\n        data.push({ category: key, name: 'before', result: value.beforeStatus, success: false, ms: 0, skipped: false });\n      results.push(...data);\n    }\n  } finally {\n    resetConsole();\n  }\n  if (options.testContext.catchUnhandled) {\n    await delay(1000);\n    if (grok.shell.lastError.length > 0) {\n      results.push({\n        category: 'Unhandled exceptions',\n        name: 'exceptions',\n        result: grok.shell.lastError, success: false, ms: 0, skipped: false\n      });\n    }\n  }\n  if (!options.test && results.length) {\n    const successful = results.filter((r) => r.success).length;\n    const skipped = results.filter((r) => r.skipped).length;\n    const failed = results.filter((r) => !r.success);\n    const packageName = package_.name;\n    for (const cat of categories) {\n      const res = results.filter((r) => r.category === cat);\n      const failed_ = res.filter((r) => !r.success).length;\n      const params = {\n        success: failed_ === 0,\n        passed: res.filter((r) => r.success).length,\n        skipped: res.filter((r) => r.skipped).length,\n        failed: failed_,\n        type: 'package', packageName, category: cat\n      };\n      grok.log.usage(`${packageName}: ${cat}`,\n        params, `category-package ${packageName}: ${cat}`);\n    }\n    if (!options.category) {\n      const params = {\n        success: failed.length === 0, passed: successful, skipped, failed: failed.length,\n        type: 'package', packageName\n      };\n      grok.log.usage(packageName, params, `package-package ${packageName}`);\n    }\n    if (options.testContext.report) {\n      const logger = new DG.Logger();\n      const description = 'Package @package tested: @successful successful, @skipped skipped, @failed failed tests';\n      const params = {\n        successful: successful,\n        skipped: skipped,\n        failed: failed.length,\n        package: package_\n      };\n      for (const r of failed) Object.assign(params, { [`${r.category} | ${r.name}`]: r.result });\n      logger.log(description, params, 'package-tested');\n    }\n  }\n  return results;\n}\n\nasync function getResult(x: any): Promise<string> {\n  return `${x.toString()}\\n${x.stack ? (await DG.Logger.translateStackTrace(x.stack)) : ''}`;\n}\n\nasync function execTest(t: Test, predicate: string | undefined, logs: any[],\n  categoryTimeout?: number, packageName?: string, verbose?: boolean): Promise<any> {\n  logs.length = 0;\n  let r: { category?: string, name?: string, success: boolean, result: any, ms: number, skipped: boolean, logs?: string };\n  let type: string = 'package';\n  const filter = predicate != undefined && (t.name.toLowerCase() !== predicate.toLowerCase());\n  const skip = t.options?.skipReason || filter;\n  const skipReason = filter ? 'skipped' : t.options?.skipReason;\n  if (!skip)\n    stdLog(`Started ${t.category} ${t.name}`);\n  const start = Date.now();\n  try {\n    if (skip)\n      r = { success: true, result: skipReason!, ms: 0, skipped: true };\n    else {\n      let timeout_ = t.options?.timeout === STANDART_TIMEOUT &&\n        categoryTimeout ? categoryTimeout : t.options?.timeout!;\n      timeout_ = DG.Test.isInBenchmark && timeout_ === STANDART_TIMEOUT ? BENCHMARK_TIMEOUT : timeout_;\n      r = { success: true, result: await timeout(t.test, timeout_) ?? 'OK', ms: 0, skipped: false };\n    }\n  } catch (x: any) {\n    stdError(x);\n    r = { success: false, result: await getResult(x), ms: 0, skipped: false };\n  }\n  if (t.options?.isAggregated && r.result.constructor === DG.DataFrame) {\n    const col = r.result.col('success');\n    type = 'core';\n    if (col)\n      r.success = col.stats.sum === col.length;\n    if (!verbose) {\n      const df = r.result;\n      df.columns.remove('stack');\n      df.rows.removeWhere((r) => r.get('success'));\n      r.result = df;\n    }\n    r.result = r.result.toCsv();\n  }\n  r.logs = logs.join('\\n');\n  r.ms = Date.now() - start;\n  if (!skip)\n    stdLog(`Finished ${t.category} ${t.name} for ${r.ms} ms`);\n  r.category = t.category;\n  r.name = t.name;\n  if (!filter) {\n    let params = {\n      'success': r.success, 'result': r.result, 'ms': r.ms, 'skipped': r.skipped,\n      'type': type, packageName, 'category': t.category, 'test': t.name, 'logs': r.logs\n    };\n    if (r.result.constructor == Object) {\n      const res = Object.keys(r.result).reduce((acc, k) => ({ ...acc, ['result.' + k]: r.result[k] }), {});\n      params = { ...params, ...res };\n    }\n    grok.log.usage(`${packageName}: ${t.category}: ${t.name}`,\n      params, `test-${type} ${packageName}: ${t.category}: ${t.name}`);\n  }\n  return r;\n}\n\n/* Waits [ms] milliseconds */\nexport async function delay(ms: number) {\n  await new Promise((r) => setTimeout(r, ms));\n}\n\nexport async function awaitCheck(checkHandler: () => boolean,\n  error: string = 'Timeout exceeded', wait: number = 500, interval: number = 50): Promise<void> {\n  return new Promise((resolve, reject) => {\n    setTimeout(() => {\n      clearInterval(intervalId);\n      reject(new Error(error));\n    }, wait);\n    // @ts-ignore\n    const intervalId: Timeout = setInterval(() => {\n      if (checkHandler()) {\n        clearInterval(intervalId);\n        resolve();\n      }\n    }, interval);\n  });\n}\n\n// Returns test execution result or an error in case of timeout\nexport async function timeout(func: () => Promise<any>, testTimeout: number, timeoutReason: string = 'EXECUTION TIMEOUT'): Promise<any> {\n  let timeout: any = null;\n  const timeoutPromise = new Promise<any>((_, reject) => {\n    timeout = setTimeout(() => {\n      // eslint-disable-next-line prefer-promise-reject-errors\n      reject(timeoutReason);\n    }, testTimeout);\n  });\n  try {\n    return await Promise.race([func(), timeoutPromise]);\n  } finally {\n    if (timeout)\n      clearTimeout(timeout);\n  }\n}\n\nexport function isDialogPresent(dialogTitle: string): boolean {\n  const dialogs = DG.Dialog.getOpenDialogs();\n  for (let i = 0; i < dialogs.length; i++) {\n    if (dialogs[i].title == dialogTitle)\n      return true;\n  }\n  return false;\n}\n\n/** Expects an asynchronous {@link action} to throw an exception. Use {@link check} to perform\n * deeper inspection of the exception if necessary.\n * @param  {function(): Promise<void>} action\n * @param  {function(any): boolean} check\n * @return {Promise<void>}\n */\nexport async function expectExceptionAsync(action: () => Promise<void>,\n  check?: (exception: any) => boolean): Promise<void> {\n  let caught: boolean = false;\n  let checked: boolean = false;\n  try {\n    await action();\n  } catch (e) {\n    caught = true;\n    checked = !check || check(e);\n  } finally {\n    if (!caught)\n      throw new Error('An exception is expected but not thrown');\n    if (!checked)\n      throw new Error('An expected exception is thrown, but it does not satisfy the condition');\n  }\n}\n\nconst catDF = DG.DataFrame.fromColumns([DG.Column.fromStrings('col', ['val1', 'val2', 'val3'])]);\n\n/**\n * Universal test for viewers. It search viewers in DOM by tags: canvas, svg, img, input, h1, a\n * @param  {string} v Viewer name\n * @param  {DG.DataFrame} df Dataframe to use. Should have at least 3 rows\n * @param  {boolean} options.detectSemanticTypes Specify whether to detect semantic types or not\n * @param  {boolean} options.readOnly If set to true, the dataframe will not be modified during the test\n * @param  {boolean} options.arbitraryDfTest If set to false, test on arbitrary dataframe\n * (one categorical column) will not be performed\n * @param  {object} options List of options (optional)\n * @return {Promise<void>} The test is considered successful if it completes without errors\n */\nexport async function testViewer(v: string, df: DG.DataFrame, options?: {\n  detectSemanticTypes?: boolean, readOnly?: boolean, arbitraryDfTest?: boolean,\n  packageName?: string, awaitViewer?: (viewer: DG.Viewer) => Promise<void>\n}): Promise<void> {\n\n  const packageName = options?.packageName ?? '';\n  if (options?.detectSemanticTypes)\n    await grok.data.detectSemanticTypes(df);\n  const tv = grok.shell.addTableView(df);\n\n  try {\n    //1. Open, do nothing and close\n    await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded);\n    //in case viewer with async rendering - wait for render to complete\n    if (options?.awaitViewer)\n      await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, undefined, options!.awaitViewer);\n\n    //2. Open viewer, run selection, filter, etc. and close\n    if (!options?.readOnly) {\n      await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, selectFilterChangeCurrent);\n      if (options?.awaitViewer)\n        await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, selectFilterChangeCurrent, options!.awaitViewer);\n    }\n\n    //2. Open viewer, change options, save layout and close\n    let propsAndLayout: { layout: any, savedProps: any } | null = null;\n    propsAndLayout = await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, changeOptionsSaveLayout);\n    if (options?.awaitViewer)\n      propsAndLayout = await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded,\n        changeOptionsSaveLayout, options!.awaitViewer)\n\n    //3. Load layout\n    await testViewerInternal(tv, v, packageName, grok.events.onViewLayoutApplied, loadLayout, undefined, propsAndLayout?.layout,\n      { savedProps: propsAndLayout?.savedProps });\n    if (options?.awaitViewer)\n      await testViewerInternal(tv, v, packageName, grok.events.onViewLayoutApplied, loadLayout, options!.awaitViewer,\n        propsAndLayout?.layout, { savedProps: propsAndLayout?.savedProps });\n\n    //4. Open viewer on arbitary dataset\n    if (options?.arbitraryDfTest !== false) {\n      tv.dataFrame = catDF;\n      await delay(50);\n      await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded);\n      if (options?.awaitViewer)\n        await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, undefined, options!.awaitViewer);\n    }\n\n    //5. Call postponed filtering\n    await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, filterAsync);\n    if (options?.awaitViewer)\n      await testViewerInternal(tv, v, packageName, grok.events.onViewerAdded, filterAsync, options!.awaitViewer);\n\n  } finally {\n    // closeAll() is handling by common test workflow\n    // grok.shell.closeAll();\n    // DG.Balloon.closeAll();\n  }\n}\n"]}","/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nexport const NUCLEOTIDES = ['A', 'G', 'C', 'U'];\n\nexport const TECHNOLOGIES = {\n  DNA: 'DNA',\n  RNA: 'RNA',\n  ASO_GAPMERS: 'ASOGapmers',\n  SI_RNA: 'siRNA',\n};\n\nexport enum DEFAULT_FORMATS {\n  HELM = 'HELM',\n  AXOLABS = 'Axolabs',\n}\n","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {DEFAULT_FORMATS} from '../apps/common/model/const';\nimport {ITranslationHelper} from '../types';\n\nexport class OligoToolkitTestPackage extends DG.Package {\n  async getTranslationHelper(): Promise<ITranslationHelper> {\n    return (await grok.functions.call(`${this.name}:getTranslationHelper`)) as ITranslationHelper;\n  }\n}\n\nexport function getHelm(strand: string, format: string, th: ITranslationHelper): string {\n  return th.createFormatConverter(strand, format).convertTo(DEFAULT_FORMATS.HELM);\n}\n\nexport function getFormat(helm: string, format: string, th: ITranslationHelper): string {\n  return th.createFormatConverter(helm, DEFAULT_FORMATS.HELM).convertTo(format);\n}\n","type Dict = { [key: string]: string };\n\n/* eslint-disable max-len*/\nexport const formatsToHelm: { [key: string]: Dict } = {\n  'Axolabs': {\n    'UfAfsCfsGfuacg': 'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'\n  },\n  'BioSpring': {\n    'A*GC*123456789': 'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$'\n  },\n  'Mermade12': {\n    'hefglijkLIJKHEFG': 'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'\n  }\n};\n\nexport const helmToNucleotides: Dict = {\n  'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACG',\n\n  // TODO: Handle monomer .d([m5C])\n  'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p}$$$$': 'AGCUACGUACG',\n\n  'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACGUACGUACG'\n};\n\nexport const helmToMolfile: Dict = {};\n/* eslint-enable max-len*/\n","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {getFormat, getHelm} from './utils';\nimport {ITranslationHelper} from '../types';\n\nimport {_package} from '../package-test';\nimport {formatsToHelm} from './const';\n\ncategory('Formats to HELM', () => {\n  let th: ITranslationHelper;\n\n  before(async () => {\n    th = await _package.getTranslationHelper();\n  });\n\n  for (const format of Object.keys(formatsToHelm)) {\n    for (const [strand, helm] of Object.entries(formatsToHelm[format])) {\n      test(`${format} to HELM`, async () => {\n        const expected = helm;\n        const result = getHelm(strand, format, th);\n        expect(result, expected);\n      });\n    }\n  }\n});\n\ncategory('HELM to Formats', () => {\n  let th: ITranslationHelper;\n\n  before(async () => {\n    th = await _package.getTranslationHelper();\n  });\n\n  for (const format of Object.keys(formatsToHelm)) {\n    for (const [strand, helm] of Object.entries(formatsToHelm[format])) {\n      test(`${format} to HELM`, async () => {\n        const expected = strand;\n        const result = getFormat(helm, format, th);\n        expect(result, expected);\n      });\n    }\n  }\n});\n","export const GROUP_TYPE = {\n  NUCLEOSIDE: 'nucleoside',\n  LINKAGE: 'phosphateBackbone',\n} as const;\n\nexport const PHOSPHATE_SYMBOL = 'p';\n\nexport const UNKNOWN_SYMBOL = '<?>';\n","import {DEFAULT_FORMATS, NUCLEOTIDES} from '../../common/model/const';\nimport {NUCLEOTIDES_FORMAT} from '../view/const';\nimport {UNKNOWN_SYMBOL} from './const';\nimport {MonomerLibWrapper} from '../../common/model/monomer-lib/lib-wrapper';\n\nimport {ITranslationHelper} from '../../../types';\n\nexport function getTranslatedSequences(\n  sequence: string, indexOfFirstInvalidChar: number, sourceFormat: string, th: ITranslationHelper\n): { [key: string]: string } {\n  const supportedFormats = Object.keys(th.jsonData.codesToHelmDict).concat([DEFAULT_FORMATS.HELM]) as string[];\n\n  if (!sequence || (indexOfFirstInvalidChar !== -1 && sourceFormat !== DEFAULT_FORMATS.HELM))\n    return {};\n\n  if (!supportedFormats.includes(sourceFormat))\n    throw new Error(`${sourceFormat} format is not supported by SequenceTranslator`);\n\n  const outputFormats = supportedFormats.filter((el) => el != sourceFormat)\n    .sort((a, b) => a.localeCompare(b));\n  const converter = th.createFormatConverter(sequence, sourceFormat);\n  const result = Object.fromEntries(\n    outputFormats.map((format) => {\n      let translation;\n      try {\n        translation = converter.convertTo(format);\n      } catch {\n        translation = null;\n      }\n      return [format, translation];\n    }).filter(([_, translation]) => translation)\n  );\n  const helm = (sourceFormat === DEFAULT_FORMATS.HELM) ? sequence : result[DEFAULT_FORMATS.HELM];\n  const nucleotides = getNucleotidesSequence(helm, th.monomerLibWrapper);\n  if (nucleotides)\n    result['Nucleotides'] = nucleotides;\n  return result;\n}\n\nexport function getNucleotidesSequence(helmString: string, monomerLib: MonomerLibWrapper): string | null {\n  const re = new RegExp('\\\\([^()]*\\\\)', 'g');\n  const branches = helmString.match(re);\n  if (!branches)\n    return null;\n  const nucleotides = branches!.map((branch) => {\n    const stripped = branch.replace(/[\\[\\]()]/g, '');\n    if (NUCLEOTIDES.includes(stripped))\n      return stripped;\n    return monomerLib.getNaturalAnalogBySymbol(stripped);\n  }).map((el) => el ? el : UNKNOWN_SYMBOL).join('');\n  return nucleotides;\n}\n\n// todo: remove after refactoring as a workaround\nexport function convert(\n  sequence: string, sourceFormat: string, targetFormat: string, th: ITranslationHelper\n): string | null {\n  const converter = th.createFormatConverter(sequence, sourceFormat);\n  if (targetFormat === NUCLEOTIDES_FORMAT) {\n    const helm = converter.convertTo(DEFAULT_FORMATS.HELM);\n    const nucleotides = getNucleotidesSequence(helm, th.monomerLibWrapper);\n    return nucleotides;\n  }\n\n  return converter.convertTo(targetFormat);\n}\n\nexport function getSupportedTargetFormats(th: ITranslationHelper): string[] {\n  const supportedTargetFormats = Object.keys(th.jsonData.codesToHelmDict)\n    .concat([DEFAULT_FORMATS.HELM, NUCLEOTIDES_FORMAT]).sort() as string[];\n  return supportedTargetFormats;\n}\n","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {getNucleotidesSequence} from '../apps/translator/model/conversion-utils';\nimport {ITranslationHelper} from '../types';\n\nimport {_package} from '../package-test';\nimport {helmToNucleotides} from './const';\n\n\ncategory('HELM to Nucleotides', () => {\n  let th: ITranslationHelper;\n\n  before(async () => {\n    th = await _package.getTranslationHelper();\n  });\n\n  Object.entries(helmToNucleotides).forEach(([helm, nucleotide], idx) => {\n    test(`Sequence ${idx + 1} to nucleotides`, async () => {\n      const expected = nucleotide;\n      const result = getNucleotidesSequence(helm, th.monomerLibWrapper);\n      expect(result, expected);\n    });\n  });\n});\n","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {DEFAULT_FORMATS} from '../apps/common/model/const';\nimport {getTranslatedSequences} from '../apps/translator/model/conversion-utils';\nimport {ITranslationHelper} from '../types';\n\nimport {_package} from '../package-test';\nimport {formatsToHelm} from './const';\n\n\nfunction getTranslationObject(sequence: string, format: string, th: ITranslationHelper): { [format: string]: string } {\n  const indexOfInvalidChar = th.createSequenceValidator(sequence).getInvalidCodeIndex(format);\n  return getTranslatedSequences(sequence, indexOfInvalidChar, format, th);\n}\n\nconst inputs = {\n  [DEFAULT_FORMATS.AXOLABS]: 'Afcgacsu',\n  [DEFAULT_FORMATS.HELM]: 'RNA1{[fR](A)p.[25r](C)p.[25r](G)p.[25r](A)p.[25r](C)[sp].[25r](U)}$$$$'\n};\n\ncategory('Formats support', () => {\n  let th: ITranslationHelper;\n\n  before(async () => {\n    th = await _package.getTranslationHelper();\n  });\n\n  Object.entries(inputs).forEach(([format, sequence]) => {\n    test(`All formats for ${format}`, async () => {\n      const output = getTranslationObject(sequence, format, th);\n      const result = Object.keys(output).length;\n      // +1 due to nucleotides\n      const expected = Object.keys(formatsToHelm).length + 1;\n      expect(true, expected <= result);\n    });\n  });\n});\n","export function errMsg(err) {\n    if (typeof err === 'string' || err instanceof String)\n        return err;\n    else if (err.constructor.name === 'StateError')\n        return err['message'];\n    else if (err.constructor.name === 'StateError' && '$thrownJsError' in err)\n        return errMsg(err['$thrownJsError']);\n    else if (err instanceof Error)\n        return err.message;\n    else\n        return err.toString();\n}\nexport function errStack(err) {\n    if (err instanceof Error)\n        return err.stack;\n    else if (err.constructor.name === 'StateError' && '$thrownJsError' in err)\n        return errStack(err['$thrownJsError']);\n    return undefined;\n}\nexport function errInfo(err) {\n    return [errMsg(err), errStack(err)];\n}\n//# sourceMappingURL=err-info.js.map","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';\nimport {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';\n\nimport {getHelm} from './utils';\n\nimport {_package} from '../package-test';\nimport {ITranslationHelper} from '../types';\n\ncategory('files', () => {\n  let th: ITranslationHelper;\n\n  before(async () => {\n    th = await _package.getTranslationHelper();\n  });\n\n  test('list', async () => {\n    /** [subTest, success, format, src, res, tgt, error, stack ] */\n    let successCol: DG.Column<boolean>;\n    const resDf = DG.DataFrame.fromColumns([\n      DG.Column.string('subTest'),\n      successCol = DG.Column.bool('success'),\n      DG.Column.string('format'),\n      DG.Column.string('src'),\n      DG.Column.string('res'),\n      DG.Column.string('tgt'),\n      DG.Column.string('error'),\n      DG.Column.string('stack'),\n    ]);\n\n    const fiList = await _package.files.list('tests', true, '.csv');\n    for (const fi of fiList) {\n      const testDf = DG.DataFrame.fromCsv(await fi.readAsString());\n      const srcCol = testDf.columns.byIndex(0);\n      const format = srcCol.name;\n      const tgtCol = testDf.columns.byIndex(1);\n      const testDfRowCount = testDf.rowCount;\n      for (let rowIdx = 0; rowIdx < testDfRowCount; ++rowIdx) {\n        const row = resDf.rows.addNew();\n        row['subTest'] = `${fi.name}, row: ${rowIdx}`;\n        try {\n          const src = srcCol.get(rowIdx);\n          const tgt = tgtCol.get(rowIdx);\n          row['format'] = format;\n          row['src'] = src;\n          row['tgt'] = tgt;\n          const res = row['res'] = getHelm(src, format, th);\n          expect(res, tgt);\n          row['success'] = true;\n        } catch (err) {\n          const [errMsg, errStack] = errInfo(err);\n          row['error'] = errMsg;\n          row['stack'] = errStack;\n          row['success'] = false;\n        }\n      }\n    }\n\n    if (resDf.rowCount == 0) {\n      const emptyRow = resDf.rows.addNew(\n        ['empty', true, '', '']);\n    }\n\n    const failedTestIdx = successCol.toList().findIndex((s) => s != true);\n    if (failedTestIdx != -1) {\n      const fRow = resDf.rows.get(failedTestIdx);\n      throw new Error(`Subtest '${fRow['subTest']}' failed: ${fRow['error']}`);\n    }\n\n    return resDf;\n  }, {skipReason: 'Can not create test in async manner based on files in Shares.'});\n});\n","import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';\n\nimport './tests/formats-to-helm';\nimport './tests/helm-to-nucleotides';\nimport './tests/formats-support';\nimport './tests/files-tests';\n\nimport {OligoToolkitTestPackage} from './tests/utils';\n\nexport const _package = new OligoToolkitTestPackage();\nexport {tests};\n\n//name: test\n//input: string category {optional: true}\n//input: string test {optional: true}\n//input: object testContext {optional: true}\n//output: dataframe result\nexport async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {\n  const data = await runTests({category, test, testContext, verbose: true});\n  return DG.DataFrame.fromObjects(data)!;\n}\n"],"names":["exports","__esModule","digestLength","blockSize","K","Uint32Array","hashBlocks","w","v","p","pos","len","a","b","c","d","e","f","g","h","u","i","j","t1","t2","Hash","this","state","Int32Array","temp","buffer","Uint8Array","bufferLength","bytesHashed","finished","reset","prototype","clean","length","update","data","dataLength","Error","dataPos","finish","out","left","bitLenHi","bitLenLo","padLength","digest","_saveState","_restoreState","from","HMAC","key","inner","outer","pad","istate","ostate","hash","hmac","fillBuffer","info","counter","num","hkdfSalt","hkdf","salt","okm","hmac_","bufpos","fill","pbkdf2","password","iterations","dkLen","prf","ctr","t","dk","k","factory","sha256","module","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","call","definition","o","Object","defineProperty","enumerable","get","obj","prop","hasOwnProperty","r","Symbol","toStringTag","value","DG","grok","testData","fromCsv","columns","add","fromList","BYTE_ARRAY","Array","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","result","done","then","apply","STANDART_TIMEOUT","BENCHMARK_TIMEOUT","stdLog","console","log","bind","stdInfo","stdWarn","warn","stdError","error","tests","autoTestsCatName","demoCatName","detectorsCatName","coreCatName","wasRegistered","currentCategory","assure","notNull","name","TestContext","constructor","catchUnhandled","report","Test","category","test","options","_a","timeout","push","actual","expected","tests_","clear","before","addNamespace","s","replace","RegExp","nqName","getResult","x","toString","stack","translateStackTrace","execTest","predicate","logs","categoryTimeout","packageName","verbose","_b","_c","_d","_e","_f","type","filter","toLowerCase","skip","skipReason","start","Date","now","success","ms","skipped","timeout_","isInBenchmark","isAggregated","col","stats","sum","df","remove","rows","removeWhere","toCsv","join","params","res","keys","reduce","acc","assign","usage","setTimeout","func","testTimeout","timeoutReason","timeoutPromise","_","race","clearTimeout","fromColumns","fromStrings","NUCLEOTIDES","DEFAULT_FORMATS","OligoToolkitTestPackage","getTranslationHelper","getHelm","strand","format","th","createFormatConverter","convertTo","HELM","getFormat","helm","formatsToHelm","helmToNucleotides","async","_package","entries","UNKNOWN_SYMBOL","getNucleotidesSequence","helmString","monomerLib","re","branches","match","map","branch","stripped","includes","getNaturalAnalogBySymbol","el","forEach","nucleotide","idx","monomerLibWrapper","inputs","AXOLABS","errMsg","err","String","message","errStack","errInfo","sequence","output","indexOfFirstInvalidChar","sourceFormat","supportedFormats","jsonData","codesToHelmDict","concat","outputFormats","sort","localeCompare","converter","fromEntries","translation","nucleotides","getTranslatedSequences","createSequenceValidator","getInvalidCodeIndex","getTranslationObject","successCol","resDf","string","bool","fiList","files","list","fi","testDf","readAsString","srcCol","byIndex","tgtCol","testDfRowCount","rowCount","rowIdx","row","addNew","src","tgt","failedTestIdx","toList","findIndex","fRow","testContext","_g","package_","getCurrentCall","package","packageId","id","moduleTests","find","startsWith","testFunctions","tags","arr","split","pop","cat","outputs","moduleAutoTests","moduleDemo","moduleDetectors","packFunctions","functions","reg","demo","isArray","matchAll","parseInt","eval","wait","friendlyName","lastError","hasTag","clone","semType","initAutoTests","results","categories","args","redefineConsole","exclude","some","every","beforeStatus","closeAll","after","afterStatus","successful","failed","failed_","passed","logger","description","runTests","fromObjects"],"sourceRoot":""}